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.

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.

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.

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.

If you are a professional software developer hoping to learn the basics of UML, this book is not for you. It is pure fluff. The examples are so trivial as to be meaningless. I have yet to find a good UML book so I can't recommend another one but this book is TOTALLY USELESS.

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.

This a very good tutorial on Rational Rose 98, UML notation understanding is not necessary as it is intorduced as you go along, but understanding the Objectory Process is necessary because it is poorely introduced in this book. There is one problem with this book, the books claims that a course registration system for a university is employed to illustrate the analysis and design of an application, however in reality this example is totally marginalize as if inserted by force after the book was finished, this is why you need to understand to Objectory Process.

When I first embarked on learning UML and Rational Rose, I searched for a book that might help expedite the learning process. Visual Modeling with Rational Rose and UML certainly accomplished that as I reference the book often. UML is difficult to master (Anybody who says otherwise is not telling the truth), and this book kept things fairly simple. If you are trying to learn Rational Rose and UML, then I recommend this book. If you are allready advanced in UML, you might be better served by the UML books recently published by Booch, Rumbaugh and Jacobson.

I never seen Rational Rose before. I didn't know UML. When I installed Rose, I did need a rapid way to use it and an intro to UML. Well, I choosed this book and in few days I developed my first application using design approach insead of never died procedural approach. 20 days in analisys (mixed with book reading). 30 days in coding (without the help of "Build Code" Rational Rose option). An excellent result that surprised all my collaborators.

If this is what you are looking for... Buy this book!

I learnel UML concept too. And for the future, I beleave that I must read some other book on UML. This will improve my design skill.

For a rapid approach to the tecnology involved, this book is good. Hence 4 stars.

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.

I believe this book was created to support classroom hands-on training. The material is over-simplified, and is cookbook in nature. I imagine a Rational trainer using this book to march a group of neophytes through a one day overview of the product. No substance is present.

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.

I bought this book and would advise you not to do so. It is much too skimpy. There is too much fluff. There are much better books and articles around. This book touches on a bunch of terms and techniques without explaining them in sufficient detail. I thought that by reading this book I would gain a good idea of how to use Rose, but such was not the case.

After reading the book, I initially thought it was a good value. Then I tried to construct my own model using the student version of Rose 4.0. I really struggled. The book does not show the BIG picture and there is not enough detail to figure out how some of the diagrams are related.

Also I think I found at least one error in the models. I tried to construct a component diagram similar to her Figure 11-10. Rose would not let me associate any of the interfaces with Professor.exe.

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.

It's a well-structured book. It gives you guidelines for using Rational Rose 4.0 through analysis, design, and code generation. Moreover, Author allows you to practice with a small project. Unfortunately, I found some chapters too superficial, above all Use Cases'chapter. I expected to find deeper explanations about visual modeling. It's not a book for mastering visual modeling with Rational Rose and UML.

If you are knee deep in UML and looking to get deeper, then this book probably isn't for you. But, if you're entering the new realm of Object-Oriented Design and Analysis and need easy to understand explanations ---- You've come to the right place.

TQ makes no pretense about being the final word on either Rational Rose or UML. Her stated purpose is to ease you into the murky world of the three amigo's. To this end she has hit the mark.

Her explanations are concise and her diagram well placed. More than that, she gives the reader a taste of a working methodology that is sadly lacking in many of other UML books.

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.

I was looking for a quick overview of using Rose to create UML models. This book was exactly that. It was a quick, easy read. I learned the basics of modeling with Rose. In addition, I gained some insights into the Rational "way" of doing OO analysis and design. This book was almost exactly what I was looking for. I would like to see the next edition have more detail without a big increase in page count.

I feel this is a easy going readable book. One can go through the full book perhaps within a couple of hours. But this book lacks in the depth of coverage. It neither covers UML fully, nor covers Object Oriented Design concepts. It, in fact, tells most of the relevant steps of OOAD but only tells skin-deep concept of OOAD. One can perhaps read this book only to familarize how to use Rational Rose in the design process.

Bad book. Bad investment. Simply, a rip-off. I won't rate it more than 2. I also rate those who gave it more than 2, 2.

A very disconnected book and very light on content. This is definitely not for people who want to learn UML. A tutorial for Rose should take the reader from scratch to building the application. By placing the content between being a UML intro and Rose tutorial and not continuing along a single thread Ms. Quattrani lost my interest right from the beginning.

A well needed introduction for the majority of IT professionals and organizations out there who are just beginning to look towards Visual Modeling as a cure for their devlopment problems. Terry does an excellent job of guiding the reader through the fundamentals of visual modeling and proves that you don't have to be a UML guru to begin utilizing visual modeling. IT professionals have to start somewhere - start by reading this book!

The book provides the uninitiated with a good introduction to the basic steps taken to build visual models. As the author points out in the preface, it is not a book for details on UML (I look forward to seeing the three books by the "three amigos"), nor is it a book on s/w architecture or design. What I liked was the simple way in which the basic issues were presented and the ability to use the instructions to create a model in Rose. The book would have gotten a 10 if the author had included pointers for the reader to go to for additional information.

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 just does not live up to its title. There is no serious discussion on any topic covered in it. Adding word 'Introduction' to the title would increase its mark to 4.

This book is very light on content. Most of the rose documentation is light, with no real insight on how to use the tool to it's fullest.

In the tradition of Fowler and then Quatrani, I'm going to start out by telling you what this book isn't:
1) It is not a good book
2) It is not a very useful book
3) It is not a good value for the money
Well then, what is it? It's a simple-minded tutorial of Rose and visual modeling ( heavy on the simple minded ). I was looking for a book with a lot more meat in it. This is the kind of book I might pay $7.99 for if I felt flush. The book would be more appropriately titled "Basic Visual Modeling" or something. It's not advanced enough - heck, it's not even intermediate enough. Perhaps, like Fowler, she didn't want to put much into it so she wouldn't step on the three amigos' toes since they're writing their own books on the subject. I hope those books will be better.

For its sheer simplicity and ease-of-read, IMHO, Terry's book is probably one of the best OO books I have ever come across. I especially like the way in which she cleanly separates methodology and the design tool (Rose). Great job !!! Jimmy Mohsin