Customer Reviews


22 Reviews
5 star:
 (9)
4 star:
 (5)
3 star:
 (2)
2 star:
 (4)
1 star:
 (2)
 
 
 
 
 
Average Customer Review
Share your thoughts with other customers
Create your own review
 
 

The most helpful favourable review
The most helpful critical review


5.0 out of 5 stars Seeing the forest through the trees
In this book, Scott Ambler provides a practical approach to modeling that allows you to successfully deploy best practices on your agile software development project. From use case modeling to deployment diagrams, agile modeling defines these best practices for rapidly moving from requirements to code in a single, easy to read book. Additionally, Scott presents many of...
Published on Aug. 18 2002 by Granville Miller

versus
2.0 out of 5 stars Violating its own principles
One of the values of the agile movement is simplicity, which the author kindly spends about two pages explaining it to us mere mortals. And it seems only logical that this high principle would also imply brevity. Unfortunately, this book in itself is a violation of that principle. The only useful lesson that one can possibly distill from this three hundred and fifty pages...
Published on Feb. 10 2003 by Mohammad B. Abdulfatah


‹ Previous | 1 2 3 | Next ›
Most Helpful First | Newest First

2.0 out of 5 stars Violating its own principles, Feb. 10 2003
This review is from: Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process (Paperback)
One of the values of the agile movement is simplicity, which the author kindly spends about two pages explaining it to us mere mortals. And it seems only logical that this high principle would also imply brevity. Unfortunately, this book in itself is a violation of that principle. The only useful lesson that one can possibly distill from this three hundred and fifty pages tome is the following: Keep it simple, lose it if you don't use it, and don't hesitate to ditch your expensive modeling software when it becomes too restrictive. A wonderful and very effective advice if I may add, but there is definitely no need for an entire book to explain it.
This book is neither a modeling tutorial nor an introduction. And if you have had any decent amount of practical modeling experience then chances are you have already learned the above lesson. As such, the book fails to hit the mark for both experts and novice modelers. Nevertheless, the lesson it contains is important, thus the two stars. The book itself, however, receives a flat zero rating.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


