Vous voulez voir cette page en français ? Cliquez ici.


or
Sign in to turn on 1-Click ordering.
or
Amazon Prime Free Trial required. Sign up when you check out. Learn More
More Buying Choices
Have one to sell? Sell yours here
Tell the Publisher!
I'd like to read this book on Kindle

Don't have a Kindle? Get your Kindle here, or download a FREE Kindle Reading App.

Agile Software Development, Principles, Patterns, and Practices [Hardcover]

Robert C. Martin
4.7 out of 5 stars  See all reviews (23 customer reviews)
List Price: CDN$ 88.00
Price: CDN$ 70.40 & FREE Shipping. Details
You Save: CDN$ 17.60 (20%)
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
Only 1 left in stock (more on the way).
Ships from and sold by Amazon.ca. Gift-wrap available.
Want it delivered Tuesday, November 4? Choose One-Day Shipping at checkout.
There is a newer edition of this item:
Agile Software Development Principles Pa Agile Software Development Principles Pa
Currently unavailable

Book Description

Oct. 15 2002 0135974445 978-0135974445 1

Written by a software developer for software developers, this book is a unique collection of the latest software development methods. The author incudes OOD, UML, Design Patterns, Agile and XP methods with a detailed description of a complete software design for reusable programs in C++ and Java. Using a practical, problem-solving approach, it shows how to develop an object-oriented application -- from the early stages of analysis, through the low-level design and into the implementation. Walks readers through the designer's thoughts — showing the errors, blind alleys, and creative insights that occur throughout the software design process. Covers: Statics and Dynamics; Principles of Class Design; Complexity Management; Principles of Package Design; Analysis and Design; Patterns and Paradigm Crossings. Explains the principles of OOD, one by one, and then demonstrates them with numerous examples, completely worked-through designs, and case studies. Covers traps, pitfalls, and work arounds in the application of C++ and OOD and then shows how Agile methods can be used. Discusses the methods for designing and developing big software in detail. Features a three-chapter, in-depth, single case study of a building security system. For Software Engineers, Programmers, and Analysts who want to understand how to design object oriented software with state of the art methods.


Frequently Bought Together

Agile Software Development, Principles, Patterns, and Practices + Working Effectively with Legacy Code + Clean Code: A Handbook of Agile Software Craftsmanship
Price For All Three: CDN$ 145.98

Some of these items ship sooner than the others.


Customers Who Bought This Item Also Bought


Product Details


Product Description

From the Inside Flap

Agile development is the ability to develop software quickly, in the face of rapidly changing requirements. In order to achieve this agility, we need to employ practices that provide the necessary discipline and feedback. We need to employ design principles that keep our software flexible and maintainable, and we need to know the design patterns that have been shown to balance those principles for specific problems. This book is an attempt to knit all three of these concepts together into a functioning whole.

This book describes those principles, patterns, and practices and then demonstrates, how they are applied by walking through dozens of different case studies. More importantly, the case studies are not presented as complete works. Rather, they are designs in progress. You will see the designers make mistakes, and you will observe how they identify the mistakes and eventually correct them. You will see them puzzle over conundrums and worry over ambiguities and trade-offs. You will see the act of design.

The Devil Is in the Details

This book contains a lot of Java and C++ code. I hope you will carefully read that code since, to a large degree, the code is the point of the book. The code is the actualization of what this book 6~ '' has to say.

There is a repeating pattern to this book. It consists of a series of case studies of varying sizes. Some are very small, and some require several chapters to describe. Each case study is preceded by /material that is meant to prepare you for it. For example, the Payroll case study is preceded by chapters describing the object-oriented design principles and patterns used in the case study.

The book begins with a discussion of development practices and processes. That discussion is punctuated by a number of small case studies and examples. From there, the book moves on to the topic of design and design principles, and then to some design patterns, more design principles that govern packages, and more patterns. All of these topics are accompanied by case studies.

So prepare yourself to read some code and to pore over some UML diagrams. The book you are about to read is very technical, and its lessons, like the devil, are in the details.

A Little History

Over six years ago, I wrote a book entitled Designing Object-Oriented C++ Applications using the Booch Method. It was something of magnum opus for me, and I was very pleased with the result and with the sales.

This book started out as a second edition to Designing, but that's not how it turned out. Very little remains of the original book in these pages. Little more than three chapters have been carried through, and those chapters have been massively changed. The intent, spirit, and many of the lessons of the book are the same. And yet, I've learned a tremendous amount about software design and development in the six years since Designing came out. This book reflects that learning.

