File Size: 6616 KB
Print Length: 400 pages
Publisher: Wiley; 1 edition (April 21, 2008)
Publication Date: April 21, 2008
X-Ray: Not Enabled
Word Wise: Not Enabled
Lending: Not Enabled
Enhanced Typesetting: Not Enabled
Best Sellers Rank: #1,105,002 Paid in Kindle Store (See Top 100 Paid in Kindle Store) #50 in Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Quality Control #235 in Books > Business & Money > Management & Leadership > Quality Control & Management > Agile #1541 in Kindle Store > Kindle eBooks > Computers & Technology > Programming > Software Design > Software Development
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 softwareAM 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.
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.
This is a mix of good, bad, and annoyingGood: the author really does know a lot about modeling (except data modeling, see "Bad") and gives good explanations and examples of many aspects of modeling at many stages in the development process. If you can plough through his 350+ pages, you will have found many stimulating and practical concepts and some good advice on implementing them.A very good chapter is Chapter 29 - a discussion of how to implement Agile Modeling - or really, any agile practice - in a usually hostile world. Some battle scars showing here!I also like that he does not consider the UML the be-all and end-all of modeling tools. Like him, I've found good use for the trusty old DFD (Data Flow Diagram) of the 70's, where appropriate.And his overall message - that the agile approach can extend to your design and modeling task, not just code, and the implications for minimizing the documentation effort - is very strong.I find his reference to quick diagrams "on the back of a napkin" a bit overdone. Sure, the quick informal diagram is excellent, but paper napkins are not the best medium! Hand-drawn on a piece of paper, or a card, sure...if you are discussing models in a bar or restaurant with that degree of focus...get a life!Whiteboard and digital camera can certainly be used much more than they are. But the overall point is excellent: that when you are documenting (and he has some difficulty separating out "modeling" from "documenting" and acknowledges the problem) you are not creating the end-product, and there is a cost for that. "Travel light" - yes. As Einstein said "Everything should be as simple as possible, but no simpler."Bad: his data model example is terrible.