4.0 out of 5 stars A Challenge from Common Sense, Feb. 3 2003
By 
Vince Kenyon (Chicago, IL USA) - See all my reviews
(REAL NAME)   
This review is from: Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process (Paperback)
An adept application of common sense--and the author's significant experience--to the use of models in software development.
A model can be almost anything that developers make to describe the software that they build--just like an architect's drawings.
A given software development effort might call for any number of different types of models including data models, class models, sequence diagrams, dataflow diagrams, statechart diagrams, etc. The set of models used on any particular project will depend partly on the nature of the project and partly on the preferred methodology of the software developers.
Agile Modeling (AM) is not itself a software development methodology. It is a collection of principles and practices to follow when using models to develop software according to a methodology like Rational Unified Process (RUP) or eXtreme Programming (XP). Many of the practices derive from an application of XP concepts.
AM challenges a number of practices widely followed (or at least preached) in organizations developing software:
1. Specializing personnel in producing a single type of model
2. Dedicating work sessions to producing a single type of model
3. Saving models after the software is developed
4. Keeping models up-to-date during and after the development project
5. Using sophisticated software to assist in modeling
6. Finishing models before coding software
AM does not in all cases prohibit these practices, but it emphasizes that the purpose of a software development project is to develop software--not just to develop models. The practices of AM help to keep models in their proper subordinate relation to the working software that is the true goal of any development project.
People with more luck than experience might doubt the need for agile modeling. Please accept from a reader with much more experience than luck an assurance that the need is great. This reader has personally witnessed development projects undertake the costly construction of models having at best a tenuous relation to the software to be developed.
It should in fact come as no surprise. Who would not agree that it is easier to waste other people's money than to abandon one's own obsessions?
At any rate, Mr. Ambler tries to keep us on track with this excellent book, challenging us to use models but to stay focused on software.
Different readers are likely to be challenged to different degrees by AM's various principles and practices. This reader easily accepted, for example, the practice "Create Several Models in Parallel," counseling us to construct multiple model types simultaneously and to eschew the antipatterns of "Single Artifact Developers" and "Single Artifact Modeling Sessions" (pp. 47-50).
The principle "Maximize Stakeholder Investment" proved more challenging. It counsels that project stakeholders (i.e. the businesspeople commissioning the development project)--not software developers--ought to decide whether to develop software documentation (p. 37). True, the stakeholders pay the bills, but architects and accountants also have paying clients who are nevertheless not able to dictate everything about their work. Clearly software development should have professional standards whose suspension may not be commanded even by a paying client.
Another challenge for this reader: "Agile modelers typically do not bother to distinguish between the different "flavors" of modeling, . . . (p. 252)." Here Mr. Ambler is writing about what Martin Fowler calls "perspectives"--conceptual, specification, and implementation--that a model might take on its subject. These perspectives correspond to the business analysis, system analysis, and system design phases of a software development project.
In his "UML Distilled," Mr. Fowler differs sharply from Mr. Ambler: "Understanding perspective is crucial to both drawing and reading class diagrams. . . . it is very important to separate the specification perspective and the implementation perspective (p. 52)."
Or does he? Mr. Ambler hedges his position in the very same sentence: ". . . they just model appropriately as the situation calls for." Now, how can one "model appropriately" if one does not first "bother to distinguish"?
Elsewhere too, the advice of AM can seem equivocal (or is it "nuanced"?). The practice "Collective Ownership" allows everyone on a project to work on any of the project's models. This "power to the people" is however greatly diluted by the practice "Model with Others," prohibiting anyone from modeling alone. Further dilution appears in the case study, where it is recognized that one would be foolish to work on a database design without consulting "Brendan, the database administration (DBA) expert on the team (p. 288)."
It is interesting to compare Mr. Ambler's populist principles for teamwork with the more elitist principles of Frederick Brooks in "The Mythical Man-Month." Mr. Brooks begins his third chapter by citing the "wide productivity variations between good programmers and poor ones." He derives from this observation a software development organization patterned after a surgical team--with one operating surgeon and a small flock of assistants.
Although starting from opposite principles, Brooks and Ambler finish peculiarly close in their team-building practices. A la XP, Brooks's ideal team pairs the "surgeon" with a colleague equally gifted though less experienced. Inversely, Ambler approaches Brooks by listing in Chapter 12 the qualities of superior software developers. "Everyone can learn from everyone else" is one of the "supplementary principles" of agile modeling, but clearly some people have less to learn than others.
Mr. Ambler seems well read. He frequently cites related books throughout the text, adding a special recommendation here and there. One of these recommendations surprised this reader, who was astounded that Mr. Ambler found "UML for Database Design" by Messrs. Naiburg and Maksimchuk "a good read (p. 170)." You may find this reader's differing opinion filed with Amazon.com
Our difference on this small point serves only to highlight the strength of this reader's recommendation.
This is a provocative and well-reasoned explication. Agile Modeling will leave its mark.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars Seeing the forest through the trees, Aug. 18 2002
By 
Granville Miller (Raleigh, NC United States) - See all my reviews
This review is from: Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process (Paperback)
In this book, Scott Ambler provides a practical approach to modeling that allows you to successfully deploy best practices on your agile software development project. From use case modeling to deployment diagrams, agile modeling defines these best practices for rapidly moving from requirements to code in a single, easy to read book. Additionally, Scott presents many of the nuances of software modeling that cannot be found in any other book.
Perhaps the most interesting part of Agile Modeling is that it is not only a book about a great software development methodology; it also suggests cultural changes to the way that we view modeling. These changes blur the line between traditional approaches such as those espoused by the Unified Process and the new culture espoused by XP. These ideas are very much in line with the way that software is successfully produced.
This book is not an entry-level UML book. If you are looking for basic UML, look at some of the entry level UML books. Instead, this book geared toward those who are actively producing customer grade software applications. It hits the mark squarely for those who want to be more successful in this endeavor.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


