Rating: 
Summary: A Game of Two Halves
Review: Like the famous description of soccer, this book is very much a "game of two halves". Half the book, maybe more, discusses the role of a software architect - the architect's approach, attitude, responsibilities, processes and techniques. This is excellent: clear and concise, encouraging if you are a newcomer but still stimulating if you are a more seasoned architect. It is without doubt one of the best descriptions I have read. Unfortunately, the other half of the book is less useful. The technical parts are either too simplistic, or too detailed when discussing a particular solution favoured by the authors. The text frequently tends to become a repetitive and thinly-disguised commercial for CORBA, and there is an obsession with standards such as RM-ODP which are simply not relevant to a great many commercial developers. The few examples are very simplistic, with no real discussion of many of the technical issues which a real architecture must address. The book would have been much better for more care in its editing and presentation. The quality of proof-reading is in general poor, but becomes quite appalling in some of the technical sections - evidence perhaps that the authors allowed their technical stance to dictate a poor choice of word processor. The choice of diagrams seems random: some are good, but some difficult discussions cry out for a diagram (horizontal and vertical partitioning, for example), while in other places a diagram confuses where the text is clear. The reference list is incomplete, omitting even the authors' "primary" reference which is quoted, frequently, in the text. All this is doubly disappointing when you consider that one of the authors is the series editor, and both were co-authors of the excellent "AntiPatterns" book. My advice: if you are happy with the technological side of software architecture, and want advice on how to be a better architect, then buy this book, but read chapters 5 through 9 before you even attempt to read the first part. If, however, you are seeking technical guidance in the real world of software from Microsoft, Oracle and a host of legacy systems, then look elsewhere.
Rating: 
Summary: Interesting idea, but badly executed
Review: Software Architect Bootcamp offers a good selection of topics and an interesting organizational metaphor. Unfortunately, this title doesn't fulfill its promise, suffering from poor writing, ineffective use of illustrations and examples and a dismal quality of editorial work.
Rating:
Summary: Very uneven
Review: The book starts out great, talking about the architect role and what an architect should and shouldn't do. After a dozen pages or so, it dives into a prolonged and repetitive discussion of COM+ vs CORBA, mislabeled as "Basic Training". Towards the end of the book, the author returns to relevant subjects and makes many excellent observations on the human factors to consider when doing architecture work.
Rating: 
Summary: Poorly edited but lives up to title
Review: The title of this book is appropriate because bootcamp is an intense indoctrination of fundamental skills and discipline. Bootcamp prepares recruits for the real world in which they are further trained in a specialty and become part of a team that has a shared mission. In the case of software architecture, this book's approach to bootcamp is narrow in that it focuses on component-based architecture instead of a more general and encompassing treatment of this aspect of software engineering. Despite the narrow focus, this book covers some important fundamentals that will serve the new or aspiring architect well in his or her career path or job. What I like most about the book is that it's independent of vendors and products. The foundation is, instead, based on standards and methods that are important to the discipline of software engineering in the component-based development domain. An excellent example is RM-ODP (Reference Model for Open Distributed Processing), which allows you to decompose an architecture into viewpoints to examine specific dimensions of requirements. Even if you do not adopt RM-ODP, the paradigm is a great foundation for architecture. Moreover, the Unified Modeling Language (UML)is placed into context with respect to architecture. Finally, although I personally believe CORBA has some problems, the mechanics and concepts are solid foundation material for understanding object request broker infrastructure as one building block of an architecture. There are some things I do not like about the book. The oscillations between high- and low-level details are akin to a roller coaster and it's disorienting to a reader who is intent on learning the basics of architecture. The lack of good editing makes the book read like a patchwork instead of an "intense indoctrination." Editing and writing problems notwithstanding, this book is a worthwhile (if ponderous) resource on an important aspect of software architecture for the new practitioner. Although the focus is on component-based development, the fundamentals can be extended into a more general view of architecture that will prepare the architect for his or her specialization in the real world.
Rating:
Summary: In serious need of an editor...
Review: This book should be required reading in technical writing classes as an example of how *not* to write. Not only is the writing style poor (runons, poor cutting and pasting) but there are logical errors abounding as well. And I didn't even manage to get through the introductory chapter...
Rating:
Summary: Muddled, biased and error-laden
Review: To be fair, I have not completed reading this book, and probably won't. I have sufficient evidence though to arrive at the above conclusion. One of the first things I noticed when I began reading this book was the abundance of typos and tortured phraseology. I found myself re-reading sentences several times only to finally realize that a word was missing or tense was incorrectly applied. The sentences were also choppy and not connected well. Once could argue that these qualities are superficial and we may give the authors a pass on this aspect if the information contained is useful. Well, as I have not read the entire book, I don't really know how much is useful. I do know, however, that the authors have extremely biased and, in my opinion, faulty perceptions about various things, include OO programming and Microsoft technologies. The authors complain incessantly about the "failures" of OO and the virtues of component-based development. I agree that CBD is a very useful approach. I discount though the fundamental premise of the authors that OO is faulty and CBD is the next Holy Grail. I would argue that, in fact, CBD is merely a natural extension to *good* OO design. Apparently, the authors have never been on a project that adopted rigorous application of fundamental principles of OO, such as design by contract, the open-closed principle, cohesion, low coupling, etc. Indeed, CBD facilitates some of these principles but certainly doesn't supplant them. The authors' love of CORBA was also annoying. No doubt, CORBA is significant and has a place in any good book on systems architecture. Microsoft technologies, however, were slighted (sometimes subtly, sometimes not) and ridiculed. No mention whatsoever was made, for example, of the very significant .Net initiative (or if there was, I couldn't find one). Fortunately, I saved my receipt.
Rating:
Summary: I would recommend Bootcamp for Novices and Pros
Review: Written in an unusual style, Bootcamp had immediate appeal. My first reaction as a practicing Architect was that I didn't need a Bootcamp and the material would be too basic. I was pleasantly suprised. Scattered throughout the book are numerous focus sections written in the style of Essays. I consider some of the material "very basic" but good for novices and a strong wake-up call to long time practicioners about the essentials of being a Software Architect. The book was co-sponsored by the Worldwide Institute of Software Architects (WWISA, ... ). I urge anyone interested in the developing profession of Software Architect to visit the site. Bootcamp provides not only useful details on just emerging Software Architecture approaches but places many of these within a historical framework - more than you would gain from a simple survey of the supporting white and academic papers. Bootcamp is also a decent journeyman's How-To. In my first pass, I jumped around to different sections that gained my interest and was rarely disappointed. From an introductory section on the use of UML to a small section (9.9) labeled Psychological Akido: Guarding your Gourd, I found Bootcamp to speak to our (Software Architects) current needs. Bootcamp rarely travels into a fuzzy haze. I do believe the authors' zeal for RM-ODP came across a bit too strong - but perhaps they know something I do not know. I am on my second pass through the book and have a better understanding of the goals of the work. I recommend Bootcamp for novices and experts alike. It is a good starter kit as well as providing comfort to all practicioners that they are not alone.
Rating:
Summary: Use this to get references to what you should read
Review: You can find a cheaper way to get references on what you should study to be an architect. Unfortunatly this book tries to cover too much and only gives superficial overviews of the subjects.
Rating:
Summary: An Updated Second Edition
Review: [A review of the SECOND EDITION!] Of the various software tasks, like writing in assembly, writing in a third generation language,..., the highest level can offer the greatest value added or subtracted. This is the level of architecture, which is covered in this book, recently updated to reflect the latest industry practices. The book tries to help you make strategically correct decisions EARLY in a project. Should you go for a client-server architecture, for example. If so, then it shows how you probably need familiarity with Remote Procedure Calls and the Distributed Computing Environment and with CORBA. Or maybe you should use an Object Oriented technology? Helpfully, the book guides you towards Java and J2EE as a development platform to do this. But it also suggests C# and .NET as an alternative platform. The authors are thoughtful enough to suggest that you steer away from a procedural paradigm if you have a commercial project, though they do give a careful, respectful description of what that approach is. The book covers more topics than just the above. I mentioned those because they may well be the most useful to you. Other important topics are the solidying of UML as the industry's standard design notation, and the use of XML as the most robust format for data interchange. Malveau and Mowbray write in a clear, down to earth style. Yes, they describe the standard jargon, because you need to know this. But the prose thankfully minimises the interspersed sprinkling of acronyms. In other words, you can read entire sections fluidly, and understand them, without having to constantly refer to a glossary of obscure acronyms.
| 
