Customer Reviews

The Object Primer: The Application Developer's Guide to Object-Orientation (SIGS: Managing Object Technology)

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

 

 

I probably purchased somewhere upwards of twenty books on the topics of the UML and object-oriented development before buying The Object Primer, 2nd Edition. Yeah, it probably would have been nice to have read this one first, but on the other hand, it may have been just the right book at the right time in terms of my learning process. As a result of my previous efforts, I was getting overwhelmed and confused by the sheer volume of concepts, notations, diagrams, development processes, and tools associated with becoming proficient with UML modeling and object-oriented development. While I had learned lots of important terminology and techniques from the previous books, I found The Object Primer to be enormously practical and useful in terms of putting it all together and breaking through to a working level of proficiency.

Among the aspects of the book that I appreciated are it's easy-to-read style, effective use of diagrams and visual examples, and the "techniques" sections with clear directives about what to do, and what not to do, in specific areas. I was able to use the technique lists in somewhat of a cookbook style as I applied what I was learning to some of my own work.

So far, in my growing library of OO development books, this one provides the "biggest bang for the buck".

This new edition of the book was well worth the wait. Finally someone has put it all together and described how to develop software using object-oriented technologies. Ambler covers development from requirements all the way through testing. Although the book does an excellent job explaining the UML, IMHO focusing on the 20% of the UML that you would actually use in practice, he supplements the UML with other techniques such as business rules, CRC cards, essential user interface prototypes, UI flow diagrams, and physical data models which he calls persistence models for some strange reason. He also goes a bit into system integration issues with external interface models, a topic that I rarely see covered in all the other OO books out there.

A huge strength of the book is that it shows how to go from OO design to actual code, giving a brief but good overview of how to implement your design in Java and in a relational database. Ambler describes important implementation issues such as how to map your objects into relational databases, how to write clean code, how to write good internal documentation, and how to design your user interface cleanly. Frankly, I don't know of any books other than this one that actually deals with real-world issues like this, and I really wish he had written this book years ago.

The testing chapter was solid but brief, summarizing material in his process patterns books, the 10th chapter very briefly overviewed technologies such as the RUP, EJB, and XP, and the final chapter provided career advice for success in the object industry. I would suggest this book for anyone new to object development, particularly people getting into Java or C++ for the first time, or even modelers or project managers than simply need to get up to speed on the UML.

OO came first and then came UML to model it! This book is all about the principles of object-oriented requirements, analysis, and design first and secondly about the UML tools for modeling these steps in project development. That's as it should be since OO is the thing most to be admired, and UML is (just) a popular and very useful language for modeling OO development. Too many UML books are so intent on UML that the fundamentals of OO are ignored. The first edition of this book was published in 1995 just before UML was born. Its author, Scott Ambler, is a prolific and renowned writer and developer.

The book has many detailed UML diagrams and is clearly written in a pleasant, professional style. The book is not about implementation. Look elsewhere for sample code, including some of Ambler's fine other publications.

