Kindle Price: $35.99

Save $12.00 (25%)

Promotions apply when you purchase

These promotions will be applied to this item:

Some promotions may be combined; others are not eligible to be combined with other offers. For details, please see the Terms & Conditions associated with these promotions.

eBook features:
  • Highlight, take notes, and search in the book
  • In this edition, page numbers are just like the physical edition
Read with our free app
You've subscribed to ! We will preorder your items within 24 hours of when they become available. When new books are released, we'll charge your default payment method for the lowest price available during the pre-order period.
Update your device or payment method, cancel individual pre-orders or your subscription at
Your Memberships & Subscriptions

Buy for others

Give as a gift or purchase for a team or group.
Learn more

Buying and sending eBooks to others

  1. Select quantity
  2. Buy and send eBooks
  3. Recipients can read on any device

These ebooks can only be redeemed by recipients in the US. Redemption links and eBooks cannot be resold.
Kindle app logo image

Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required.

Read instantly on your browser with Kindle for Web.

Using your mobile phone camera - scan the code below and download the Kindle app.

QR code to download the Kindle App

Follow the authors

Steve Freeman
+ Follow
Nat Pryce
+ Follow
See all
Something went wrong. Please try your request again later.

Growing Object-Oriented Software, Guided by Tests (Addison-Wesley Signature Series (Beck)) 1st Edition, Kindle Edition

by Freeman Steve (Author), Pryce Nat (Author) Format: Kindle Edition
4.5 4.5 out of 5 stars 278 ratings
See all formats and editions

Test-Driven Development (TDD) is now an established technique for delivering better software faster. TDD is based on a simple idea: Write tests for your code before you write the code itself. However, this "simple" idea takes skill and judgment to do well. Now there's a practical guide to TDD that takes you beyond the basic concepts. Drawing on a decade of experience building real-world systems, two TDD pioneers show how to let tests guide your development and “grow” software that is coherent, reliable, and maintainable.

 

Steve Freeman and Nat Pryce describe the processes they use, the design principles they strive to achieve, and some of the tools that help them get the job done. Through an extended worked example, you’ll learn how TDD works at multiple levels, using tests to drive the features and the object-oriented structure of the code, and using Mock Objects to discover and then describe relationships between objects. Along the way, the book systematically addresses challenges that development teams encounter with TDD—from integrating TDD into your processes to testing your most difficult features. Coverage includes

  • Implementing TDD effectively: getting started, and maintaining your momentum throughout the project
  • Creating cleaner, more expressive, more sustainable code
  • Using tests to stay relentlessly focused on sustaining quality
  • Understanding how TDD, Mock Objects, and Object-Oriented Design come together in the context of a real software development project
  • Using Mock Objects to guide object-oriented designs
  • Succeeding where TDD is difficult: managing complex test data, and testing persistence and concurrency
Read more Read less
Previous page
  1. ISBN-13
    978-0321503626
  2. Edition
    1st
  3. Sticky notes
    On Kindle Scribe
  4. Publisher
    Addison-Wesley Professional
  5. Publication date
    October 12, 2009
  6. Part of series
    Addison-Wesley Signature Series (Beck)
  7. Language
    English
  8. File size
    15979 KB
  9. See all details
Next page
Due to its large file size, this book may take longer to download
Add a debit or credit card to save time when you check out
Convenient and secure with 2 clicks. Add your card
Next 3 for you in this series See full series
Total Price: $85.87
By clicking on the above button, you agree to Amazon's Kindle Store Terms of Use

Editorial Reviews

From the Back Cover

Foreword by Kent Beck

"The authors of this book have led a revolution in the craft of programming by controlling the environment in which software grows.” --Ward Cunningham

“At last, a book suffused with code that exposes the deep symbiosis between TDD and OOD. This one's a keeper.” --Robert C. Martin

“If you want to be an expert in the state of the art in TDD, you need to understand the ideas in this book.”--Michael Feathers

Test-Driven Development (TDD) is now an established technique for delivering better software faster. TDD is based on a simple idea: Write tests for your code before you write the code itself. However, this "simple" idea takes skill and judgment to do well. Now there's a practical guide to TDD that takes you beyond the basic concepts. Drawing on a decade of experience building real-world systems, two TDD pioneers show how to let tests guide your development and “grow” software that is coherent, reliable, and maintainable.

