Customer Reviews (6)

The best thinking on documenting software architecture
Simply put, I think this book represents the best thinking about documenting software architectures. You can find other books that include different aspects covered in this book (documenting views, 4+1, ANSI/IEEE-1471-2000, etc). However, you will have a hard time finding a book that pulls it all together, provides the rationale and includes the "beyond" part which discusses other approaches to documenting software architectures and how they relate to the "Views and Beyond" (V&B) approach. For instance, the book discusses how to use V&B to comply with ANSI/IEEE-1471-2000.

detailed advice about designing
Clements shows how to use various notations to document your software design. Of these, perhaps UML is now the most common. The advice in the text can be used to first design your code, before programming. Certainly, you should somehow have a design laid out first. You do, don't you?

The book offers structural advice about how to do this. From the low level "mechanical" details of the UML notation, to more general conceptual issues. Various possible architectures are outlined. Client-server, n-tier and peer-to-peer. Enough to get you started in implementing these ideas.

The best to date
Software architecture really is unlike any other aspect of its design. The architecture has deeper meaning and larger scale than any other aspect, and can't be discussed in the same ways.

This book opens that discussion. Among the "architecture" books I've read lately, this is the only one to offer concrete advice on describing, presenting, and analyzing archtiectural features of a system. It identifies a number of documentation types and variations. It also identifies a number of different readers - developers, future architects, users, etc. - and addresses their different documentation needs.

The authors use a little UML, but not a lot. For one thing, standard UML works at too low a level for architectural discussion. Classes, and even hierarchies of class inheritance are such fine-grained entities that architecture gernerally won't address them. Instead, the authors offer a number of diagramming styles of their own. For once, I agree with the need for non-standard notation.

Even so, I think they under-utilize the existing standards in favor of their own terminology and notation. They could have used a UML profile for lots of the discussion. It would have had to be a new profile, however, not just a force-fit of the real-time profile. They also under-used the existing architecture standards (IEEE/ANSI, DoD, NASA, and more) in favor of their own discussion. Maybe their approach can be used in any of those frameworks, but that should have been more explicit.

I see only one major flaw in this book, the assumption that a software system's architecture describes the program delivered to a customer. That's way too narrow. A large system includes things like test harnesses, debug instrumentation, application-specific QA tools, and user documentation of many kinds. Those can be major undertakings of their own. They are intimately tied to the delivered software, and may constrain the actual product.

On the postivie side, this book offer an extensive real-world case study. That probably doubles the book's value, by putting a concrete face on the otherwise abstract discussion.

There are two ways to use this book: you can agree with it, or think about it and disagree with it. If you really think about it, though, you get it's full value whether you agree or not.

In other words, you can't lose by reading this book.

Quite skimpy
This is not a bad introductory documentation book, but quite skimpy in the amount of information and examples it contains.
Not sure it is worth buying at that price. I bought it after reading the previous reviews - I think they overrated it!

The only technical documentation book you'll need
After reading my colleague's comments I rushed out and purchased this book.I, too, am trained and certified in Information Mapping© and was impressed at how closely the approach in this book is aligned to that method.However, what I like most is the fact that this book can be used as guidance for a wider scope than just documenting software architectures because it shows how to organize your documentation requirements, develop clear documentation and manage the entire process from start to finish.

I also like the clearly articulated and illustrated advice about how to augment text with graphics, and how to select the views and associated graphics to document requirements, specifications and the finished architecture.An example of how this book goes beyond documenting just architectures is a project in which I was engaged two years ago.One of the major deliverables was a set of operations guides.While this is related to architecture with respect to how its used after it's in production, there were no books that fully described how to go about it in a coherent way.Using the advice and techniques in this book I could have greatly improved upon what I did produce.While I cannot change the past, you can be sure that I'll use this book to its fullest the next time I need to write ops guides, especially when it comes to showing component and connector views, and elements and relations.

If you do technical writing either professionally or as a part of your job get this book and keep it nearby.If you read and use the material you're ability to communicate will surely improve, and you'll be able to tailor your documentation to each segment of your audience (business and technical), as well as to clearly communicate information.You'll also learn much about managing the documentation process itself. ... Read more