Customer Reviews

Visual Modeling With Rational Rose and Uml (Addison-Wesley Object Technology Series)

5 star:		(7)
4 star:		(7)
3 star:		(2)
2 star:		(6)
1 star:		(7)

 

 

If you are new to UML, Rose and the whole Rational process for software development this is an excellent book to start with. It includes step-by-step instructions for constructing models with Rose software.

However for detail on UML and the development process in many areas you will need to continue on with other books such as "The Unified Software Development Process".

Important information is also missing on using Rose software. For example, the book does not tell you enough to be able to successfully complete Rose/C++ roundtrips. You will need more books and hopefully a good mentor/coach to help you become competent with Rose software but, again, this book is a very good place to start.

I highly recommend this book for anyone starting out with Rational Rose, UML and the Rational process for software development.

This is a good introduction to the Rational Rose tool and the Rational method of developing software. A reader should have a prior introduction to UML even though nothing advanced is presented here. What the book does best is build your confidence for tackling a large scale project using UML and Rational Rose to develop the object model. While the book includes some step by step instructions and tracks a development project from beginning to end it is not a definitive guide. The review is very broad brush. Terry Quatrani writes very clearly and for the most part fulfills the objectives that she sets out. There were a couple of points that I could not follow even rereading multiple times and I found myself wanting just a little more explanation of illustrations.