Don't be lislead by the word "Primer" in the title. It's for the serious reader and would make a good text, but for a junior or senior level CS course. If you are a professional and could have just two references in your library for your first OO project, this 523-page book together with a good programming reference (Java, C++, C#, or VB.NET) would be a good choice.

This has to be the first book that has gotten object-oriented development right. Ambler really does tell it like it is in an easy to read manner. This is a great book for novices because it provides an introduction to the actual techiques you need to know about to develop software and is good for people like me who have been working in Java for a few years now because it fills in the missing blanks. Every Java and C++ programmer needs to read this book.

The thing that I like most about the book is that he colors outside of the UML lines, I wish more authors had the nerve to do that. This book is what the UML User Guide by the Three Amigos should have been. This book, in combination with UML Distilled, is the only thing that you need to know how to model object-oriented business applications.

I wrote this book to share with you the techniques that I have found to work on the development of real-world business applications. The book covers the development lifecycle from end-to-end, covering requirements, analysis, design, implementation, and testing from the point of view of a developer. It covers the Unified Modeling Language (UML), focusing on the 20% that you actually apply in practice, and goes beyond the UML so you actually have a collection of techniques that will work for you in the real world. For example, do you develop applications with user interfaces and databases? Of course you do, yet the UML has nothing to say about user interface modeling or data modeling does it? How about business rules or future requirements (change cases)? I cover these techniques and more because they are what you need to be successful. You're not limited to just applying the techniques of the UML so why should books that describe how to develop software be limited in that manner?

Techniques and topics that I cover in the book include: Business rules, Change cases, Class responsibility collaborator (CRC) models, Constraints, Essential use case models, Essential user interface prototypes, Persistence/data models, mapping objects to relational databases, Technical requirements, UML activity diagrams, UML class models, UML collaboration diagrams , UML component diagrams, UML deployment diagrams, UML sequence diagrams, UML state chart diagrams, UML use case models, User interface (UI) flow diagrams, UI design tips and techniques, and UI prototypes.

I found this book about an often overlooked topic to be entertaining, well-written and informative. This is a good introduction into object-oriented application design and what I found most pleasing and very rare was the treatment of the subject without the burden of any code whatsoever. All too often this topic is bogged down with coding details and Mr. Ambler avoided that, making a neutral volume that is as applicable for project managers as it is for Java, C++ and SmallTalk programmers.

A minor complaint I have is the author's frequent references to his upcoming book. I found it annoying and a bit self-congratulatory. We as readers will seek out future books if we like an author's style and knowledge so there is really no need to repeatedly beat us over the head with upcoming book plugs within the text. Additionally, I found the "pinball metaphor" silly , the frequent Star Trek references embarassing, and the barely original and proudly stated "Ambler Class Diagram Notation" a bit pretentious.

These petty gripes aside I would highly recommend this book to anyone who is interested in getting on the design boat at the entry level.

I have looked at quite a few books on the subject of OO analysis and design. This is the best book I have found for someone who knows nothing of this subject, but I imagine it would be a good reference and review for experienced OO types. It is concise and clearly written with very good examples. I especially appreciated the information about how to deal with the politics and mechanics of OO in the workplace.

I came to The Object Primer from the perspective of someone who has been working in the computer industry for over 10 years, knowing that OO is the wave of the future, but unable to get past the buzzwords thown around in most industry articles. After noticing the practical and readable nature of Scott Ambler's articles in Software Development magazine, I decided to have a look at this title and found it an excellent introduction. Very readable and clear. In particular the book gives you a good start on how to initiate OO analysis (for example, how to determine what classes should be modelled by the OO system in the first place). Provides a good scaffold on which to build a fuller understanding of OO development, and leads naturally to his next book: Building Object Applications the Work.

Before you buy this book, ask yourself what type of reader are you. A) A programmer with no OO experience that wants to learn how object oriented techniques can improve your applications or; B) An experienced programmer with OO development, software patterns understanding and a component-minded thinking for building applications. If you are (A), this book is for you. It will teach you to think and see development from OO point of view. If you are (B), this book is Object Oriented 101. I bought this book because I saw it advertised in several of the Scott's papers, thinking that the book would be an extension to the paper's topic (Persistent Layers for RDBMS). If you own books in Java Patterns, J2EE blueprints, etc, this book will render you hungry for knowledge (not to mention it will be a good pil to put you to sleep), since what it really is, is a brochure to sell you tipical object oriented design techniques that you probably already know. The book covers a lot of topics, but it stays superficial (intro level), with very simple examples. If you are seeking for advanced techniques for implementing or building frameworks and architectures for common enterprise problems, this book is farrrrrr too basic.

William Sheridan/Systems Analyst/Ottawa, Canada

Ostensibly, the purpose of Scott Ambler's book is to teach the novice about the merits of object-oriented analysis in application development. Therefore the methodology, notation and examples, all conform to the "objects" approach. This is a good thing, for there are many developers who would like a gentle introduction to object-orientation, and this presentation of the new paradigm is very appealing.

After a little reflection however, what sticks most from this book is the good sense behind Ambler's own modus operandi. For instance, at one point he claims object orientation should mean that better analysis and design will require less programming - but, as Ambler concedes, that was also actually true with the previous "structured" paradigm. So Ambler's bottom line is that systems developers should work smarter rather than harder - but most still don't!

Another of Ambler's themes is that the object-oriented approach involves much closer work with end-users than other methods. "Users do the bulk of the analysis." But in all likelihood, the difference between "user-centric" and "technology-centric" development is more a matter of temperament than technique. Ambler later implies as much: "With the way we have presented OO development, the people who understand the business do the analysis." The point is, that others have presented a far more "expert-centric" object-orientation - so this is a question of philosophy rather than methodology.

The third aspect of the book which continues to resonate, is Ambler's creation of a new "Pinball" Systems Development Life Cycle (SDLC) model. Iterative and incremental development was not represented particularly well by either the "waterfall" or the "spiral" strategies, so Scott adopted the "Pinball" metaphor. Both analysis and design really do "bounce around" between use cases, attributes, methods, classes, and collaborations on their journey to prototypes, testing and implementation, so why not say so!

Ambler is conscientious without being compulsive. At the end of each chapter he summarizes both the advantages and the disadvantages of "objectifying " analysis. Those who are determined to stick with obsolete approaches will definitely be the losers in the systems development business. The winners will be those with the good sense to look to the future. The aim of this book though, is not to convert us, but just to convince us to give the method a try. I am looking forward to the next volume of this trilogy for more of the same