Steve Freeman and Nat Pryce describe the processes they use, the design principles they strive to achieve, and some of the tools that help them get the job done. Through an extended worked example, you'll learn how TDD works at multiple levels, using tests to drive the features and the object-oriented structure of the code, and using Mock Objects to discover and then describe relationships between objects. Along the way, the book systematically addresses challenges that development teams encounter with TDD--from integrating TDD into your processes to testing your most difficult features. Coverage includes

• Implementing TDD effectively: getting started, and maintaining your momentum

throughout the project

• Creating cleaner, more expressive, more sustainable code

• Using tests to stay relentlessly focused on sustaining quality

• Understanding how TDD, Mock Objects, and Object-Oriented Design come together

in the context of a real software development project

• Using Mock Objects to guide object-oriented designs

• Succeeding where TDD is difficult: managing complex test data, and testing persistence

and concurrency

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.

Product details

  • ASIN ‏ : ‎ B002TIOYVW
  • Publisher ‏ : ‎ Addison-Wesley Professional; 1st edition (October 12, 2009)
  • Publication date ‏ : ‎ October 12, 2009
  • Language ‏ : ‎ English
  • File size ‏ : ‎ 15979 KB
  • Simultaneous device usage ‏ : ‎ Up to 5 simultaneous devices, per publisher limits
  • Text-to-Speech ‏ : ‎ Enabled
  • Screen Reader ‏ : ‎ Supported
  • Enhanced typesetting ‏ : ‎ Enabled
  • X-Ray ‏ : ‎ Not Enabled
  • Word Wise ‏ : ‎ Not Enabled
  • Sticky notes ‏ : ‎ On Kindle Scribe
  • Print length ‏ : ‎ 384 pages
  • Customer Reviews:
    4.5 4.5 out of 5 stars 278 ratings

About the authors

Follow authors to get new release updates, plus improved recommendations.
Previous page
  1. Steve Freeman

    Steve Freeman

    Brief content visible, double tap to read full content.
    Full content visible, double tap to read brief content.

    Steve was a pioneer of Agile software development in the UK, he has built applications for banks, ISPs, financial data providers, and specialist software companies. He has given training courses in Europe, America, and Asia.

    Previously, he worked in research labs, software houses, earned a PhD, and wrote shrink-wrap software for IBM. Steve also teaches in the Computer Science department at University College London. He is a presenter and organizer at international industry conferences, and was conference chair for the first London XpDay.

    See more on the author's page
  2. Nat Pryce

    Nat Pryce

    Brief content visible, double tap to read full content.
    Full content visible, double tap to read brief content.

    After completing a PhD at Imperial College, Nat Pryce joined a dot-com just in time to ride the bust. Since then he has worked as a programmer, architect, trainer, and consultant in a variety of industries, including sports reportage, marketing communications, retail, telecoms, and finance. He has also worked on academic research projects and does occasional university teaching. An early adopter of XP, he has written or contributed to several open source libraries and tools that support TDD and was one of the founding organizers of the London XP Day conference. He also regularly presents at international conferences. Nat is based in London, UK.

    See more on the author's page
Next page

Customer reviews

4.5 out of 5 stars
4.5 out of 5
278 global ratings

Top reviews from the United States

Bas Vodde
5.0 out of 5 stars Excellent TDD book for actual practitioners
Reviewed in the United States on January 14, 2010
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.
59 people found this helpful
Helpful
 Report
Tre’ Seymour
5.0 out of 5 stars Only on Chapter 7 so far, and loving it
Reviewed in the United States on December 11, 2011
Verified Purchase
I've been involved with agile development with unit testing for 3 years now.
I've read many books on the topics of ooad, oop, design patterns, etc.
This book however, is quite niche.
One of the the things that has eluded me thus far is the ability to use mock objects to assist in creating useful dsl's for my apps.
I think this book may do just that.
At any rate, this book is motivating me to join the Agile Alliance, so that I might meet these heroes of mine.
For anyone that sees software as living designs and not just products, this book is a keeper, right up there with Fred P. Brooks's book: Mythical Man Month.

As an aside, I recommend:
Mythical Man Month (Brooks)
Test Driven (Lasse)
Test Driven Development (Beck)
Head First Design Patterns
Joel On Software
Art of Unix Programming
Software Engineering Economics (Boehm)
etc (and any thing from anyone on the Agile Manifesto)
One person found this helpful
Helpful
 Report