What a half-decade! Designing came out just before the Internet collided with the planet. Since then, the number of abbreviations we have to deal with has doubled. We have Design Patterns, Java, EJB, RMI, J2EE, XML, XSLT, HTML, ASP, JSP, Servlets, Application Servers, ZOPE, SOAP, C#, .NET, etc., etc. Let me tell you, it's been hard to keep the chapters of this book reasonably current!

The Booch Connection

In 1997, I was approached by Grady Booch to help write the third edition of his amazingly successful Object-Oriented Analysis and Design with Applications. I had worked with Grady before on some projects, and I had been an avid reader and contributor to his various works, including UML. So I accepted with glee. I asked my good friend Jim Newkirk to help out with the project.

Over the next two years, Jim and I wrote a number of chapters for the Booch book. Of course, that effort meant that I could not put as much effort into this book as I would have liked, but I felt that the Booch book was worth the contribution. Besides, this book was really just a second edition of Designing at the time, and my heart wasn't in it. If I was going to say something, I wanted to say something new and different.

Unfortunately, that version of the Booch book was not to be. It is hard to find the time to write a book during normal times. During the heady days of the ".com" bubble, it was nearly impossible. Grady got ever busier with Rational and with new ventures like Catapulse. So the project stalled. Eventually, I asked Grady and Addison Wesley if I could have the chapters that Jim and I wrote to include in this book. They graciously agreed. So several of the case study and UML chapters came from that source.

The Impact of Extreme Programming

In late 1998, XP reared its head and challenged our cherished beliefs about software development. Should we create lots of UML diagrams prior to writing any code, or should we eschew any kind of diagrams and just write lots of code? Should we write lots of narrative documents that describe our design, or should we try to make the code narrative and expressive so that ancillary documents aren't necessary? Should we program in pairs? Should we write tests before we write production code? What should we do?

This revolution came at an opportune time for me. During the middle to late 90s, Object Mentor was helping quite a few companies with object-oriented (OO) design and project management issues. We were helping companies get their projects done. As part of that help, we instilled our own attitudes and practices into the teams. Unfortunately, these attitudes and practices were not written down. Rather, they were an oral tradition that was passed from us to our customers.

By 1998, I realized that we needed to write down our process and practices so that we could better articulate them to our customers. So, I wrote many articles about process in the C++ Report. These articles missed the mark. They were informative, and in some cases entertaining, but instead of codifying the practices and attitudes that we actually used in our projects, they were an unwitting compromise to values that had been imposed upon me for decades. It took Kent Beck to show me that.

The Beck Connection

In late 1998, as I was fretting over codifying the Object-Mentor process, I ran into Kent's work on Extreme Programming (XP). The work was scattered through Ward Cunningham's wiki and was mixed with the writings oil many others. Still, with some work and diligence I was able to get the gist of what Kent was talking about. I was intrigued, but skeptical. Some of the things that XP talked about were exactly on target for my concept of a development process. Other things, however, like the lack of an articulated design step, left me puzzled.

Kent and I could not have come from more disparate software circumstances. He was a recognized Smalltalk consultant, and I was a recognized C++ consultant. Those two worlds found it difficult to communicate with one' another. There was an almost Kuhnian paradigm gulf between them.

Under other circumstances, I would never have asked Kent to write an article for the C++ Report. But the congruence of our thinking about process was able to breech the language gulf. In February of 1999, I met Kent in Munich at the OOP conference. He was giving a talk on XP in the room across from where I was giving a talk on principles of OOD. Being unable to hear that talk, I sought Kent out at lunch. We talked about XP, and I asked him to write an article for the C++ Report. It was a great article about an incident in which Kent and a coworker had been able to make a sweeping design change in a live system in a matter of an hour or so.

Over the next several months, I went through the slow process of sorting out my own fears about XP My greatest fear was in adopting a process in which there is no explicit up-front design step. I found myself balking at that. Didn't I have an obligation to my clients, and to the industry as a whole, to teach them that design is important enough to spend time on?

Eventually, I realized that I did not really practice such a step myself. Even in all the articles and books I had written about design, Booch diagrams, and UML diagrams, I had always used code as a way to verify that the diagrams were meaningful. In all my customer consulting, I would spend an hour or two helping them to draw diagrams and then I would direct them to explore those diagrams with code. I came to understand that though XP's words about design were foreign (in a Kuhnian sense), the practices behind the words were familiar to me.

