Growing Object-Oriented Software, Guided by Tests

Rate this book

Clear rating

1 of 5 stars 2 of 5 stars 3 of 5 stars 4 of 5 stars 5 of 5 stars

Growing Object-Oriented Software, Guided by Tests

4.17 of 5 stars 4.17 · rating details · 321 ratings · 37 reviews

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...more 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(less)

Paperback, 345 pages

Published October 1st 2009 by Addison-Wesley Professional

more details... edit details

Get a copy:

More…

Friend Reviews

To see what your friends thought of this book, please sign up.

Lists with This Book

The C Programming Language by Brian W. Kernighan

Structure and Interpretation of Computer Programs by Harold Abelson

Essential Programming Books

27th out of 86 books — 150 voters

More lists with this book...

Community Reviews

(showing 1-30 of 956)

filter | sort: default (?) | rating details

May 12, 2012 Stephen rated it 5 of 5 stars

Shelves: software

...more

I did not realize how much I still have to learn about writing good object-oriented (OO) code, and about hewing to a tight test driven development (TDD) methodology, before I read Growing Object-Oriented Software, Guided By Tests. My education in OO and unit testing has been largely theoretical, with no time spent directly learning from experienced OO programmers; my best mentor was a COBOL coder. Books like Design Patterns: Elements of Reusable Object-Oriented Software, Patterns of Enterprise Application Architecture, Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and Iterative Development, Xunit Test Patterns: Refactoring Test Code, and others are wonderful but have few detailed real-world business-case examples.

That said, I admit that I skimmed through some of the middle chapters where the application was being built – it was simple to skip the details of Java implementation and focus on the points where a decision was being made, based on tests, about where to put/move a piece code. The authors did well in steering away from anything too Java-centric, that the book would remain accessible to those of us who are not deep in that language.

There is no need for me to recount the contents – perusal of the table of contents should be sufficient. Some of the advice about testing overlaps that found in XUnit Test Patterns, but the overlaps is small enough to warrant reading both. Naturally, some of the advice will reinforce what any good and self-reflective programmer will have already figured out about writing tests. In that case you receive validation and further justification. And much of the advice on OO programming can be found in more detail in other works, though here it is uniquely combined with TDD to shed new light on the advantages of OO.

A few particular highlights for me:

Let necessity drive design, rather week-long UML sessions.
Write to interfaces, initially ignoring implementation. Interfaces should name and describe relationships between classes.
Deploy as early as possible. Do so even before the application does anything, just to prove that the framework can be deployed.
Readability applies to test code as well. I already believed that, but this presentation will help me explain that better to doubters.
Test names can be extremely descriptive (prior post)
I have been over-reliant on Microsoft's Moles (prior post)
(less)

like 1 like · see review

Jun 20, 2011 Jeanne Boyarsky rated it 4 of 5 stars

Shelves: technology

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 ther...more

like · see review

Aug 01, 2011 Xing Shi rated it 4 of 5 stars

TDD is hard

I finished Growing Object-Oriented Software Guided by Tests (GOOS) this afternoon. It’ a book that I sincerely hope I would have had the patience to read years ago. It answers one deceivingly simple question in software development that has bothered me for a long time: How to practice TDD (Test Driven Development)?

When I first heard about the Golden Rule of TDD – “Never write new functionality without a failing test”, I was quite skeptical about it. But after several years building so...more

like · see review

Sep 27, 2011 Jean Tessier rated it 4 of 5 stars

Shelves: software

Came recommended by Kent Beck. The authors wrote jMock. This books explains how they approach writing tests.

Well worth the read, whether you're new to TDD or if you're a seasoned practitioner. Part I and II lay out how TDD works and the authors' philosophy with regard to writing software. Many other books describe TDD and the authors are candid when it comes to their personal practices. YMMV. Part III is a very comprehensive case study where they use the practices in anger, that is, trying to ac...more Came recommended by Kent Beck. The authors wrote jMock. This books explains how they approach writing tests.

Well worth the read, whether you're new to TDD or if you're a seasoned practitioner. Part I and II lay out how TDD works and the authors' philosophy with regard to writing software. Many other books describe TDD and the authors are candid when it comes to their personal practices. YMMV. Part III is a very comprehensive case study where they use the practices in anger, that is, trying to achieve some goal and not for as a toy exercise. Part IV revisits some of the concepts illustrated in the case study. Part V pays special attention to some advanced concerns when writing tests, such as testing persistence or multithreaded code.