R. Williams
4.0 out of 5 stars Excellent, Though Short of Its Potential
Reviewed in the United States on November 14, 2010
Verified Purchase
On the whole, this is an exciting book, one that shows that the book industry is not dead yet (although screening developers for an open position would make you think it were), but it's not what it thinks it is. It's almost comical, in a way, to see this book's conception of itself unfold. In the beginning of the book, it seems the authors believe they can show us ways to make TDD better. By the end, the Little Corporal is crowning himself emperor. The TDD/BDD historicity (and its nationalistic twinge) are ludicrous and add nothing to the book. Example of the Trump school of PR: DIY. On the substantive level, this book is confused about what it is because it takes its example (one of the best things about the book) as a representative of the world, which it most certainly is not.

The example, which is detailed, thoroughgoing, and significant, is an auction application, and the focus in 'building' it is restricted completely to laying down the various protocols that dictate how parties interact through bidding, winning, losing, etc. This is not only not a serious picture of a project (as in one), it's laughable to be considered even complete for what it was. I am so bloody sick of examples that are of the form 'let's look at writing the 10 thousandth version of ______.' I am in software development (and love it) because it is invention. There is zero invention here. [Somebody, please address the part of the programming audience who are not ankle-chained to a rock pile, just once!]

But there are other reasons why this 'work' is not representative. It's focused solely on the protocols in the program. If there were any honest, self-reflexive rhetoric in this book, the authors would have at least nodded toward the other things one would have to do to make an auction work. Their total absence beckons simultaneously to wizardry (Oz/Maxwell's Demon) and infantilism. What is JMock going to do to make it easier to build interfaces? to test the obvious role of things like little languages (DSLs)? If your favored way of situating yourself in reality is statistics, what percentage of the overall effort does this protocol layer represent? Even of an auction app that has no invention, a small fraction. I could bring up a ton of examples off the top of my mind that would have almost no protocol work to them.

Does this mean JMock or mocking in general are useless? No. I am offering a counter argument to the preposterous one in the book that makes it seem like JMock was the keystone to the last decade.

The best things about this book are: 1. even though it's a narrow one, a book like this is much better using real examples, real code. 2. the concept of the walking skeleton (this is one of the areas of seriously underdelivery) and 3. some of the tips about using static builders, creating test data, acknowledging the limits of mocks, etc.

The boldest thing in this book is the concept of the walking skeleton. If I could have coaxed the authors in process, I would have not only told them to make this the centerpiece of the book, but to address the difficulties in being able to really accomplish this in practice. Frankly, if these guys helped us conquer something in the last decade, they ought send out a memo to the Java world, which is more fragmented than ever, and I think everyone would agree, has no grip on the technological underpinnings such a strategy implies (falls down on the first requirement: the ability to perform end-to-end tests). Ironically, one of the reasons this IDEA was so compelling to me is precisely the opposite implication herein: because we have NOT been able to practice this though many of us have wanted it FOREVER!! Did you ever use Cactus? I did. In the bloody beginning. But this is compelling to me now because I have been doing Objective-C/Cocoa programming, and though they don't have this right now, they showed it at WWDC in the form of unit tests for the components and fully functional integration tests in the coming version of Instruments. In summary: the book is attempting to milk an empty utter here, and it doesn't tug very hard or for very long.

Do I think this book is worth reading? Yes, absolutely. I look forward to the book that's going to deliver the real promise of the check this one writes itself and then cashes, in any language, on any platform. Hopefully soon..
7 people found this helpful
Helpful
 Report

Top reviews from other countries

Translate all reviews to English
Victor
5.0 out of 5 stars Bom
Reviewed in Brazil on October 27, 2021
Verified Purchase
BOm
Report
Abhay
3.0 out of 5 stars Classical book but stains on the side of the book
Reviewed in India on September 19, 2020
Verified Purchase
Needless to say , this is a classical book on Test Driven Development - includes theory, a complete section on examples backing those theory...! This review is not on that rather appearance of the book

On one side of the book , there are few stains (can be seen in the pic), - which appears to be the result of something spilled over !

When you pay a premium price for a product (in this case ~5K) , you expect same thing in return. Insides of the book( contents) seems to be OK.