My other fears about XP were easier to deal with. I had always been a closet pair programmer. XP gave me a way to come out of the closet and revel in my desire to program with a partner. Refactoring, continuous integration, and customer on-site were all very easy for me to accept. They were very close to the way I already advised my customers to work.

One practice of XP was a revelation for me. Test-first design sounds innocuous when you first hear it. It says to write test cases before you write production code. All production code is written to make failing test cases pass. I was not prepared for the profound ramifications that writing code this way would have. This practice has completely transformed the way I write software, and transformed it for the better. You can see that transformation in this book. Some of the code written in this book was written before 1999. You won't find test cases for that code. On the other hand, all of the code written after 1999 is presented with test cases, and the test cases are typically presented first. I'm sure you'll note the difference.

So, by the fall of 1999 I was convinced that Object Mentor should adopt XP as its process of choice and that I should let go of my desire to write my own process. Kent had done an excellent job of articulating the practices and process of XP, and my own feeble attempts paled in comparison.

Organization

This book is organized into six major sections followed by several appendices.

  • Section 1: Agile Development
    This section describes the concept of agile development. It starts with the Manifesto of the Agile Alliance, provides an overview of Extreme Programming (XP), and then goes into many small case studies that illuminate some of the individual XP practices—especially those that have an impact upon the way we design and write code.
  • Section 2: Agile Design
    The chapters in this section talk about object-oriented software design. The first chapter asks the question, What is Design? It discusses the problem of, and techniques for, managing complexity. Finally, the section culminates with the principles of object-oriented class design.
  • Section 3: The Payroll Case Study
    This is the largest and most complete case study in the book. It describes the object-oriented design and C++ implementation of a simple batch payroll system. The first few chapters in this section describe the design patterns that the case study encounters. The final two chapters contain the full case study.
  • Section 4: Packaging the Payroll System
    This section begins by describing the principles of object-oriented package design. It then goes on to illustrate those principles by incrementally packaging the classes from the previous section.
  • Section 5: The Weather Station Case Study
    This section contains one of the case studies that was originally planned for the Booch book. The Weather Station study describes a company that has made a significant business decision and explains how the Java development team responds to it. As usual, the section begins with a description of the design patterns that will be used and then culminates in the description of the design and implementation.
  • Section 6: The ETS Case Study
    This section contains a description of an actual project that the author participated in. This project has been in production since 1999. It is the automated test system used to deliver and score the registry examination for the National Council of Architectural Registration Boards.
  • UML Notation Appendices:
    The first two appendices contains several small case studies that are used to describe the UML notation.
  • Miscellaneous Appendices
How to Use This Book If You are a Developer...

Read the book cover to cover. This book was written primarily for developers, and it contains the information you need to develop software in an agile manner. Reading the book cover to cover introduces practices, then principles, then patterns, and then it provides case studies that tie them all together. Integrating all this knowledge will help you get your projects done.

If You Are a Manager or Business Analyst...

Read Section 1, Agile Development. The chapters in this section provide an in-depth discussion of agile principles and practices. They'll take you from requirements to planning to testing, refactoring, and programming. It will give you guidance on how to build teams and manage projects. It will help you get your projects done.

If You Want to Learn UML...

First read Appendix A, UML Notation 1: The CGI Example. Then read Appendix B, UML Notation II: The STATMUX. Then, read all the chapters in Section 3, The Payroll Case Study. This course of reading will give you a good grounding in both the syntax and use of UML. It will also help you translate between UML and a programming language like Java or C++.

If You Want to Learn Design Patterns...

To find a particular pattern, use the "List of Design Patterns" on page xxii to find the pattern you are interested in.

To learn about patterns in general, read Section 2, Agile Design to first learn about design principles, and then read Section 3, The Payroll Case Study; Section 4, Packaging the Payroll System; Section 5, The Weather Station Case Study; and Section 6, The ETS Case Study. These sections define all the patterns and show how to use them in typical situations.

If You Want to Learn about Object-Oriented Design Principles...

Read Section 2, Agile Design; Section 3, The Payroll Case Study; and Section 4, Packaging the Payroll System. These chapters will describe the principles of object-oriented design and will show you how to use them.

If You Want to Learn about Agile Development Methods...

Read Section 1, Agile Development. This section describes agile development from requirements to planning, testing, refactoring, and programming.

If You Want a Chuckle or Two...

Read Appendix C, A Satire of Two Companies.

From the Back Cover

