oder
Loggen Sie sich ein, um 1-Click® einzuschalten.
Jetzt eintauschen
und EUR 0,81 Gutschein erhalten
Eintausch
Alle Angebote
Möchten Sie verkaufen? Hier verkaufen
Der Artikel ist in folgender Variante leider nicht verfügbar
Keine Abbildung vorhanden für
Farbe:
Keine Abbildung vorhanden

 
Den Verlag informieren!
Ich möchte dieses Buch auf dem Kindle lesen.

Sie haben keinen Kindle? Hier kaufen oder eine gratis Kindle Lese-App herunterladen.

Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process (Computer Science) [Englisch] [Taschenbuch]

Scott Ambler
3.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
Preis: EUR 43,32 kostenlose Lieferung. Siehe Details.
  Alle Preisangaben inkl. MwSt.
o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o o
Auf Lager.
Verkauf und Versand durch Amazon. Geschenkverpackung verfügbar.
Lieferung bis Dienstag, 23. September: Wählen Sie an der Kasse Morning-Express. Siehe Details.

Kurzbeschreibung

21. März 2002 Computer Science
XP (Extreme Programming) hat in der Software Development Community jetzt für ähnlichen Aufruhr gesorgt, wie Design Patterns vor ein paar Jahren. Zwar ist XP eine Methodik zur schnelleren Softwareentwicklung, aber sie gibt dem Entwickler nicht genügend Modellierungszeit, die jedoch wichtig ist, um sicherzustellen, dass ein Projekt die gewünschten Anforderungen auch erfüllt. Darüber hinaus funktionieren Standard-Modellierungstechniken auf der Basis von UML (Unified Modeling Language) häufig nicht mit XP. In diesem innovativen Buch präsentiert Software Development Kolumnist Scott Ambler Agile Modeling (AM) - ein Verfahren, das er speziell für die Modellierung von XP-Projekten entworfen hat und das Teile von UML und RUP (Rational's Unified Process) einsetzt. Ambler erklärt anhand zahlreicher Fallstudien anschaulich, was AM ist und wie Software-Experten AM, UML und RUP in ihre Entwicklungsprojekte einbinden können. Die begleitende Website (www.agilemodeling.com) bietet Updates, Links zu XP- und AM-Resources sowie laufende Fallstudien zum Agile Modeling.

Wird oft zusammen gekauft

Agile Modeling: Effective Practices for eXtreme Programming and the Unified Process (Computer Science) + Agile Documentation: A Pattern Guide to Producing Lightweigth Documents for Software Projects: A Pattern Guide to Producing Lightweight Documents for Software Projects (Wiley Software Patterns Series)
Preis für beide: EUR 72,22

Die ausgewählten Artikel zusammen kaufen


Produktinformation

  • Taschenbuch: 404 Seiten
  • Verlag: Wiley; Auflage: 1. Auflage (21. März 2002)
  • Sprache: Englisch
  • ISBN-10: 0471202827
  • ISBN-13: 978-0471202820
  • Größe und/oder Gewicht: 24 x 19 x 2 cm
  • Durchschnittliche Kundenbewertung: 3.0 von 5 Sternen  Alle Rezensionen anzeigen (1 Kundenrezension)
  • Amazon Bestseller-Rang: Nr. 269.697 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
  • Komplettes Inhaltsverzeichnis ansehen

Mehr über den Autor

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Pressestimmen

"...I would not hesitate in recommending this book..." (CVu, October 2004) "...easy-to-follow...enjoyable writing style...overall the book is impressive...valuable reading..." (Software Testing, Verification & Reliability, March 2003)

Synopsis

This is the first book to cover Agile Modeling, a new modeling technique created specifically for XP projects. eXtreme Programming (XP) has created a buzz in the software development community-much like Design Patterns did several years ago. Although XP presents a methodology for faster software development, many developers find that XP does not allow for modeling time, which is critical to ensure that a project meets its proposed requirements. They have also found that standard modeling techniques that use the Unified Modeling Language (UML) often do not work with this methodology. In this innovative book, Software Development columnist, Scott Ambler presents Agile Modeling (AM) - a technique that he created for modeling XP projects using pieces of the UML and Rational's Unified Process (RUP). Ambler clearly explains AM, and shows readers how to incorporate AM, UML, and RUP into their development projects with the help of numerous case studies integrated throughout the book. AM was created by the author for modeling XP projects - an element lacking in the original XP design. The XP community and its creator have embraced AM, which should give this book strong market acceptance.

Its companion website features updates, links to XP and AM resources, and ongoing case studies about agile modeling.


In diesem Buch (Mehr dazu)
Einleitungssatz
When I first read Extreme Programming Explained (Beck 2000), one of the most poignant things about XP for me was how Kent first defined a foundation for his methodology. Lesen Sie die erste Seite
Mehr entdecken
Wortanzeiger
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis | Rückseite
Hier reinlesen und suchen:

Eine digitale Version dieses Buchs im Kindle-Shop verkaufen

Wenn Sie ein Verleger oder Autor sind und die digitalen Rechte an einem Buch haben, können Sie die digitale Version des Buchs in unserem Kindle-Shop verkaufen. Weitere Informationen

Kundenrezensionen

5 Sterne
0
4 Sterne
0
2 Sterne
0
1 Sterne
0
3.0 von 5 Sternen
3.0 von 5 Sternen
Die hilfreichsten Kundenrezensionen
5 von 8 Kunden fanden die folgende Rezension hilfreich
3.0 von 5 Sternen nice thoughts 2. Mai 2002
Format:Taschenbuch
Nice reading - some simple thoughts helped me rethinking:

- models can die (throw away)
- documentation <> models
- models need not to be in sync with the code to be usefull

Some good examples and advise on artifacts / usefullness.

Sadly it is not a "howTo" book for modeling. So while
gradually changing my attitude toward this topic, it gives
no tutorial / best practices.
War diese Rezension für Sie hilfreich?
Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)
Amazon.com: 3.7 von 5 Sternen  26 Rezensionen
26 von 28 Kunden fanden die folgende Rezension hilfreich
4.0 von 5 Sternen A Challenge from Common Sense 3. Februar 2003
Von Vince Kenyon - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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.
14 von 15 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Ambler's most valuable book to date 12. August 2002
Von Gary K. Evans - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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.
13 von 15 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Seeing the forest through the trees 18. August 2002
Von Granville Miller - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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.
12 von 14 Kunden fanden die folgende Rezension hilfreich
5.0 von 5 Sternen Very, very practical 2. April 2002
Von Ein Kunde - Veröffentlicht auf Amazon.com
Format:Taschenbuch
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.
11 von 13 Kunden fanden die folgende Rezension hilfreich
2.0 von 5 Sternen You can have way too much of a good thing 17. Februar 2007
Von John Bonavia - Veröffentlicht auf Amazon.com
Format:Taschenbuch
This is a mix of good, bad, and annoying

