This is a solid work on SEI's ADD methodology. The authors fully document the ADD methodology in terms of incorporating this into your practice. Clear text, diagrams, and illustrations depict how you bridge the gap between theory and practice.

If you're looking to use, or enhance, how to leverage your use architecture, I recommend this book. ADD is a method that values the business intent of the software, and constructs a method that delivers value to the customer.

There are some weak chapters, which prevent me from giving a 5-star rating. For example, Chapter 10 addresses reverse engineering an architecture. The focus was on a point exercise that is not useful in either theory or practice. Other case studies in the book (there are a few) were not helpful as they did not have the keys to turn the theory into practice. For example Chapter 16 addressed a J2EE/EJB study; however it was very high-level and omitted important details to be used in practice. However, the case study of an avionics system (Chapter 3) was good; it provided insight in how to apply theoretical concepts.

I recommend this book for those organizations looking for a solid value-add approach to improving your architectures both technically, and in customer value.

This text is chock full of "Case Studies" in Architectural design & development methods, but surpringinly sparse in specifics. The authors' take an approach that is almost entirely qualitative; I was hoping to see a more analytical set of methods for analysing architectures, but found little.

This book is great to gain theoritical knowledge about software architecture, but it lacks practical insights. May be it's my specific problem, because I was trying to find a good book on architecture of web applications, which this book does not provide.

What is arguably the best analogy to the creation of the large, modern software product is the construction of the great pyramids of Egypt: any error made in laying down the lower layers was magnified many times over when the additional layers were added. The placement of even a single component required the coordinate actions of many workers. Large detailed plans were necessary before the first block could be laid and while no precise deadline existed, there was a general one. Finally, despite their impressive size, the pyramids were built by applying simple components while following a well-understood pattern for integration.
Therefore, as so many people are now pointing out, software engineers can learn much from the masters of construction.
Architecture (architorture to students of the craft) is a very difficult area to master. The human mind processes information based on patterns, but much of that efficiency is based on experienced patterns, and abstractions rarely come easy even to the prepared mind. In this book, the authors do a great deal to assist "open minds" in preparing to understand and use architectural patterns.
To present their ideas, the authors coined the phrase, "Architecture Business Cycle" (ABC). This phrase is designed to describe the entire process, from the initial itch on the back of the brain, to the influence of the architecture of one product in succeeding generations of products. Only when the consequences to future generations of software are included can we truly say we are describing the complete software life cycle.
The approach used is a combination of explanation and case studies. Seven of the nineteen chapters are case studies that generally are well-done examples of the material. The core of the book, however, is the development of the steps in the construction of the ABC. The first step is the creation and analysis of a specific architecture. To perform the analysis, the authors put forward the Software Architecture Analysis Method (SAAM), a scenario-based method of evaluation. This technique is also one of the components of an architecture-review process.
After the architecture is developed, it is time to create an equivalent system based on the design. To do that, a symbolic notation is needed. While there is some time spent on Architecture Description Languages (ADLs), this is one topic that should have been expanded. Without a common language that has a high degree of precision, there is a great deal of room for potential error. The analogy or metaphor that clarifies a concept for one person makes it less comprehensible for others. An example of an ADL is presented, but seven pages containing diagrams is not enough to do more than spark interest or confusion.
The final area concerns the reuse of components and architecture. Two chapters are devoted to this topic, one on reuse within an organization and the other on reuse within the community. Within an organization, the emphasis is on the other software product line-a series of products in both parallel and sequential development. Creating a "reasonable" match to a consumer's requirements in the software development equivalent of real time is achievable only if there is an extensive stock of well-designed components that work and play well with each other. The only way to achieve this is to make such behavior part of the fundamental design. In the modern era of global competition, exposing your architectural designs to the world might seem to be a poor business practice. However in many areas this is not the case.
Software developers can learn a great deal from the construction engineers of the ancient world. When planning a complex structure, the medieval architect commonly attacked the problem from a multigenerational perspective. Knowing the project would not be completed for decades, the initial architectural plans included the passing of the necessary legacy knowledge down to the later generations of planners and builders. Only then could there be a guarantee of completion and long-term viability. The ABC as put forward in this book is one way the computer industry can approach problems from the same perspective.

Published in Journal of Object-Oriented Programming, posted with permission.

Some would have trouble describing the discipline of Software Architecture in a concise sentence... Writing a book about it is a bigger challenge.

What I like about this book is that it spells out succinctly some of the principles that software architects should adhere to... and then identifies why they sometimes should not. The tradeoffs, while not discussed in the light of a common problem, but mostly as a comparison between two or more 'reference architectures', become clear once the reader can frame the problem in a way that applies to her own architectural dilemmas.

On the other hand, the book now shows its age. While CORBA makes for a good case study, most software architects would benefit from a Web-Services study, and the patterns that are being used there.

Overall, a good book but I would recommend you flipping through it to figure out if it would help you in your day-to-day activities - or whether another Software Architecture book is more suitable.