Best selling author and world-renowned software development expert Robert C. Martin shows how to solve the most challenging problems facing software developers, project managers, and software project leaders today.

    This comprehensive, pragmatic tutorial on Agile Development and eXtreme programming, written by one of the founding father of Agile Development:
  • Teaches software developers and project managers how to get projects done on time, and on budget using the power of Agile Development.
  • Uses real-world case studies to show how to of plan, test, refactor, and pair program using eXtreme programming.
  • Contains a wealth of reusable C++ and Java code.
  • Focuses on solving customer oriented systems problems using UML and Design Patterns.

Robert C. Martin is President of Object Mentor Inc. Martin and his team of software consultants use Object-Oriented Design, Patterns, UML, Agile Methodologies, and eXtreme Programming with worldwide clients. He is the author of the best-selling book Designing Object-Oriented C++ Applications Using the Booch Method (Prentice Hall, 1995), Chief Editor of, Pattern Languages of Program Design 3 (Addison Wesley, 1997), Editor of, More C++ Gems (Cambridge, 1999), and co-author of XP in Practice, with James Newkirk (Addison-Wesley, 2001). He was Editor in Chief of the C++ Report from 1996 to 1999. He is a featured speaker at international conferences and trade shows.


Sell a Digital Version of This Book in the Kindle Store

If you are a publisher or author and hold the digital rights to a book, you can sell a digital version of it in our Kindle Store. Learn more

What Other Items Do Customers Buy After Viewing This Item?


Customer Reviews