4.0 out of 5 stars Lots of Information, Aug. 14 2002
By 
Srihari Mailvaganam (Vancouver, British Columbia Canada) - See all my reviews
(REAL NAME)   
This review is from: Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process (Paperback)
My first impression on receiving "Agile Modeling" was that there is lots of information which could be condensed into tighter passages or sometimes omitted.
I have read Scott Ambler's work before and am an admirer of his contribution to software development. I found the book helpful, as with most of Scott's work, despite the sometimes redundant information.
Despite my cautionary introduction above, I recommend this book to developers and project managers.
In this book the reader can expect to find information on how to implement development processes with Agile Modeling (AM).
This book discusses the processes for development - it does not go into the details on how to use the tools.
There is a comparison chapter on AM and XP which is helpful. AM, like all development processes, is a mixture of art and science. It is not carved in stone - although many may disagree with this statement. This book will help the reader decide what is appropriate to utilize for the project, given the real-world scenarios.
Hope this helps - please let me know if you have any questions or suggestions.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars Modelling for the real world, Aug. 13 2002
By 
Susan (Ottawa, Canada) - See all my reviews
This review is from: Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process (Paperback)
I really liked this book. Ambler describes how modelling actually works in the real world, not how it is supposed to theoretically happen. It is about time somebody stood up and said that modelling is something that all developers should do and that it isn't simply the purview of "professional modellers". It is also refreshing to see someone come out and say that you don't have to do all your modelling up front, that you don't have to use complex CASE modelling tools, and that you don't have to restrict yourself to just the UML. This book provides practical advice for any actively involved in building software.
I especially liked how Ambler didn't waste any time teaching me the basics of object orientation, the UML, data modeling, or any of the other techniques that he refers to in the book. If he had then it would have been huge. He provides summary of a large number of common models in the back of the book, I was surprised how many there were, and suggests when and when not to use them. This is worth the cost of the book alone.
I don't see what the people promoting the MDA are complaining about, Agile Modelling could easily fit right in with the MDA vision. Agile Modelling tells you to use the simplest tool for the job. If someone was to build a CASE modelling tool that actually fulfilled the MDA vision then an Agile Modeller would very likely use it. Of course, such a tool doesn't actually exist yet. Probably why the book doesn't waste any space on it.
I have to agree that the book could have been edited better. It did repeat in places but that's actually good practice when you're trying to teach someone new techniques. Too bad the MDA people didn't understand this. If they had they might have learned something that they could actually use in practice. I think we'll all be waiting a long time for the MDA academics to produce a tool that fulfills their vision. Until then I'll be following the Agile Modelling practices on my whiteboard.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars Ambler's most valuable book to date, Aug. 12 2002
By 
Gary K. Evans "Agile entrepreneur" (Columbia, SC United States) - See all my reviews
(REAL NAME)   
This review is from: Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process (Paperback)
The hype that grew around eXtreme Programming (XP) in the year 2001, and the publication of now almost 2 dozen books devoted to XP has not cleared up the original vagueness of what practices are allowed and what aren't. To a casual observer the XP culture seems replete with "Thou shalt not's"¯ don't do Big Requirements Up Front, don't do Big Design Up Front, don't build models because it's only the code that matters, etc. For those of us who think it's important to have a map of where you are going before you start a long trip, some of the radicalness of XP was¯well, too radical and too unplanned.
Scott Ambler's new book, Agile Modeling, addresses a sane middle ground between the apparent unstructured XP and the overly structured approach in the Rational Unified Process (RUP). Agile Modeling is arguably Ambler's best book to date. It conveys an approach that is truly a confluence of best practices and does so in a very readable, accessible presentation.
Ambler presents Agile Modeling (AM) as a set of values, principles and practices. AM's values are borrowed directly from those in XP: Communication, Simplicity, Feedback and Courage, with Ambler's addition of "humility". In my experience this additional value is a defining characteristic of an effective modeler and mentor. From these 5 values Ambler defines the principles for AM, including: Software is your Primary Goal, Travel Light, Embrace Change, use Multiple Models, etc.