Good: 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. What's with adding surrogate keys to every table? This is a pernicious practice that has become all too common from people who never learned relational theory and try to fit relational into the object model. A giveaway is that he calls his "identity" columns "persistent object identifiers." Yes, sometimes they are necessary or useful, but in general the natural key is way better. In his Customer table, there is a customer number - but it's not the primary key, a pesky OID is! He himself acknowledges that this may give performance problems, or at least not be optimal. It implies more indexing and triggers...oh well, enough already. Just don't let RDBMS gurus like Fabian Pascal or Joe Celko see that chapter.

Slightly annoying: A few little niggles about English usage etc - by now you would think that any publisher's editor would know that "supersede" has no "c" in it, and that you can't be "reticent to" something - the word is "reluctant. Odd. On the other hand, thank goodness for someone who understands why it's "co-located" not the bizarre "collocated" that I see far too often.

Really annoying: Basically, Einstein's phrase above could have replaced about half the book. It's incredibly repetitious, and also over-organized, over-conceptualized, over-categorized, generally over-inflated. We need a discipline of Agile Communication! An end to ListMania! A thoroughgoing refactoring of the contents is in order. His four Parts and thirty Chapters contain massive redundancy. The matching of agile modeling precepts, in finest detail, to the equally excruciating detail of the RUP, is really an unnecessary exercise. We don't have TIME for this!

As someone else said, a short White Paper could have replaced the entire book. Hence the two stars, good though some of the material is.
Waren diese Rezensionen hilfreich?   Wir wollen von Ihnen hören.
Kundenrezensionen suchen
Nur in den Rezensionen zu diesem Produkt suchen

Kunden diskutieren

Das Forum zu diesem Produkt
Diskussion Antworten Jüngster Beitrag
Noch keine Diskussionen

Fragen stellen, Meinungen austauschen, Einblicke gewinnen
Neue Diskussion starten
Thema:
Erster Beitrag:
Eingabe des Log-ins
 

Kundendiskussionen durchsuchen
Alle Amazon-Diskussionen durchsuchen
   


Ähnliche Artikel finden


Ihr Kommentar