Most helpful customer reviews
1 of 1 people found the following review helpful
5.0 out of 5 stars Clear, specifc, applicable April 29 2004
Format:Hardcover
The bulk of this book describes OO design principles. They're presented in a readable, useful, and well-organized way. Often they just clarify and put a name to something you've probably been doing anyway. The standard Dependency Inversion Principle is there, for one. (I'm glad to see that other people have trouble with the name. By today's reckoning, there's nothing inverted about it, but the name dates back to less enlightened times.) Others, like the Interface Segregation Principle, are less well known but reinforce lots of other good practices, such as data hiding and prevention of "interface leakage".
The "Agile" section is blessedly short, and doesn't much contaminate the otherwise good presentation elsewhere in the book. There's a lot of good to be extracted from the agility movement, but there's a lot of rabid dogmatism too. Martin managed to keep it well under control. He presented the Manifesto (ugh) early on, but that was the worst of it.
A few points marred the book, but only slightly, The drawings came across as "cute" - unprofessional and tangential to the topics at hand. Semi-fictional conversations in books like this always seem fatuous to me, and Ch.6 was no exception. The technical content managed to withstand this presentation anyway.
This book has lots of good ideas. It relates those ideas well to common and useful design patterns. A few aspects of the book tried to be funny, but came across as more annoying than anything else. That was only a few, though - the meaningful content of the book came through despite those flaws.
I recommend this book to any serious student or practitioner of OO design and implementation. I really mean "any," since even project-scarred veterans are likely to see some of their hard won knowledge set into clear text and into the context of other ideas.
Was this review helpful to you?
1 of 1 people found the following review helpful
5.0 out of 5 stars PPP are excellent, but not the XP Sept. 3 2003
By Ray Ye
Format:Hardcover
I am not a XPer, and I am not convinced to be one after reading this book. The first section (Agile Development) sketches XP(Extreme Programming). It reads "Everybody works on the GUI. Everybody works on the middleware. Everybody works on the database..." Basically, everybody works on everything. Have a doudt yet? Here is more, "Individuals and interactions over process...Working software over comprehensive documentation".
It seems to me that XP team is an elite team, whose members are the industry experts with aboundant design knowledge and experience, they know OO technology deep inside and out. To form such a team is a luxury even if it is affordable. In normal corporate environment, team members are at different level with different specialties, it is more beneficial to the corporate to utilize these specialities, e.g., to ask a GUI person to design database or ask a server-side developer to write GUI would cause unnecessary slow-down (if not disaster) of the project.
Generally speaking, relying on individual over process is not a safe play for any companies. People on the team come and go, how do you keep the project going? How do you train the new comer to catch up with the project? Reading code is definitely one way, but a slow way I believe. Without have a big picture of whole application architecture, diving into thousands of lines of codes is intimidating and frustrating. Documentation is one important step in the software develop process. Design document (of course, keeps up with the design/code change) is a good way to start, diagams are far more easier to descibe the functionalities of the application, and its modules, and their interactivities.
Read more ›
Was this review helpful to you?
1 of 1 people found the following review helpful
2.0 out of 5 stars Book in two parts fails to excel at either Nov. 28 2003
Format:Hardcover
This is really two books; one is on agile development. The other is on design pattern examples. Unfortunately, it fails to be really tremendous at either.
The agile development part lacks much of the pragmatism of more recently published books on agility, espousing principles quite nicely, but avoiding all of the tricky issues around larger teams, products where the architecture -- as well as the product itself -- is a deliverable, etc.
The design pattern examples were pretty reasonable, but there are already more comprehensive tomes available online for free. The examples provided were just large enough to obscure the reading of the patterns themsevles and inhibit browsing (unlike the GoF book, which treads that line quite nicely).
Was this review helpful to you?
5.0 out of 5 stars Get it. Read it. Use it. Feb. 23 2004
Format:Hardcover
I bought this book after attending a conference and meeting Uncle Bob himself. If you ever have the chance to see Bob in living color (and remember to ask him why we see the colors we do) don't pass it up. In order to get the most out of this book you need to be open to his philosophy and have some experience. I say this, because I feel it's only after you can say to yourself "I know exactly what you're talking about", or in my case, "Geez, I'm guilty of that", that you understand the principles Bob is trying to get across and the applicability, or lack there-of, of patterns.
Bob does an excellent job of setting up the material and then showing an example (a believable one at that) of how to apply the concepts. For example, he will introduce a set of patterns and then provide a case study that applies those patterns. This book is not only useful for those new to the material, but the format is also very good to be used as a reference.
While his explanation of the different patterns is very good, I believe it's his principles and test-driven-development philosophy that are the real gems in this book. These are principles and practices that every developer should be familiar with. In fact, this is a great approach for junior developers so they can become disciplined. In a world where everyone seems to be an "Architect", I'm amazed at how many don't convey and don't practice similiar thoughts. If you can't open yourself up to the "model your idea up on a white-board, erase, code test case, code logic" mentality, then it will be very difficult to see the intuitiveness of Bob's writing. Bob has provided a job-aid to all of us and we'd be in a lot better shape as software professionals if we followed just a few of these principles.
Was this review helpful to you?
Most recent customer reviews
5.0 out of 5 stars A Question When Reading the Book.
First, I will say it is an excellent book, anyone who is looking at the front page and thinking about the payment should not hestitate anymore. Read more
Published on Nov. 20 2003 by Sticker Ji
5.0 out of 5 stars One of the Most Valuable Library Additions in Years
I find myself going back to this book over and over again. It's true that it makes a great compendium of a wide range of topics, but to me, one of the best things about this book... Read more
Published on Oct. 17 2003 by R. Williams
5.0 out of 5 stars Extra Credit Bob for mentioning Kuhn twice!
As a developer new to OO programming I have struggled (and still continue to) to wrap my head around the power of objects.
How do I construct well designed OO software? Read more
Published on Aug. 19 2003 by Shane Mingins
5.0 out of 5 stars Wonderful piece of writing
I just finished reading the book _Agile Software Development_ and I think it is an excellent piece of writing. Read more
Published on Aug. 8 2003 by Robert T. Walsh
5.0 out of 5 stars A wonderful adjunct to the GOF design patterns book
The title of this book belies much of its content. While agile development practices are espoused, much of the content is concerned with the application of design patterns in... Read more
Published on July 9 2003 by M. Simpson
5.0 out of 5 stars Gotta have it.
This book has had a profound effect on my coding. Uncle Bob does a masterful job putting together the fundamental principles, patterns, and practices that make him and his cohorts... Read more
Published on July 2 2003 by jeremy
5.0 out of 5 stars deserves the five stars
No other book has these topics -- Design Patterns, Test Driven Development, and Object Oriented Design Principles -- within its covers, with such extensive examples. Read more
Published on April 21 2003 by C. Keith Ray
5.0 out of 5 stars If I Only Bought Two OOD Books, This Would be One of Them
I don't think I've given another design/programming book 5 stars before. This book deserves it-- it could easily replace a half dozen books on my shelf, and it probably will. Read more
Published on April 1 2003 by David C. Veeneman
5.0 out of 5 stars Anyone I hire will have to read this book!
My first thoughts were "Hmm.. Uncle Bob's written another book. Hmm... another Agile development book. Yup. Read more
Published on Feb. 21 2003 by Dave Astels
Search Customer Reviews
Only search this product's reviews

Look for similar items by category


Feedback