If you have a good understanding of the UML (and even if you don't) this book will not enhance your knowledge. The same applies for good modeling techniques and/or OO concepts - the book doesn't teach these. Then again it does not profess that it does so why blame it. The only reason I read this book is because it came with the Rose copy we bought. Frankly, even as a guide to Rose, it doesn't add much to what the (many) Rose manuals describe. The only people that should read this book, in my humble opinion, are those with a copy of Rose but without the manuals that come with it.

I strongly disagree with other reviewers who rated this book just "1 star" or "2 stars". I feel they picked a wrong book in the light of what they were looking for. That's pretty much their fault, or Amazon's fault for not publishing a good online description of the title.

Here is what book's preface says:

"[this book is NOT:]

- a tutorial on all the ins and outs of analysis and design using UML

- a tutorial on all the details in the Rational Objectory Process

- an explanation of all the notation and semantics of the UML

- an abridged explanation of the UML Notation

- a book on software architecture or C++ design

(...) This book is an introduction to the concepts needed to visualize a software system process, a notation, and a tool."

IMHO, the book achieves the purpose it states in 100%. It explains what visual modeling is in principle. It ligtly explains the notation. It walks the reader through the creation of a model of! a software system using Rational Rose. It is written in nice clean English (can't say that about mine ;-) ). It contains screenshots and provides Rational Rose GUI digest and sample auto-generated code in the Appendix. It does not obscure the picture with excruciating detail or complexity of the example software system (the author consciously chose to forget about some details of the sample software system for the sake of clarity).

Basically, you read the book on Saturday, digest it on Sunday, read it again over the next week (in a subway or where ever, the book is an easy read), realize where you messed up on your current project and how the Rational Rose tool could have been used to eliminate your problems, and buy another book on Visual Modeling next Saturday. This time a thick one.

Terry did a good job. If you need an easy read to get a picture on what Visual Modeling is because you heard a co-worker mention "Rational Rose is cool", get the book. Otherwise r! ead Rose help files or buy some thick volume on UML and &qu! ot;tri amigos'" work.

This book is a much more readable than the on-line documentation. It is a good introduction to Rose and UML for people who have never used either, but doesn't give you a solid enough grounding in either to be truly effective. The tutorial that comes with Rose is more complete, but doesn't guide you through the building of an application the way this book does. This gives you some guidance, telling you how to start with Use Cases, move on to sequence diagrams, and finally object relationships. Following the Flow of Events template is probably the most useful thing in this book; that isn't good, considering the Flow of Events template is nothing more than a Word document.

This book can get you past that "Ok, I've installed Rose, now what do I do?" point. Unfortunately, it then leaves you saying "But how do I do THIS?" a lot. The book would be dramatically improved if it contained a COMPLETE example. Unfortunately, Ms. Quatrani gives you a bunch of Use Cases, then uses a different one in each part of the book. She doesn't follow a single thread, showing how to get from Use Case to code generation; instead, each part of the process uses a different scenario. There is no use case that has all diagrams (Use Case, Sequence, Collaboration, Class, State), so you can't easily see how one flows into the next. Also unfortunately, she seems to choose the simplest example in every case, leaving you wondering how to do a more complex one. The book desperately needs a complete model for the example program included with it, or at least a downloadable copy of the model on Rational's web site. In the book, she does gives you one (and only one) example of everything, but expects you to figure out how to generalize the example. And the sections on the Code Generation functions and Round-Trip Engineering are very perfunctory, seeming like an afterthought.

The book doesn't even come close to using the UML 1.1 specification, but neither does Rose, so that's no surprise. You'd expect the company developing UML would make a tool that supports it, but even Rose '98 fails there. If you're looking at the UML 1.1 spec, it'll confuse you.

This book is geared toward Rose 4.0. It won't help at all with Object-Relational mapping and the other features introduced in Rose '98.

This book has just enough detail to illustrate the process, without confusing the reader. It also has a good explaination of why and when the various artifacts are useful.

Unfortunatly, I tried to learn UML and Rational Rose by using this book. I should have read the preface a little closer, which states that this is not what this book is about.

Even after learning about the UML from other sources and going back to this book, I don't know what it trying to teach. The only thing that I could see is that Rational Rose doesn't support the full UML notation and that this book does nothing to point that out. It tries to work around it.

Spend your money on other books such as 'The Unified Modeling Language User's Guide' and learn UML first. Rational Rose is then easy to figure out.

This book is a concise, tantalizingly understandable introduction to UML with Rose. But it falls short of its promise. I suspect it could've been made much better - through careful organization & better editing - without adding a great deal more material. After reading the Jan 98 version, I came to Amazon.com hoping to find a later, improved edition - in vain. The book illustrates basic aspects of Rose usage but frequently fails to tie these illustrations to the underlying "University Course Registration" system example in a consistent manner. It's not always easy to tell whether or how a Rose usage illustration relates to the system being developed. The presentation flow suffers as a result. For example, pg. 53 shows how to create a new package and relocate classes between packages. The figures show Browser views with a class under the Logical View called StudentInformation and a package called PeopleInfo. But 2 pages later, having returned to system development in the same Browser view, the StudentInformation class has disappeared and the name of the PeopleInfo package has changed to People. There are several places where new, important concepts are quickly introduced and glossed over. For example, Scenarios are an important idea related to Use Cases and interaction diagrams, but on pg. 53 the term "scenario" is introduced without definition in a manner that appears to equate scenarios with sub-flows of use cases; the transition in terminology occurs without explanation. In spite of shortcomings like these I still recommend this book as a valuable "primer" for newcomers to OO and UML / Rose.

If you are getting started with Rational Rose and UML and need a book to get you up to speed fast this is the book. It pulls together a lot of key concepts extremely well. The book discusses the Rational Objectory Process and identifies where the various UML notations can be used in it. This is a great intro to this area. It was the first UML book that I read so far that brought these two together ( the language and the process ). When I want to present material to my colleagues on how to use the Rational Rose I end up going back to this book to get my program together. Even if you do not have the Rational Rose Software available to you this book teaches the material well. I recommend this book highly. There is a lot of material out there that can be extremely confusing to people just starting out. I think Terry Quatrani should get high marks in providing a easy to understand text.

This book was an excellent resource. As a guide to learning Rational Rose, it was great value. I think that some of the reviewers might have misunderstood the intention of the book. It is not meant to be a UML tutorial - a basic knowledge of UML is assumed for readers of this text. The book is all about applying UML using Rational Rose, and as a book with this aim it succeeds admirably. It is far more succinct than the Rational documentation, and it also includes practical ongoing exercises to work through as you read. I've been using Rational Rose for about a year, but this book was great for being able to learn all the esoteric aspects of the program & how the UML is used within it.