The seller(Cloudtail) should have taken due diligence and checked for any sort of damage...hence the 3 star rating.
Customer image
Abhay
3.0 out of 5 stars Classical book but stains on the side of the book
Reviewed in India on September 19, 2020
Needless to say , this is a classical book on Test Driven Development - includes theory, a complete section on examples backing those theory...! This review is not on that rather appearance of the book

On one side of the book , there are few stains (can be seen in the pic), - which appears to be the result of something spilled over !

When you pay a premium price for a product (in this case ~5K) , you expect same thing in return. Insides of the book( contents) seems to be OK.

The seller(Cloudtail) should have taken due diligence and checked for any sort of damage...hence the 3 star rating.
Images in this review
Customer image Customer image Customer image
Customer imageCustomer imageCustomer image
Report
Dark Matter
5.0 out of 5 stars Buen libro
Reviewed in Spain on September 10, 2020
Verified Purchase
Excelente libro para conocer está práctica de programación
Report
E. Brodie
5.0 out of 5 stars GOOS is a must read for all software developers!
Reviewed in Canada on January 24, 2017
Verified Purchase
This book is a must read for any developer in today's software market. The lessons learned about TDD (Test-Driven Development) are invaluable. Reading this has permanently changed my career for the better.
Report
Stefan Macke
5.0 out of 5 stars Sehr ausführlich, tolles Praxisbeispiel, viele Anregungen für die Praxis
Reviewed in Germany on October 31, 2012
Verified Purchase
Nachdem "Growing Object-Oriented Software, Guided by Tests" von Steve Freeman und Nat Pryce bei den "Ruby Rogues" besprochen wurde (siehe Episode 68), war mir klar, dass ich es auch lesen musste. Und ich muss sagen: es hat sich definitiv gelohnt. Es ist das beste Buch zum Thema Test Driven Development, das ich bislang gelesen habe.

Das Buch beginnt mit einer ca. 70-seitigen allgemeinen Einführung in das (testgetriebene) Vorgehen der Autoren bei der Softwareentwicklung. Dabei wird z.B. TDD erläutert und die eingesetzten Werkzeuge werden vorgestellt. Der Fokus liegt hierbei auf JUnit und jMock.

Danach folgt ein riesiges Praxisbeispiel: ein "Auktionssniper", dessen Entwicklung als Java-Swing-Anwendung auf gut 150 Seiten beschrieben wird. Was mir dabei die Augen geöffnet hat, war das Starten mit einem fehlschlagenden Akzeptanztest. Bevor die erste Zeile Produktiv- bzw. Unit-Test-Code geschrieben wurde, haben die Autoren viel Zeit darauf verwendet, einen "End-To-End-Test" zu erstellen, der die erste Funktionalität der Applikation wie ein echter Benutzer testet. Dazu ist einiges an Aufwand nötig (Threading, GUI-Test-Framework etc.), aber das lohnt sich im Nachhinein, weil die Tests mit echten Benutzern entfallen können.

Ich muss zugeben, dass ich das Praxisbeispiel teilweise nur recht schwer nachvollziehen konnte, weil ich beim Lesen nicht den ganzen Code im Kopf hatte und immer nur die interessanten Teile gezeigt wurden. Allerdings konnte ich sehr viele Anregungen für meine eigenen Anwendungen mitnehmen, z.B. dass man generische Klassen nicht als Methodenparameter nutzen sollte (sondern besser eine eigene Containerklasse mit einem sinnvollen Namen erstellen sollte), dass einem die "import"s einer Klasse ggfs. verraten, dass diese zu viele Aufgaben hat, oder dass man Factorys besser im Kontext der Domäne benennen sollte (z.B. AuctionHouse anstatt AuctionFactory).

Abgerundet wird das Buch durch die letzten ca. 100 Seiten mit wieder eher allgemeinen Tipps zum testgetriebenen Entwickeln. Dabei gehen die Autoren noch einmal in die Vollen und behandeln z.B. das Testen von Multithreading-Applikationen oder den sinvollen Umgang mit Logging-Mechanismen.

Alles in allem kann ich dieses Buch jedem Softwareentwickler empfehlen. Obwohl die Beispiele in Java geschrieben sind, lassen sie sich leicht auf andere Sprachen übertragen und jeder Entwickler wird hier eine Vielzahl an Anregungen für die Programmierung mitnehmen können.
7 people found this helpful
 Report
Report an issue

Does this item contain inappropriate content?
Report
Do you believe that this item violates a copyright?
Report
Does this item contain quality or formatting issues?
Report