As a computer science (CS) academic responsible for supervising and marking large student projects, I am used to being presented with pages and pages of unified modeling language (UML) diagrams; this usually drives me to despair as it is not clear how the projects have actually benefited from the use of such formal specifications of software architectures. Often students are taught that a software architecture is first designed and then there is a one-way process of refinement to code, which can then be integrated, tested, and analyzed.

This book provides an alternate and much more sensible approach, which I hope is adopted by more and more software designers and engineers. One of the main benefits of a formal description of the software architecture is that it allows the use of powerful simulation techniques to robustly examine a design before effort is expended in coding in detail. According to the Palladio approach, a specification is extended with information that allows simulation--such as the resources required (for example, central processing unit (CPU) time) as well as the probability of failure--and graphs are produced that allow comparison with variant designs. The same software that is automatically generated for simulation can in fact be used as a starting point for the final coding.

Palladio is a software architecture simulator that supports architectures specified in the Palladio component model via a set of add-ons, which perform tasks such as reliability analysis, performance analysis, and forward engineering. The component model is similar to--but simpler than--the popular UML; the simplifications allow the different tools to be used and ensure consistency. Models can be created within an Eclipse front-end, which also allows the add-ons to be invoked.

The book is a very clear and well-presented description of the language and the tool. Extensive information is available on the website, but the book provides a much more accessible introduction and can be used by both experienced software engineers as well as students, though a certain level of knowledge of issues surrounding large software packages is useful. The language is rather dry, but the book is illustrated by many diagrams. Good use is made of a case study, the design of a media store and the use of performance analysis to compare several options. The book attempts to be quite pragmatic and helpful to potential users, but without getting bogged down by details of what the user must do to open the tool, or run the case study--it is expected that users can manage this without hand-holding. Thus, it works well both as a practical manual and as a readable introduction. While the chapters are presented with distinct authors, the whole volume is seamlessly put together, with excellent editing. There is an extensive bibliography, and throughout the authors explain the pros and cons of the described approach.

Overall, this well-produced volume shows the potential of what is clearly a highly professional and refined toolkit, of use to software engineers as an alternative to UML and related tools. I can see myself having a go at using Palladio if and when I am once again involved in a large software development project.