Customer Reviews

Instant UML

5 star:		(10)
4 star:		(9)
3 star:		(2)
2 star:		(2)
1 star:		(10)

 

 

Let me put my review in perspective. I have been programming in one language or another for twenty years. I was the project manager for a Fortune 500 company's e-commerce initiative. I do some consulting on the side. In other words, I consider myself to be a veteran programmer.

As you know by now, Wrox books fall somewhere between expert references and trivial introductions. "Instant UML" diverges from this stereotype. It was initially written in French, and then later it was translated into English. The readability of this book suffers as a result. There are many sentences that are either confusing, highly academic and theoretical in nature, or both. I found myself having to re-read several sections to understand them. I suppose I was expecting the content to be a little more watered-down for an "Instant" book.

This misconception on my part may be the result of the content matter: UML is a formal syntax for modeling real-world systems in such a manner that facilitates writing object-oriented software. For me, this topic begot a "chicken or the egg" paradox. Knowing UML should help me to understand the benefits and mechanics of Object Oriented Programming (OOP), but without having a moderate OOP background I couldn't appreciate UML. I actually tried reading this book about a year ago, but gave up after reading the first three chapters. As an aside, there are only five chapters in this book, so that was a reasonable attempt!

Since that time, I have improved my understanding of how to write OO software, and I have returned to this book. I enjoyed reading this book on my second attempt. Therefore my first admonition to the potential reader is that she have at the very least an introductory knowledge of OOP prior to reading this book. Having journeyman knowledge would serve her even better.

The first chapter covers the genesis of UML. It is very short, and for the most part can be skipped. Suffice to say that several OOP gurus were developing their own syntaxes independently, and then did something truly remarkable: they set aside their egos, and decided to unify their efforts. Thus was UML born.

The second chapter is a nice summary of OO features. The first time I read this book, I could grasp the meaning of concepts like inheritance, generalization, containment, and polymorphism, but they were just that: concepts. After having first-hand experience working with those concepts in a program, this chapter had much more significance for me. If you just read those last two sentences, and they described your comfort level with OOP, then you would likely appreciate this book.

The third chapter presents the formal UML notation. It is very straightforward, and thankfully there are many examples. An interesting point to note is that UML is intentionally language non-specific. If you come from a C++, Smalltalk, Java, or even a VB background, you can make use of UML. The notation is meant to be independent from the constructs of the programming language used to implement its diagrams. "Instant UML" maintains its adherence to this principle by remaining wonderfully language-neutral.

The fourth chapter is a lengthy dissertation about object oriented projects. This chapter is a tremendous resource for anyone whose job is tied to professional software development and delivery. I particularly empathized with the section on Risk Management, and its delineation of reasons for software project failure. I was also intrigued by the concept of "patterns." I wish they had been given greater coverage in this book. Still, this chapter on software development is very worthwhile for most software professionals.

The last chapter is a real-life case study that is examined using UML. By this time, I was able to understand the presented drawings. However, I was a bit disappointed that the book remained neutral, and never provided even skeletal class modules to implement some of the diagrams (much less fleshed them out with actual code). This omission is somewhat mitigated by appendices C, D, E, F, and G, which provide these skeletal structures for a variety of programming languages.

"Instant UML" is a good book for the experienced Object Oriented software programmer. I can't stress this point enough. It is not an entry-level introduction to the concepts of OOP. It contains a concise coverage of the UML syntax, and will be a great reference. Its numerous examples are very helpful. If you have the prerequisite OOP experience, and are looking for an explanation of UML, then this is a good place to start.

A fairly experienced software developer with no previous knowledge of UML may find it the best introduction to the subject. Just as WROX promise, there is no trivial introduction, no attempts at teaching the reader what he/she already knows, and then repeating it four times.

It's concise and to the point, unlike practically all other books on the subject of systems analysis and design, that I had in my hands. At the same time, it manages to give the reader a very clear idea of the concepts behind the pictures. I find the quality of presentation on par with Stroustup's ARM and a few other classics.

This book assumes the reader already knows a lot about systems analysis, but nothing about UML. If this description fits you, it's for you. If you look for an introductory text about systems analysis or OOP, you might need another resource.

If you're just now learning object-oriented concepts, then Instant UML will almost certainly befuddle you as the French author tries to cram too many concepts into his abstraction-filled sentences.

If you already have a very strong familiarity with OOP, but want to learn UML notation, you might find the UML treatment useful. But why bother? Just get another book that doesn't spend the first half teaching you what you already know: OOP.

In my quest to learn UML, I bought five books: 1) Instant UML, 2) UML Distilled, 3) Applying Use Cases, and 4) Building Web Applications with UML and 5) The Rational Unified Process. I've read them all.

Instant UML is, by far, the most unrewarding of the group: I spent too much time unraveling his words and not enough time grasping the new-to-me concepts of object-oriented programming.