Ever since I began using JUnit, I've been adamant about initializing the fixture in the setUp() method and not in the constructor. Early JUnit would create all test instances before it ran the first one, so you didn't want to reserve any resources in the constructor. I class with 20 tests would reserve and hold 20 resources for the duration of the test run. Instead, you reserve the resource in setUp() and free it in tearDown(). Now, instead of holding up 20 resources, at most one is held at any given time. And the best way to remember to reserve expensive resources in setUp() only is to do all fixture initialization there rather than split it up between constructor and setUp().

So you can imagine my surprise when I see the authors initialize their fixtures in their test class constructors. What are they thinking?!?! I had to go back and write some sample tests using the latest JUnit and print traces in constructors, setUp(), tests, and tearDown() to validate my assumptions. Lo and behold, at some point in time, JUnit got it's act together and now creates test instances as it runs tests, not all of them at the beginning of the test run. For a moment, I was afraid that Grails might leave me stuck in the dark ages of setUp()-only initialization, but I'm safe there too. Not I've got to update my habits.

The sample problem had lots of complexity: GUI, asynchronous communication, Jabber-based RPC, etc. Some of the code transformations are sometimes hard to follow, especially the further you get in the case study and they pick up the pace. Some side-by-side comparisons would have been welcome, but maybe hard to do in the limited space of the book.

The authors used a neat trick to track their development progress through the sample problem. They kept a hand-written list of tasks on a sheet of paper, crossed out items as they completed them, and added tasks as they happened upon them. Here's a snapshot from the somewhere halfway through:

Todo
single item - join, lose without bidding
single item - join, bid & lose
single item - join, bid & win
single item - show price details
multiple items
add new item through the GUI
stop bidding at stop price
translator - invalid message from Auction
translator - incorrect message version
handle XMPException on send

I used a similar technique a long time ago to implement a feature with great success. I'm going to re-introduce it to my toolset going forward.

I really liked the chapter on test data builders. I already grew more comfortable using test helper methods to clarify the text of a given test after reading Gerard Meszaros' xUnit Test Patterns. The builders in this book take it to another level. The authors use builders and Hamcrest matchers to create DSLs that really make tests easy to read and makes their purpose crystal clear. Groovy and Grails already have support for writing builders and I'll have to spend some time adapting the examples in the book to the Groovy way.(less)

like · see review

Feb 04, 2012 Marshall rated it 2 of 5 stars

Shelves: non-fiction, technology

A book about Test-Driven Development (TDD), based on Java. It was fantastic to see this style of programming in action. Much of the book was devoted to an example program, which they wrote as they went along, so you saw all the mistakes and discoveries they made along the way. This was supposed to demonstrate how wonderful TDD is for the incremental growth of software, as it adapts to changing requirements. I was amazed to see how absolutely clean the resulting code was, and how tiny their chang...more

like · see review

Dec 17, 2012 Bjoern Rochel rated it 5 of 5 stars

Shelves: agile, favorites

Pretty cool book. I wish I had it 6 years ago. Learned quite a few of the lessons they talk about the hard way in those years. I really, really like the emphasis on growing and nurturing a software design. I've seen too many codebases that slowly but gradually went off the rail because of too much pragmatism or simply the lack of a big picture on what the software was supposed to do and how it actually did it.

Software teams often don't fail delivering the first version of a software. They fail...more

like 1 like · see review

May 05, 2011 Rene Stein rated it 4 of 5 stars

Nejlepší kniha o testování (Unit testy, Integrační testy, Akceptační testy), kterou jsem četl. Autoři-praktici precizně popisují svůj přístup k vývoji a testování aplikací a nevyhýbají se na konci knihy ani doporučením, jak psát složitější testy, které zohledňují existenci více nezávislých threadů v aplikaci, nebo jak si poradit s testy, které testují metody závislé na aktuálním datu a čase, a nechybí ani příklady testů, které musí ověřit výsledek volání asynchronní operace.