It is interesting to me that no one would refute these principles: they are too close to Motherhood and Apple pie. But it is disturbing how seldom I see any of these principles actually embraced by the dozen or more organizations I provide mentoring services to each year.
The bare-metal practicality of AM is in the chapters on "Agile Modeling in Practice". Here Ambler goes into detail on the practices that support the AM principles. Are you curious how your culture might adopt AM? See his chapter on "Nurturing an Agile Culture". In a quandary over what expensive OO CASE tool to buy? See "Using the Simplest Tools Possible?" In his broad reach in this book Ambler covers issues surrounding how you can effectively set up your work areas, how to conduct modeling sessions, how to staff your AM teams, and more. And each chapter ends with a pragmatic commentary on "How to Make This Work in the Real World".
I predict that if one chapter is read more than any other it will be the one on "Agile Documentation". This is also the longest chapter in the book, and Ambler skillfully addresses the two big questions of "Why Do People Document?" and "When Does a Model Become Permanent?" And if for some perverse reason you didn't read any chapter but this one, it alone would justify the cost of the book.
The last two sections of the book show how to apply these principles and practices to an XP environment (Part 3), and then how they can be applied to a Unified Process environment (Part 4). Again the approach is on the practical application of AM so that you can have a better chance of succeeding on your next (or current) software project.
If you are a software developer, a technical manager or project manager, you cannot afford to dismiss this book. Forty years ago no one did the "waterfall" process (Winston Royce hadn't defined it yet) and forty years from now we will certainly be building software in ways we have not yet even conceived. But this year and for the foreseeable future we will be using every idea from Agile Modeling to build better software faster. As Ambler says about building an agile culture, "You can be agile or you can be fragile." That says it all, so get this book and learn how AM can make you a winner.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


1.0 out of 5 stars Don�t waste your money., Aug. 5 2002
By A Customer
This review is from: Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process (Paperback)
This book is a little bit of common sense wrapped up in a lot of pseudo-religious psychobabble.
Agile modeling is a technique that can be summed up in one sentence. "Use UML wisely". This book attempts to wrap that simple concept up in 25-dollar words and intellectual grandeur. Ambler preaches the value of simplicity for good communications, but has done a poor job of following his own advice; instead he delivers a healthy dose of verbal diarrhea and baffling language.
Tragically, the editor could have really helped, but chose not to. Amblers appalling practice of putting initials and references in brackets every second sentence should have been stopped after the first page. As for the layout, the editor desperately needs to read a book on the correct use of white space because those long blocks of dreary text are just draining to try and read.
Mr. Ambler, I respect your ideas and applaud you standing up to the nonsense of overblown UML diagrams that communicate nothing. Unfortunately you need to rethink you approach, because this book is a classic example of the things you're arguing against.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars I've been waiting for a book like this, May 2 2002
By 
"rick_m_hightower" (Tucson, AZ United States) - See all my reviews
This review is from: Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process (Paperback)
If you are doing software development of any kind, you should read this book. Especially if you are doing Extreme Programming and you erroneously believe modeling has no place in XP. Or, your doing the Unified Process and you feel that your models and documents are more important than a working system, or you feel you are bogged down in documentation and required artifacts (more likely). Agile Modeling (AM) is a modeling methodology that enhances your modeling endeavors despite your process methodology inclination. Agile modeling will help you effectively incorporate modeling into your organization.
The title is only partially accurate as the book covers a lot more than modeling. I know from experience that picking titles is tricky (you can't please everyone). You don't need to be a UML expert to get value of this book. Any software developer should get value out of this book. Modelers, software developers and yes managers will find this material useful. In fact you may want to buy a copy and put it on your manager's desk. This book is original and well thought out. It is also well written and very readable. I wish there were more examples of applying the different artifacts in different phases of the XP life-cycle, but there has to be room for the next edition. The depth is appropriate.
Many UP developers (and other prescriptive processes) get bogged down in the tonnage of documents and artifacts that are required. They wonder if they are ever going to have time to actually write the code.
XP offers a methodology for building high quality software fast. However, many XP developers, and I've spoken to them about this very subject on many occasions, find that XP does include time to do models. This books shows how to integrate XP and modeling.
This book sets the record straight about design and Extreme Programming. Actually, Kent Beck set the record straight with the first book on XP when he said "In the time it would take you to code one design, you can compare and contrast three designs with pictures." Kent Beck's views were corrupted over the years for various reasons that this book explains and finally this book sets the record straight once and for all about XP and modeling.
This book drives the point home about XP and modeling and also explains how to avoid following prescriptive methodologies that require certain artifacts. Instead the book brings out that you should model to understand the problems and only apply the right artifacts, i.e., all modeling lead to writing code.
The AM book transcends just being a book on modeling, despite the title, the book covers many aspects of developing software. The book endeavors to be real. By real I mean it talks about real issues and how things are handled in the real world not a hypothetical world, i.e., not the perfect world covered by most books. For example, the chapter on documentation is an excellent coverage of the subject.
Like the original XP book, the AM book lists values, core principles and practices. It also added supplementary principles like "Content Is More Important Than Representation". A key take away from the book is models are important if they help you understand and solve problems. And, models do not have to be perfect in fact they can be thrown away when you are done with them. After all is said and done: "Software is your Primary Goal".
Strangely enough, the author, Scott Ambler is the author of numerous books (and by numerous I mean a lot) for the Unified Process, and UML. He also contributed to the Mastering EJB Book, and the Java Element of Style book. All his work in UP seems strange since AM seems to have closer ties to XP than UP, but that is probably my own warped misconceptions of the world. Bottom line, Scott has mastered his craft of writing and I really enjoyed his writing style. The first few chapters seemed a little slow probably because it has been covered before in other books. The chapters on AM and XP were really informative and useful (as was the chapter on agile documentation mentioned earlier).
If you are doing software development of any kind, you should read this book. It is an informative and enjoyable read.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars YOU need this book!, April 7 2002
By A Customer
This review is from: Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process (Paperback)
If you are involved in any way with software development, you need this book. Although the title might suggest that it's concerned only with modeling, or with agile processes, the book implicitly (and necessarily) deals with most if not all aspects of the business of developing software.
Because the work was itself actually created using some of the agile practices (most notably, interaction with "customers" via the Agile Modeling mailing list), it speaks remarkably well to the concerns of actual practitioners, and is a remarkably thorough treatment of an issue with broad scope. Following the best principles of both agile development and open-source (and key AM values of Humility and Courage), the author revised and extended the book over the course of several months, displaying many draft elements on the AM website to be reviewed (and criticized) by fellow practitioners.
This book is grounded in reality, discussing what practices (agile and otherwise) people actually use, how they use them, and which of them work. Moreover, it describes many of the MOTIVATIONS behind certain practices, which is invaluable information both in applying (or eschewing) them, and in understanding and predicting the attitudes of various stakeholders to them.
Because it ties so many ideas together, this book will help to define software engineering into the future, even though it does not prescribe a methodology. It is well-structured and easy to use as a reference.
In short, this book has high technical AND business value. Indeed, it has value beyond the software business, probably across most business and engineering disciplines. I have my own copy, and plan to give some away as well.
Buy it.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


5.0 out of 5 stars Very, very practical, April 2 2002
By A Customer
This review is from: Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process (Paperback)
Finally somebody wrote a book like this. I've been following the AM site for awhile now and have been very impressed, and this book goes one step further. Anybody involved with software development needs to read this book. I've been showing it to a couple of Java developers who swear up and down that modeling is a waste of time, but now with this book they're rethinking their ways. If you're working on a project where everyone thinks that modeling means writing a lot of documentation, and I've been on those, then you need to read this book. It's okay to create models on whiteboards!!!!! It's okay to not spend days transcribing those models!!!!!
AM describes real-world, practical techniques for improving your modeling and documentation efforts. Although there is only one chapter on documentation it very likely is the best advice that you're ever going to read on the subject. I wish this book was available years ago when I first started out as a developer, I'd be significantly more productive now. Modeling is one of the few skills that I can see using throughout my entire career -- I was a C programmer a few years ago, I'm a EJB developer now, and a few years from now I don't know what language I'll be programming in. What I do know is that I'll still be modeling, and I'll still be writing documentation, so I need to get good at these two things. Agile Modeling describes exactly how to do this.
Help other customers find the most helpful reviews 
Was this review helpful to you? Yes No


‹ Previous | 1 2 3 | Next ›
Most Helpful First | Newest First

This product

Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process
CDN$ 65.99 CDN$ 41.37
In Stock
Add to cart Add to wishlist
Only search this product's reviews