Growing Object-Oriented Software, Guided by Tests (Addiso... and over one million other books are available for Amazon Kindle. Learn more
CDN$ 39.68
  • List Price: CDN$ 62.99
  • You Save: CDN$ 23.31 (37%)
Only 2 left in stock (more on the way).
Ships from and sold by Amazon.ca.
Gift-wrap available.
Quantity:1
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

Growing Object-Oriented Software, Guided by Tests Paperback – Oct 12 2009


See all 2 formats and editions Hide other formats and editions
Amazon Price New from Used from
Kindle Edition
"Please retry"
Paperback
"Please retry"
CDN$ 39.68
CDN$ 37.33 CDN$ 60.32

2014 Books Gift Guide
Thug Kitchen is featured in our 2014 Books Gift Guide. More gift ideas

Special Offers and Product Promotions

  • Join Amazon Student in Canada


Frequently Bought Together

Growing Object-Oriented Software, Guided by Tests + Clean Code: A Handbook of Agile Software Craftsmanship
Price For Both: CDN$ 72.43

One of these items ships sooner than the other.


Customers Who Bought This Item Also Bought



Product Details

  • Paperback: 384 pages
  • Publisher: Addison-Wesley Professional; 1 edition (Oct. 12 2009)
  • Language: English
  • ISBN-10: 0321503627
  • ISBN-13: 978-0321503626
  • Product Dimensions: 17.8 x 2.3 x 23.1 cm
  • Shipping Weight: 621 g
  • Average Customer Review: 2.0 out of 5 stars  See all reviews (1 customer review)
  • Amazon Bestsellers Rank: #129,660 in Books (See Top 100 in Books)
  • See Complete Table of Contents

Product Description

About the Author

Steve Freeman is an independent consultant specializing in Agile software development. A founder member of the London Extreme Tuesday Club, he was chair of the first XPDay and is a frequent organizer and presenter at international conferences. Steve has worked in a variety of organizations, from writing shrink-wrap software for IBM, to prototyping for major research laboratories. Steve has a Ph.D. from Cambridge University, and degrees in statistics and music. Steve is based in London, UK.

 

Nat Pryce has worked as a programmer, architect, trainer, and consultant in a variety of industries, including sports reportage, marketing communications, retail, telecoms, and finance. With a Ph.D. from Imperial College London, he has also worked on research projects and does occasional university teaching. An early adopter of Extreme Programming, he has written or contributed to several open source libraries that support Test Driven Development. He was one of the founding organizers of the London XPDay and regularly presents at international conferences. Nat is based in London, UK.

 

Freeman and Pryce were joint winners of the 2006 Agile Alliance Gordon Pask award.

 


Inside This Book (Learn More)
Browse Sample Pages
Front Cover | Copyright | Table of Contents | Excerpt | Index
Search inside this book:

What Other Items Do Customers Buy After Viewing This Item?

Customer Reviews

2.0 out of 5 stars
5 star
0
4 star
0
3 star
0
2 star
1
1 star
0
See the customer review
Share your thoughts with other customers

Most helpful customer reviews

0 of 6 people found the following review helpful By JEAN MILLO on April 14 2012
Format: Paperback Verified Purchase
Bien que présentant une approche très intéressante, ce livre est un commentaire pas à pas du développement d'une application Java en utilisant des outils exclusivement Java. Une analyse plus exhaustive des diverse plateformes de simulation d'objets tant en étendue (langages) que profondeur (théorie) aurait été la bienvenue. Je m'attendais à un livre de cuisine, je n'ai eu que des recettes.
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.

Most Helpful Customer Reviews on Amazon.com (beta)

Amazon.com: 36 reviews
66 of 68 people found the following review helpful
Deep OO and TDD in one book Nov. 25 2009
By Michael C. Feathers - Published on Amazon.com
Format: Paperback
There are many books about Test-Driven Development on the market, but this book is unique. It presents a style of TDD which originated in the London software development community. It's a style which pushes several key ideas to the extreme: "tell, don't ask" object design, fully end-to-end incremental development, and the deep synergy between testability and good design. Steve and Nat have done a stellar job refining and presenting these ideas. The text is lucid and precise. When you read this book you'll be exposed to far more than just another style of TDD, you'll be exposed to a depth of insight about emergent object oriented design which is both rare and extremely valuable.
43 of 45 people found the following review helpful
Excellent TDD book for actual practitioners Jan. 13 2010
By Bas Vodde - Published on Amazon.com
Format: Paperback Verified Purchase
This book has been in my Amazon pre-ordered list for quite a while and I was looking forward to this. I found the title alone already excellent. Steven and Nat (authors of jMock) are well known expert TDD practitioners, so I was looking forward to what they had to say. The book was better than I had expected.

The book consists of 5 parts. The first part of a very quick introduction to TDD and jMock. The second part discusses the tdd cycle in more detail. The third part (150 pages) is a very large example of growing a piece of software. The fourth part discusses topics on how to sustain TDD and the last part covers some advanced topics.

In this review, I'll skip part 1 as it was short and nothing special. Part two covers the TDD cycle and the link to evolutionary design. Steve and Nat have a design style that focuses almost purely on the interactions between classes which are most frequently tested using expectations on mock objects (which, as authors of jMock, they have lots of experience with). Most notable from part 2, for me, were the classifications of objects that they used, the strong focus on interaction and mocking (more than I usually have when test-driving) and their lack of focus on classes but focus on roles and responsibilities. Nat and Steve clarify their thinking exceptionally well which makes it all easy to understand.

Part 3 takes the largest part of the book, which is where they test-drive an AuctionSniper application. It is a small application, but large for a book example. The authors show how they gradually build up the application by adding one test at the time and how they gained insights during this process which made them adjust their design. I had mixed feelings about this part as a book didn't seem like the best medium for doing this, but still I appreciate the insights they had and also their attempt to make it as close to "real world" as possible.

Writing tests is one thing, maintaining them in another. Part 4 discusses how to make the tests maintainable and the tdd cycle sustainable. Personally, I found this part very insightful and the authors discipline exemplar. The authors start of with different test smells and what to do about it. They then discuss readability of the tests and of the error messages and spend some time of test object creation. Most notable from that part (for me) was their focus on using builders for creating test data, rather than object mothers.

The final part covers three (or actually two!) advanced topics. First is testing persistence where most interesting was how the authors seemed to prefer to "go all the way" whereas the common advise (for test speed) is to rollback and mock more. (this was actually a common theme in their book). The last two chapters deal with multi-threading and async code. I was unclear why these were separated in two chapters and they they were in this particular order. The content was excellent though, except that I missed some typical design guidelines related to multi-threading design. It almost felt they were in a hurry to write the last two chapters...

Anyways, in conclusion, this will definitively be one of my favorite (if not the favorite) TDD books and general design books. Steven and Nat did a wonderful job on this one. Though the book is not perfect, I enjoyed it thoroughly. A definite recommendation for anyone interested in modern design and TDD.
20 of 21 people found the following review helpful
This GREAT book deserves a better kindle version Nov. 26 2012
By Bigodines - Published on Amazon.com
Format: Kindle Edition Verified Purchase
This is a GREAT book... one of those you don't wanna stop reading. But the kindle version sux so bad that I gave up when I saw the first code samples...

A programming book with code samples that are almost impossible to read is a huge drawback. 70% of the value is lost in the kindle version.. I am sure that sooner or later this will be fixed but until then... stick to the printed version.
21 of 23 people found the following review helpful
Food for nurturing your TDD mastery Dec 17 2009
By Johannes Link - Published on Amazon.com
Format: Paperback
In a way this book presents the essence of a decade of test-driven development practice. The authors bring together the various tools of uptodate TDD like mock objects, bdd-style naming and acceptance tests. Open the book on any chapter and you will most likely find useful and deep advice, even if you consider yourself already a TDD expert.

There's one catch, though, that made me lower the rating to 4 stars: The authors go for an extended example which covers the full TDD cycle; from a walking skeleton, to the first acceptance test, into many obvious and some non-obvious refactorings. As noble as this endeavour is, it didn't work for me as a reader. Coming back to the text - and the code - after a day or two I often got lost trying to grasp the subtle nuances; I just couldn't remember all the necessary details of previous chapters.

Nonetheless, it's an excellent book and I enjoyed it. Get a copy, read it and become a better TDD practitioner.
9 of 9 people found the following review helpful
5 stars on the non-case study parts June 20 2011
By Jeanne Boyarsky - Published on Amazon.com
Format: Paperback
The person who handed me this book said it was "better than Lasse's book" (Test Driven.) I disagree. One can't compare the two books - Test Driven is meant for beginners and this book is meant for an advanced audience. If you have never written unit tests before, this book is very hard to follow. So put it down, get an intro book and come back.

I really liked the emphasis on making the software responsive to change along with separating acceptance and unit tests. The book uses Junit 4.6 and therefore covers Hamcrest matchers for both JUnit and JMock. I like the authors cover best practices, good design and clearly indicate what is a personal preference. I really liked part 4's emphasis on things that are hard to test at a higher level than "extract method."

The only thing that prevents me from giving full marks, is the case study. While I did read this part in one sitting, it was still hard to follow. There was a lot of information to keep in mind while trying to focus on the lessons of the example. I also think it was admirable for the authors to use a Swing example since Swing is harder to test. However, Swing is also less common for Java developers to use actively adding another block to understanding the software growing/testing aspects. And it is even harder for non-Java developers who are in the target audience for the book.

Except for the case study, I thought the book was amazing. And I'm sure the case study is a matter of taste.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.


Feedback