CDN$ 65.60
  • List Price: CDN$ 88.00
  • You Save: CDN$ 22.40 (25%)
Only 4 left in stock (more on the way).
Ships from and sold by Amazon.ca.
Gift-wrap available.
Quantity:1
Add to Cart
Have one to sell?
Flip to back Flip to front
Listen Playing... Paused   You're listening to a sample of the Audible audio edition.
Learn more
See all 2 images

Agile Software Development, Principles, Patterns, and Practices Hardcover – Oct 15 2002


Amazon Price New from Used from
Hardcover
"Please retry"
CDN$ 65.60
CDN$ 65.00 CDN$ 46.90

Join Amazon Student in Canada



Frequently Bought Together

Agile Software Development, Principles, Patterns, and Practices + Clean Code: A Handbook of Agile Software Craftsmanship + The Clean Coder: A Code of Conduct for Professional Programmers
Price For All Three: CDN$ 127.95

Show availability and shipping details


Customers Who Bought This Item Also Bought

NO_CONTENT_IN_FEATURE

Product Details

  • Hardcover: 529 pages
  • Publisher: Prentice Hall; 1 edition (Oct. 15 2002)
  • Language: English
  • ISBN-10: 0135974445
  • ISBN-13: 978-0135974445
  • Product Dimensions: 25.7 x 20.3 x 2.3 cm
  • Shipping Weight: 1.2 Kg
  • Average Customer Review: 4.7 out of 5 stars  See all reviews (23 customer reviews)
  • Amazon Bestsellers Rank: #14,531 in Books (See Top 100 in Books)
  • See Complete Table of Contents


What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

4.7 out of 5 stars
Share your thoughts with other customers

Most helpful customer reviews

1 of 1 people found the following review helpful By wiredweird on 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? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again.
1 of 1 people found the following review helpful By Amazon Customer on 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? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again.
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? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again.
Format: Hardcover
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.
Second, I have a question hoping that someone can explaint it to me. When Uncle Bob talk about the LSP(Liskov Principle), he give an example----Line and LineSegment, if you remember that, read on...
This example confuse me so much, we use inheritation because the two class contain differences (at least one). If in this situation we cannot use inheritation, what else can we? Recalling the memory of most the codes I have written, the child classes have different behavior when comparing with its father class, in those situataions, I should do the drawing actions? Then in what situation should we use the inheritation?
If you have your ideas, please be free to contact me through email, I am dying to share the master's thinking with you!
Was this review helpful to you? Yes No Sending feedback...
Thank you for your feedback. If this review is inappropriate, please let us know.
Sorry, we failed to record your vote. Please try again.

Product Images from Customers

Most recent customer reviews

Search


Feedback