Ke knize bych měl jen...more Nejlepší kniha o testování (Unit testy, Integrační testy, Akceptační testy), kterou jsem četl. Autoři-praktici precizně popisují svůj přístup k vývoji a testování aplikací a nevyhýbají se na konci knihy ani doporučením, jak psát složitější testy, které zohledňují existenci více nezávislých threadů v aplikaci, nebo jak si poradit s testy, které testují metody závislé na aktuálním datu a čase, a nechybí ani příklady testů, které musí ověřit výsledek volání asynchronní operace.

Ke knize bych měl jen pár výhrad:

1) Praktické příklady jsou v knihách vždy užitečné, ale prostřední část s hutnými výpisy kódu, které demonstrují, jak napsat a hlavně otestovat aplikaci komunikující s aukčním serverem, je po chvíli úmorná. Při čtení této kapitoly jsem si říkal, že platí: 10x zopakovat variaci na pravidlo Red-Green-Refactor je asi poznávací znamení každého opravdového agilního vývojáře. Něco jako profylaktické pokřižování zahánějící ďábla, který refaktorizací svého stávajícího aplikačního pekla pyšně pohrdl. :)

2) V titulu knihy není zmínka o tom, že všechny příklady budou v Javě a s využitím Java knihoven(JMock). Při čtení příkladů mě rušilo, že jsem se soustředil podvědomě na to, jak některé konstrukce v Javě a také API Java knihoven působí při přímém srovnání se současnými výrazovými prostředky jazyka C# archaicky. Dokonce bych řekl, že v některých příkladech maji (IMHO) metody v JMocku lehkou pachuť hacku.

3) Některá pravidla pro psaní kódu v první části knihy na mě působila rozpačitě nebo neúplně. Například rozdělení spolupracujících objektů na "dependencies", "notifications" a "adjustments" v kontextu knihy (a DI kontajnerů) dává smysl, ale mně třeba hranice mezi dependencies a adjustments přijdou neostré a u notifications tuším, že autoři jsou hodně závislí na notifikacích ve specifické formě "Java" listenerů.

Kniha ale i přes tyto drobné výhrady za přečtení určitě stojí.
(less)

like · see review

Feb 03, 2013 Vladyslav rated it 4 of 5 stars

It took me too long to finish the book. First part was quit interesting and promising. I enjoyed reading stories from the author's practice as consultants trying to adopt TDD and unit-testing doctrine in real life. It was interesting to read their props and cons particularly because I have seen myself in the same role at my daily job. I have seen or wished to see. So I tried to learn new tricks to convince colleagues and managers to accept unit-testing as necessary part of the development proces...more

like · see review

Sep 26, 2010 Graham rated it 4 of 5 stars

Shelves: computer-books

Growing Object-Oriented Software shows the reader how TDD, done from the inception of a greenfield project, can have a dramatic effect on both the design and correctness of a piece of software. The book covers not only unit testing, but also integration, and end-to-end testing, demonstrating that TDD is effective at every level of granularity. In fact, the examples of integration testing are the strongest aspect of the book, and read like natural language while exercising multiple parts of the s...more Growing Object-Oriented Software shows the reader how TDD, done from the inception of a greenfield project, can have a dramatic effect on both the design and correctness of a piece of software. The book covers not only unit testing, but also integration, and end-to-end testing, demonstrating that TDD is effective at every level of granularity. In fact, the examples of integration testing are the strongest aspect of the book, and read like natural language while exercising multiple parts of the system simultaneously, and additionally providing documentation about the system that unit testing often does not. Excellent object-oriented advice is also sprinkled throughout the book, such that -Impl suffixes and I- prefixes are meaningless and should be avoided for implementations and interfaces respectively (interfaces should refer to services, classes should refer to implementations). The distinction between objects and values, even though both are classes in Java, is also stressed. Instead of allowing for duplication in tests, several helper patterns are discussed such as the Test Data Builder. Lastly, while dependency injection is obviously favored, Spring containers are rightly eschewed.