I agree with the reviewer from Warsaw, but can't help but think that even experienced OOPers appreciate clearer sentence structure.

Well, having just read Booch's book I still highly rate 'Instant UML'. I think that the title pretty much describes the contents. Its a great text to "dip into", and answer immediate questions you have about the UML and its application. I personally like it because its concise, to the point, and is illustrated with a ton of useful examples. I guess that it is really aimed at designers who have a reasonable amount of OO analysis / design experience - as an introductory text...well I'm not too sure. I recently passed a copy of this book to a technically savvy manager who had little OO experience, but found it fairly accessible - and said that it helped him gain a useful grasp on the fundamentals.

Its pretty well written (even after been translated from its original French), the examples are good, as I've already said, and it seems sensibly organized. Four stars is pretty fair I think. Is it better than the Booch book? In my opinion, probably not - simply due to the fact that the Booch book was written by one of the designers of UML, so you get that valuable insider view - but thats for another review :)

Bottom line : I really liked Instant UML, if you have money to spend on more than one UML book, its virtues are probably well worth a personal or company purchase.

If you do not have a copy of a UML tool (such as Rational Rose or Microsoft Visual Modeler) you will be wasting your money on "Instant UML." But if you are comfortable with Grady Booch's methodologies and have an extensive background in software engineering (having read Steve McConnell's "Rapid Development" book, for instance), then you may find "Instant UML" useful as a reference. If you are a complete beginner to UML and looking to satisfy your curiosity about UML, trying to understand this book will be a maddening and futile exercise, because of the overly concise and highly technical quality of the writing. Although the jacket of the book states that you can "Learn how to document the object-oriented development process," it is clearly the case the Muller expects the reader to know a significant amount about UML before beginning. Because this book is marketed for the UML beginner, but clearly is not suitable for the beginner, this book is NOT RECOMMENDED.

This book tries to teach UML by using UML. This metamodel approach would work if you already knew UML. Also, break out the dictionary because the author really enjoys showing of his vocabulary skills. This is not a book for programmers. It is a book for academics. Stay away from it.

If such sentances as "The order of application of the criteria is often arbitary, and leads to a covariant decomposition that translates into isomorphic model elements."

make perfect sense to you on the first read then this book is for you. On the other hand if your not a professor of Computer Science and don't have a PhD then DONT BUY THIS BOOK.

This book makes a sometimes difficult subject impossible. The language is very dificult to understand unless your very well versed in UML/OOP already and even then still not easily understood.

Half way through this book I started to doubt my own intelligence so I tried out a few choice paragraphs on fellow workers (some who do have Mscs and Phds) and not one was able to fully understand parts of this book

A great book for top academics, a terrible book for mere programmers like me. This is a shame because most books by Wrox are very good and aimed at programmers.

Imagine someone throwing all the pieces of an automatic transmission on a table and now suggesting they've explained how to build, use and repair an AT. That's how this book is written.

If you don't already know everything about UML, what it is and how to use it, forget this book. You'll never learn it here. The writing is full-press academic. For example, here is the author's definition of Associations: "An association symbolizes a piece of information with a lifecycle that is non-negligible in comparison to the general dynamics of object intances of associated classes." Wow, that really makes it clear! I especially like how he uses the term he is trying to define INSIDE the definition.

Here's another example: Anyone who has tried to decipher a UML diagram knows the UML notation has many types of arrows with multiples of meanings. The author uses them without ever giving a definition, and in fact, nowhere in the book is a table describing the notation.

I tried to sell this book to my local Half-Priced Books store. They didn't want it. 'Nuff said.

I have only read the first 2 chapters of this book but I feel I have no additional knowledge on the subject. The author seems to be a rocket scientist and his audience assumed likewise. The sentence structure is obtuse and runon, using many words to say very little that is understandable to the average human. He says things like: "Any software implementation method must take into account the organization, interrelationships, and layout of structures in order to obtain the complex macroscopic behavior of the system being created." HUH. In english please!. Call me an idiot but this book is useless to all except the Harvard computer science graduate.

Technical publications should be technical but, with a real-world, no-nonsense, all be it simplistic behavior that appeals to the rocket scientist as well as your average guy, like me. This one is not!

So unless you are into tormenting yourself with overly complex information that has very little practical value in the real world, avoid this book.

I was quite surprised after reading this book to read some of the negative reviews on it. I find the book to be excellent, to the point, very clear, and very concise. However, I already know this field rather well (UML, OO modeling, etc.) so it is hard for me to imagine what it would be like for a beginner trying to use this book to learn UML. Beginners seem to be giving it the worst reviews.

I would strongly recommend this book as a reference book for those engaged in OO modeling, for those learning OO modeling under the guidance of an instructor, and for seasoned modelers who can pick up new ideas and interesting angles on the whole modeling process from the book. There are so many horrible technical books out there in the computer world -- this is not one of them.