Customer Reviews

The Object Primer: Agile Model-Driven Development with UML 2.0

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

 

 

For those who want a quick, fun introduction and intermediate mastery of UML 2.0 without getting sidetracked in all the esoteric notation that is rarely used, this is your book. I have used it since its release (and the edition before that) for teaching UML and good Object Oriented Design concepts. Many will throw stones (UML Purists that are more interested in UML Metamodel Purity then getting systems built for example) but don't let that phase you. If you need to learn UML 2.0 and have fun doing it, this book will do an incredible job for you. Scott writes in a very accessible style, not trying to show off his deep technical knowledge of UML (which he has). I admire him for writing this book as it is a tremendous service to our community. He simply wants people to get working as fast as possible. I admire his ability to have such a deep grasp of UML yet not flaunt it and distill things down to the necessary 20% that is all you need 80% of the time. More accurately, perhaps it is more accurate to say he covers the necessary 35%-40% that covers 90% of what you need to be effective.

The negative reviews come from people who are likely purists or are taken aback by his somewhat fun and informal style. As we have seen with books such as `Head First Design Patterns' I have seen greater success with books that take this format for people who are starting out. The other books can come later if needed.

You can buy much more academic books that will go into great detail on the semantic meanings of UML 2.0 model elements such as stereotypes that are almost never used or understood, advanced concepts in categorizing classes in a class diagram that are rarely used, etc. but you will rarely see any of them in practice. Rather then waste your time learning these items why not learn what you need to learn so you and your team can start communicating in Visual Diagrams as quickly and efficiently as possibly?

Kind Regards,
Damon Carr

This book is an overview of agile model-drive development, while uses a story about practice agile development for a university system. This application is so simple that it may take only one small incremental step to develop. The author does not care to complete this system at the end since he knows it is very simplistic. It is not necessary to carry out any refectory and iteration. On the journey, the author often stops to tell his experience and point out some treasures exposed along the path. However, at the end, you realize that you are still at Disney Land, although this time guided by a real pathfinder who repeatedly told us it is for real. The author provided several UML diagrams supposedly developed on a white board. But it makes no difference whatsoever if they are printed. They are just decorations to make it looks real. Actually, it is hard to read, as complained by other reviewers.

The main title of the third edition, The Object Primer, is misleading. This book is mainly about agile model-driven development, which is part of the subtitle. A better title of this book should be The Primer of Agile Model-Driven Development. This book does not teach you very much about object itself. Chapter 2 gives you a review of object-oriented concepts. If you are new to OO, such brief coverage will not help you very much. This is not a book that teaches you UML either. UML 2.0 is used throughout this book in straightforward cases. If you are new to UML, you have to read other books first.

This is a well-written book and you may learn a lot IF you are one of the targeted audiences. The author stated, this book is aimed at two primary audiences - existing developers and university/college students who want to gain the fundamental skills required to succeed on modern software development projects. The author give a quite "radical" (his own words) definition of developer as ANYONE involved in the development of a software applications, including programmers, analysts, designers, business stakeholders, database administrators, support engineers, and so on. I understand ANY author wants to sell his/her books as much as possible. But this author is established. He does not have to make us believe that the university registrar needs to read this book merely to be part of the team working on university system mentioned this book. My recommendation is that this book is really written for software developers and students who already have reasonable understanding and certain experience in terms of object-oriented approaches and UML, and they wish to have an overview on how to conduct agile development.

The author provided instructions on how to read this book. I somehow do not total agree with his recommendation. Below is my suggestion following his classification of different groups of readership.

For Programmers, Designers, and Project Managers, the author suggests them to read the entire book. I somehow feel different. If you are a project manager but not that technical, you will feel this book difficult if not impossible. If you are a project manager for a software development project merely since you are PMI certified, you have a lot to learn before you come to this book. If you are a VB programmer and you are not confident on what OO really means, you should read other books.

For Business Analysts and User Representatives, the author said Chapters 4 through 9 is written specifically for you. Well, this is 6 chapters with 144 pages out of a book of 12 chapters with 492 pages. Furthermore, I am not sure why the author believes you need to learn Singleton Design Pattern (12.2.1) and Façade Design Pattern (12.2.2).

For Students, the author asks you to read the book cover to cover. I agree with the author on this, as long as you are the right type of the students who have learned OO and UML and who needs to get the idea how agile approach works and how a project is developed conceptually. If you are still not sure about polymorphism, this book will not help you.

I am an experienced developer and I teach as well at university. I am within the targeted audiences of this book and I do buy many books. I completed this book within days after receiving it since it is quite readable. I am glad I added this book to my collection and I will certainly review it again and again, but perhaps mainly for my teaching duties.

I still give this book a 4-star rating since it gives us a good conceptual model kind of overview on agile model-driven development, with practical advices sometimes. However, he has yet had the time to implement his model (write more substance). He sees the needs of readers and he has made one more incremental deliverable, the 3rd edition. We hope he will get the feedback from us and make another try quickly, one with more implementations. For instance, since this book is an overview, the author should have provided references whenever necessary that lead us to further studies and discussions. The book contains a reference list with more than 100 entries at the end of the book. The problem is that the author expects a developer to figure out what references are relevant when he/she is reading a particular chapter or subject.

The list price of this book is $45; but it sells at $30 with Super Saver Shipping (free shipping) at Amazon.com. As a matter of fact, this book is free for me since I bought it by using the $30 discount I received when I signed up with Amazon Platinum Visa Card.

/* The statement and opinions expresses here are my own and do not necessarily represent those of my employer */

This book should really be called "Agile Models Distilled" or perhaps "Agile Model Driven Development". It does for modeling what UML Distilled does for UML: it provides a concise overview of a wide range of modeling techniques. One thing that is a real eye opener in this book is how many simple techniques exist work involving your users in the modeling process, as well as developers who may not want to learn the complex UML tools which management foists on them.

A huge benefit of the book is that it actually covers the entire software development lifecycle. It describes testing techniques that you can use throughout your project and shows how TDD fits together with modeling. The simple and straightforward approach to modeling that's covered in this book fits incredibly well with the TDD approach favored by many agile developers; it's a great way to increase your productivity as a developer. The book works through a case study, showing how to model and then code portions of a business application, so you get a pretty good idea how to actually do this stuff in practice.

This book shows how to be effective at modeling on agile projects, something few other books show how to do. It shows that you need to go beyond the UML although makes it clear that the UML is still an important part of your modeling effort. The book shows how it all fits together, but doesn't go into the excruciating details of how to apply each modeling
technique: if it did that it would be several thousand pages long. If you want to gain an understanding of the types of modeling skills you need to learn to be effective, this book is it.

I am an experienced analyst looking for an antidote to the RUPies use-case-jaundiced view of requirements. This book provided the perfect foil to the sentiment that use cases are all that is in the requirements universe.

It is not meant to be an exhaustive treatise of UML models, rather, it offers a different and, to me, refreshing view of what requirements for system building are supposed to be: agile, responsive and as varied as the projects that they are used on.

Additionally, the writing is light enough to be enjoyed and (what a novel idea) actually read. I have read Mr. Jacobson's books as well as Mr. Rumbaugh's. Albeit their authority status, their writing styles leave you wondering who they were writing for. It certainly wasn't me.

If you are looking for an alternative to the use-cases-as-panacea view of the world, this book will present a good fundamental look at how to get requirements written in a different way. And along the way, you will have a good time reading the book.

This is an excellent book that deserves to be on your short list of books about modelling...especially beginners. It continually drives home the point that UML and modelling are means to end (working software), not an end by itself.
The author explains each UML diagram, with examples of how and when to use it. However, this is not a dry reference. He freely expresses his opinions and experience about how useful these diagrams are in the real world. How refreshing!
UML can be overwhelming for beginners. This book shows that it doesn't have to be.

The Object Primer is a great read. Scott walks you through the development lifecycle in clear and simple language. And all along the way, Scott points out the landmarks to the reader. Scott has a way of knowing just what a person needs.

For example, on page 122, Scott provides a basic list of twelve pointers for interviewing. How often was there a problem in requirements because of misunderstanding. These pointers address techniques they did not teach us in CS-101. The primer is full of helpful lists like these pointers. And who, besides Scott, would like to include this?

This new edition has been updated to reflect the emerging consensus of the Agile Modeling community. Whether you are a seasoned developer, a software development manager, or novice programmer, this book will provoke you to thoughtful consideration of how you develop software.

I bought this because I needed to get more firmly grounded in UML. I already had Ambler's "Elements of UML 2.0 Style" which points to this book as one possible way to get it. The other book he suggested was Fowler's "UML Distilled", but he claims his own book "goes beyond UML".

I liked the idea of learning UML in a software engineering context, especially one that emphasizes Agile programming. But that's not what I got. This is a long discourse on development models, with some bits and pieces of UML thrown in. Most of it is in a single chapter, with very few illustrations (for a visual language!). Really, UML is an afterthought.

I can't comment on the quality of Ambler's methods for software engineering -- I'm a technical writer, not a developer. What I needed was enough about Agile development to enable me to work with Agile teams. But from my limited understanding of Agile methods, I suspect that this is just old-fashioned software engineering in Agile drag.

So, this book has "UML" and "Agile" in the title, but isn't really about either. Buzzword compliance.

If you want to learn the agile methodology this book is a good beginning. Without a doubt you will learn the underpinnings and ready yourself and your organization for agile development.

The Object Primer is aimed at software engineers and architects with a good bit of experience. For that audience it is a well-written, clearly illustrated introduction to object concepts, UML, and agile development.

A warning: even though the book says that everyone involved in analysis, design, and delivery should read this book, I think it would probably be over the heads of most non-technical business analysts.

The author has an excellent pedagogical style. As a result, this book is easy to read. Another plus is that the book covers a lot of ground, including the development spectrum (requirements, analysis, design, coding, testing, etc.), GUI modeling, data modeling, and database modeling, so most readers will be broadened by reading it. Another plus is that the author regularly shares what he has learned from personal experience. I found two minor annoyances. First, CONSTANTLY being reminded to produce models that are "just barely good enough" was like Chinese water torture. Secondly, the book practices what it preaches: instead of depicting models drawn using automated tools, in many cases the book depicts models drawn on a whiteboard by human hand, because that's "good enough." The problem is that in many cases I didn't find it good enough because the penmanship was such that I had a hard time reading the handwriting. Bottom line: if you want an up-to-date, introductory book that covers a lot of ground, this book has a lot of meat in it, it won't put you to sleep, and you'll almost certainly learn something.