In object-oriented (OO) software development, unified modeling language (UML) is a popular and important tool for object-oriented modeling and architecture description. The models, created using UML, could be used to generate codes. The object constraint language (OCL), a declarative language that is part of the UML standard, is used to describe rules, which in turn are used together with UML models to generate codes. OCL is intended to extend UML diagrams with additional information such as new attributes, associations, methods bodies, and so on. UML is inflexible in defining system behavior and cannot take into account, afterward, any modification of requirements .
This book, the second volume of the series, presents agile modeling with UML with a focus on code generation, testing, and refactoring. Furthermore, it presents object-oriented modeling using UML/P (UML profile, where /P stands for programming). UML/P enables users to overcome the inflexibility facing the UML standard.
Overall, the book is well structured and easy to follow. In chapter 3, the author provides a compact overview and brief reminder of the first volume. However, the reader needs to read the first volume to get more insight into the UML/P modeling language, presented as an extension of UML. I missed a systematic comparison, in the form of a table, between UML and UML/P; a refresher would surely help less experienced readers as well as those who have not read the first volume to easily follow the entire book.
The book describes the agile modeling process using UML/P, which is more flexible than UML. It further describes and ably discusses the agile methodology. It also presents the limitations of extreme programming, an agile development methodology. The book demonstrates how flexible UML/P is in modeling, code generating, and code refactoring. The author illustrates each of his assertions with examples. The book clearly and succinctly discusses code generation, the principles of testing with UML models, model-based testing, and design patterns for testing. It further presents refactoring as model transformation and the refactoring of models. Rumpe provides an excellent literature review. This book is primarily intended for developers with strong backgrounds in software modeling, code generation, and refactoring.
One point makes me feel a bit confused: chapter 1 states that agile methods typically don’t involve the creation of documentation (page 3). However, the following chapters state that agile methods, for example extreme programming (XP), require less documentation. This might be a bit confusing for inexperienced readers. Although the agile manifesto clearly recommends reducing time by quickly producing high-quality code and products rather than elaborate documentation, it does not assert skipping documentation altogether. Less documentation is not equal no documentation: there is a big difference.
Generating code from UML is termed “forward engineering,” and reverse engineering is used for the process of generating models from code. However, I did not see these terms mentioned.
This book provides excellent teaching material, and can be recommended for students and lecturers; in addition, experienced developers working on agile projects can use it as a guideline and to read about best practices. However, I see it being used more in an academic environment than in development.