Browse Books

Reviewer: Mordechai Ben-Menachem

This book arrived for review on my birthday, which I found rather nice. Then I saw “UML” on the cover; this, and the overall size of the book (over 500 pages) led me to open it with some trepidation. Since I have never considered Unified Modeling Language (UML) “the bee’s knees” or viewed object-oriented (OO) techniques as the ultimate in engineering, I was suddenly less excited. Fortunately, I was in for a very pleasant surprise. The book is quite well written and is even enjoyable. Even the subtitle is correct: it is practical, it is a guide, and it really shows how to get the job done with reasonable effort and within an acceptable skill-level. However, any book has two “parents”: the author (in this case, two authors) and the publisher. The authors did a first-rate job, but the publisher seems to have done a slightly rushed job, where quality was not a prime concern. Considering the quality of authorship, this is a pity. The book uses a relatively new and refreshing way of looking at performance to describe how to do a job well, and do it right the first time. The authors have a remarkable habit of stating things that made me exclaim, “why didn’t I ever think of it!” In the first 22 pages, I found several statements warranting improvements in the way software design is taught. If the authors are not careful, they may actually make software less expensive to create. On the other hand, I also found three typographical errors that good editing should have corrected. After that, I stopped counting them, but there are more there. Really skilled editing would also have reduced the volume to a more comfortable size. The authors describe a methodology for understanding, estimating, designing, and planning performance as an integral part of the system solution. They make their case in an excellent step-by-step style that is easily to follow. They even went to the trouble—missing in too many books—of showing the reading steps for different reader types (for example, what sections a programmer should read as opposed to a manager). This was very helpful and much appreciated. The authors also cover how to use their process for different types of systems: graphical user interface (GUI) systems, embedded and Web applications, and so on. Patterns (how to do things right) and anti-patterns (how things are usually done wrong) are both given so that the user can plunge into the concepts at whatever depth is most suitable. The book is well illustrated, and the margins are well used, showing pointers and comments to help the reader find what is needed quickly. An example in point is the section on improving scalability (12.3.2). This is certainly a substantial issue in most development today, but methods are quite rare. All of the important issues seem to be covered here. One not only finds out how to improve scalability, but one gets enough background, well balanced with references, to delve into it more deeply, if that becomes necessary. While this is not designed as a textbook, it appears to be well suited as such. I hope the publisher produces a second edition with a little more care with regard to typographical errors. It will be the classic in the field. Online Computing Reviews Service