UML Demystified Book

A book well worth considering as the supporting textbook for an introductory, undergraduate two-semester course on Software Engineering. Bruegge and Dutoit also claim it can be used for an introductory 16 week long course by covering the first three sections of each of its sixteen chapters. By omitting the chapter on rationale management and compacting the five chapters on design, it may be possible to squeeze it, with some reservations, into twelve weeks.

It is a tighter, more cohesive book than Ian Sommerville´s or Roger Pressman´s well known textbooks. It manages this cohesion by focusing on object-oriented software engineering, introducing Unified Modeling Language (UML) models very early on (chapter 2) and using them exhaustively thoughout the book, and by working on different facets of the same case study, the development of a game tournament framework in all chapters. The constant use of UML is in fact, the book´s greatest strength and, possibly its greatest weakness -its greatest strength because not only does it continually reinforce the use of UML but it provides a consistent definitory framework for such disparate topics as analysis, design, testing, configuration management and project management; its greatest weakness, because in order to model such topics its has had to adjust and introduce some non-standard terminology and skirt some real-life conceptual ambiguity. However, it also does its best to refer to IEEE standards whenever possible.

Taking into account that this is an introductory book, its best chapters are on analysis and design, particularly detailed design. Of course, if you want to delve more deeply into requirements elicitation and analysis, turn to Sommerville. As for design, there is little on software architecture (quite rightly in my opinion, given the introductory nature of the book) and object-oriented design patterns. The impedance problem beween object-oriented software and (relational) database management systems is touched upon and skirted around in a very practical way.

The chapter on testing is barely adequate for an introductory course and rather confusingly, rewords some key definitions, such as that of structural testing, several times, shifting their meaning as the authors attempt to distinguish between different categories of (overlapping) categories such as structural and system testing. It briefly introduces U2TP, a UML profile for testing, that does not add much value in such an introductory course, and does not even mention random testing techniques (for an excellent introduction to such techniques see John Regehr and Sean Bennet´s e-course on testing at ), while its section on automated testing focuses on JUnit, a unit testing tool, leaving out other important tools.

The chapter on configuration management is, as most general books on software engineering, long on definitions (and in this chapter is where the authors most rework terminology) and short on practice. It focuses exclusively on centralized configuration managers and thus needs to be updated as regards so-called third generation distributed configuration managers, such as Git. The key trade-off in configuration management practice between parallel work and merging complexity is not touched upon.

The most idiosyncratic chapter in the book is on Rationale Management, which I found interesting but which I do not consider mainstream enough for an introductory course. Rationale Management applies Knowledge Management techniques to software development, but, as the authors admit, maintaining this knowledge up to date in a changing system is heavy going. I would suggest the authors add a chapter on software maintenance and downgrade rationale management to a section in it.

Although Bruegge and Dutoit provide explanations of agile methodologies and show in their final two chapters how processes and methodologies can be put together, their textbook can be said to reflect a medium-weight software development process and represents an interesting and intelligent compromise.

It is very hard to write an introductory textbook on software engineering: there is simply too much material to cover. If you follow the classic development stages you will find that key practical topics like configuration management and testing tend to get pushed into the last part of the course and are skimped on. In this sense, Bruegge and Dutoit have made an interesting contribution to the literature by placing a general overview of process and methodologies at the end of the book -however, in spite of the fact that the changes between the third and second edition of the book focus on the chapters on testing, configuration management and project management, in my opinion, the first two are still not quite up to scratch. In short, this is an honest, intelligent, focused and cohesive book on object-oriented software engineering, well-worth basing introductory software engineering courses on.