There are a few parts of the book that could have been improved. First is that the authors are advocates of behavior-based over state-based testing. They do a good job of defending this position by advising to use as few expectations per test as possible, but I couldn't help but notice the duplication of the implementation of the code-under-test in the test itself, which would have been avoided with state-based testing. Second, while the authors support the idea of not mixing business and presentation logic and keeping the View as small as possible, they still felt it was worth using the complete real View in testing, and using timeouts to sync up with the GUI thread. Lastly, the book contains yet another attempt at testing concurrency without using message passing. This is particularly odd because the authors take the SmallTalk view that object-orientation is inherently about messages passed between objects.(less)

like · see review

Jul 01, 2010 Amy Gilchrist Thorne rated it 4 of 5 stars

Shelves: own, part-read, nonfiction, tech

I think there's a lot of food for thought in this book. Personally, I can remember reading Martin Fowler's Mocks Aren't Stubs some time ago and concluding that I'd be a "classicist."

Some time later, I started working with mocks as a way to isolate unit tests from "slow" dependencies, such as databases, trying to make them run more quickly. I didn't have much success, though, because I was still writing my tests in a classicist style.

This book helped open my eyes to how the "mockist" style really...more

like · see review

Apr 29, 2011 gargamelscat rated it 4 of 5 stars

Shelves: compsci, 2011

This review has been hidden because it contains spoilers. To view it, click here.

like · see review

Sep 26, 2012 Said A rated it 4 of 5 stars

Shelves: programming

Basically the book about test driven development. If you are new to the concept of TDD, this book will help you get an idea what it is and the process of TDD'ing your next/current project. However, if you are not new to TDD/BDD, I think reading "xUnit Test Patterns: Refactoring Test Code" is a time best spent.

Read it if you're new to TDD, if not got get yourself a copy of "xUnit Test Patterns: Refactoring Test Code" book.

like · see review

Sep 29, 2011 Vasili Puchko rated it 4 of 5 stars

Shelves: technical

One of the best books on TDD I've seen so far. The only problem is that it's written for Java. A lot of samples are not applicable to .Net due to differences in mocking and unit testing frameworks. But anyway it worth reading.

like · see review

Nov 24, 2012 Igoris Azanovas rated it 3 of 5 stars

I liked the practical way of writing, but there were quite a lot of examples on java mocks which is not my primary language, and it is hard to port some of principles.
All in all good book for intermediate programmer.

like · see review

Dec 30, 2009 Ash Moran rated it 5 of 5 stars

Shelves: software

Awesome. Clearest description I've ever seen on how to evolve code test-driven. Also an interesting, if understated, look at software architecture. Tackles some really difficult problems swiftly and elegantly.

like · see review

Jun 23, 2010 Drake rated it 4 of 5 stars

Shelves: programming

A good persuasive argument in favour of Test-Driven Design/Development, combined with a catalogue of techniques to use in both clean and legacy code bases to improve quality while developing features.

like · see review

Apr 28, 2012 Matt Diephouse rated it 2 of 5 stars · review of another edition

While there were some valuable nuggets that stuck out to me while reading this book (e.g., the distinction between objects and values, the value of writing object internals functionally), much of the bulk of it was either common sense or not highly valuable to me.

Additionally, the use of Java, jUnit, and jMock made the contents not highly relevant to my current line of work writing Objective-C. It is useful to have some insight into the Java world and how testing has influenced it, but Objective...more

like · see review

Jun 12, 2011 Arun rated it 4 of 5 stars

The authors lecture in good details about what we're testing and how they break it down into smaller units of tests, whats the though process behind each iteration, etc. Lots of code samples based on the hypothetical application regarding Auctions. Makes it a little bit easier to follow and understand the real TDD approach.

like · see review

Mar 30, 2013 James rated it 5 of 5 stars

This is the best guide to TDD and emergent design I've read. I have two copies, one of which is permanently loaned out to friends and colleagues.

like 1 like · see review

Nov 15, 2010 Tom rated it 5 of 5 stars

Shelves: nonfiction, own, tech

A definite must-read for professional developers, this book taught me a lot about incrementally building software that's constantly deployable and maintainable - not only the technical know-how required to do it, but also the mentality needed. Reading the book made me realize that my unit testing skills are woefully lacking in comparison, so I'm grateful that it provides extension tips, tricks, and examples that I can study for improvement. But this book covers much more than unit testing, which...more

like 1 like · see review

Feb 01, 2011 Nicolas rated it 5 of 5 stars

