||New Reviews| |Software Methodologies| |Popular Science| |AI/Machine Learning| |Programming| |Java| |Linux/Open Source| |XML| |Software Tools| |Other| |Web| |Tutorials| |All By Date| |All By Title| |Resources| |About||
Keywords: UML, object oriented design, modelling
Title: Learning UML 2.0
Author: Russ Miles and Kim Hamilton
Verdict: An excellent introduction to UML
The Unified Modelling Language (UML), has firmly established itself as the lingua franca of the object oriented development world. It offers the right levels of abstraction, independence from programming language implementation to make it pretty much ubiquitous. Use cases and class diagrams have entered the vernacular, even amongst those developers who have only the vaguest idea of what UML stands for. Now, for those embarrassed by their pidgin UML, 'Learning UML 2.0' offers a fast introduction to all of those funny diagrams that look really cool…
While UML is language independent, it's difficult to ignore the fact that for all that fancy notation the model has to be implemented somewhere, somehow. And when the aim is to teach UML there has to be some link to source code to fully appreciate the relationship between the different diagrams and concrete implementations. In the case of this book the authors have used Java as the implementation language, but the book is still useful for non-Java programmers (particularly C# programmers).
Rather than take the overly mathematical or theoretical route, the book sticks pretty much to UML 2.0 as she is spoke. The focus is firmly on the practical side of things. To this end the text makes good use of extended examples, tables and plenty of diagrams. While there are no excercises in the book, there's an accompanying web site which includes questions and answers for those looking to apply themselves to what they learn in the book.
Topics covered include: how to capture a system's requirements in a model in order to ensure that the design meets the users' needs; modelling different parts of a system and their relationships; describing how a system will be deployed and the different deployment components. These (and other) practical activities are all addressed using different UML diagrams and abstractions, and of course the authors point out both the strengths and weaknesses of one approach versus another (because, just as in programming, there is no single right way of doing things in UML - it's model after all…)
In terms of coverage all 13 UML diagrams are covered to some degree, though there's more emphasis on the 'core' diagrams - such as the use case, class, activity and sequence diagrams. Certainly those interested in Agile modelling will find that some of the more esoteric of the UML 2.0 diagrams - such as the timing diagram - do not warrant a disproportionate amount of attention.
It's worth noting also that the book devotes little attention either to specific methodologies (RUP, XP etc), or to specific modelling tools. This should be considered a strength rather than a weakness. The focus is, as it should be, on the meaning of UML and what it models rather than on specific bits of software which implement this or that diagram.
The book is really directed at the UML beginner, experienced practitioners already familiar with UML 1.x are unlikely to find enough new material to justify forking out for the book. For the uninitiated, this book provides a very pragmatic introduction and tutorial on UML 2.0.