The author describes this book as an introduction to a tool (Rose), a process (Rational's Objectory) and a notation (UML). It actually focuses mainly on the first two of these - the process and its support from the tool. An introduction to the most basic elements of the UML is given only as they become necessary.
The book walks you through the various stages of the system development process, from discovering use cases and classes, through to a brief discussion of system deployment. For each process, detailed steps are given to let Rose know what you want ('open this folder, click the class required, drag it onto the diagram'). This can be quite painful to read, but if sitting, confused, in front of the screen, it could be quite helpful to have every step listed. The book admits (near the end of chapter 1) to being based on the older V4 of Rational Rose (its successor, Rose 98, came out at the start of 1998), but justifies this on the grounds that the software steps described in the book 'may be applied to later versions'. This is perhaps partly defensible because the main ideas that the book tries to get across are those of the process, so detailed usage of dialogue boxes should be similar, even if their layout, etc., changes. This should be advertised more prominently, however.
The style is (apart from the software instruction) quite readable. Several errors - incorrect references, grammar, copy/paste mistakes, figure errors - should really have been picked up in final proof-reading. Footnote numbers are also typeset almost into the line above, making it hard to spot them.
There are some interesting points made on design and class associations and on states and state transitions, although I found a couple of minor omissions or technical inaccuracies in the explanations of UML. One thing that struck me whilst reading this book, however, was that there is not that much text here. Ignoring contents, glossary and the code listings in the appendix, the page count drops to 160-odd pages of actual text. Of this, around a third of the space is screen dumps, dialogues and other figures and another fifth is lists of 'next click here' procedure steps to achieve something in Rose. Furthermore, the Summary sections at the end of each chapter read like a set of choice quotations from the main chapter text, rather than a thought-out conclusion.
This book gives a good, if short, introduction to the Objectory process and contains a case study that works through most of the steps in the process, which helps to reinforce the processes introduced. It is also a handy introduction to some of the basic procedures in Rose V4.
This is a slim volume, but could serve as a quick introduction for new members on a team using Rose and might be a good investment to transfer the basic software skills rapidly before it is passed on to the next recruit.