This book shows you why, when and how to use mocking to improve the design of you development and to ease the testing process. Not only the unit testing, but end to end as well.

Probably the best demonstration on how to implement TDD I've seen so far.

like · see review

Sep 18, 2011 Collin Rogowski rated it 5 of 5 stars · review of another edition

Shelves: non-fiction

Best TDD book to date. Very nice introduction to the underlying concepts by discussing real life examples.

like · see review

May 27, 2011 Xavier Shay rated it 4 of 5 stars

Shelves: owned

It started a bit slow so I was concerned, but it really kicked off. Wish I'd read this 4 years ago. The guided walkthrough is good but as with clean code would have been better as a screencast. The final chapters on testing are spectacular.

Key takeaways:
- Focus on the communication between objects.
- Ports and adapters architecture to separate the domain.
- Proper division between unit, integration and acceptance tests.
- Use test builders for complex test setup.
- Transactional tests are a hack bec...more

like 1 like · see review

Oct 10, 2012 Cristofer rated it 4 of 5 stars

Shelves: computer-science

Learned a lot on Object-Oriented design with this book!

like · see review

Aug 21, 2011 Olaf Lewitz rated it 5 of 5 stars

Shelves: improving-software-development

Best TDD book and best OO book I ever read. Amazing.

like · see review

May 11, 2010 Topilno added it

Shelves: manuals-01

Creating Web Pages for Dummies

like · see review

Apr 28, 2013 Amp Tanawat rated it 4 of 5 stars

Shelves: tdd

It is TDD by Example in advance level.

like · see review

May 19, 2011 Vishal rated it 4 of 5 stars

Shelves: softwaredevelopment

On page 42 and I like it so far.

like · see review

Jul 27, 2010 Mikhail Tomilov rated it 5 of 5 stars

Great book about TDD

like · see review

Dec 11, 2012 Rich Dammkoehler rated it 4 of 5 stars

Shelves: technical

A Must Read!

like · see review

« previous 1 2 3 4 5 6 7 8 9 … 31 32 next »

new topic
Discuss This Book

There are no discussion topics on this book yet. Be the first to start one »

Recommend it | Stats | Recent status updates

combine
Other Editions (2)

Goodreads is hiring!

If you like books and love to build cool products, we may be looking for you.
Learn more »

Genres

Computer Science > Programming

41 users

Computer Science > Software

15 users

Science > Technology

13 users

Science > Computer Science

9 users

Computer Science > Technical

7 users

Computer Science > Computers

6 users

Non Fiction

5 users

See top shelves...

Readers also enjoyed similar books

Books by Steve Freeman

Was the 2004 Presidential Election Stolen?: Exit Polls, Election Fraud, and the Official Count

Is America Stupid?: Legitimate Rape, an Illegitimate President, and the Politics of Nonsense

World Travel Adventures: True Encounters from Over 100 Countries by an Ordinary Guy with Extraordinary Experiences

More…

Share This Book

Facebook Twitter Your website

Trivia About Growing Object-Or...

No trivia or quizzes yet. Add some now »

title link	preview: Growing Object-Oriented Software, Guided by Tests
avg rating	preview: Growing Object-Oriented Software, Guided by Tests Goodreads rating: 4.17 (321 ratings)
small image	preview: click here [close]
med image	preview: click here [close]
BBCode	[url=http://www.goodreads.com/book/show/4268826-growing-object-oriented-software-guided-by-tests?utm_medium=api&utm_source=blog_book][img]http://d.gr-assets.com/books/1348030542l/4268826.jpg[/img][/url] [url=http://www.goodreads.com/book/show/4268826-growing-object-oriented-software-guided-by-tests?utm_medium=api&utm_source=blog_book]Growing Object-Oriented Software, Guided by Tests by Steve Freeman[/url]

Growing Object-Oriented Software, Guided by Tests

Friend Reviews

Lists with This Book

Community Reviews

new topicDiscuss This Book

combineOther Editions (2)

Goodreads is hiring!

Genres

Readers also enjoyed similar books

Books by Steve Freeman

Share This Book

Share This Book on Your Website

Trivia About Growing Object-Or...

new topic
Discuss This Book

combine
Other Editions (2)