Buy new:
£39.49£39.49
Arrives:
Tuesday, June 20
Dispatches from: Amazon Sold by: Amazon
Buy used £25.31
Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet or computer – no Kindle device required. Learn more
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Follow the Authors
OK
Growing Object-Oriented Software, Guided by Tests (Addison-Wesley Signature Series (Beck)) Paperback – Illustrated, 22 Oct. 2009
| Amazon Price | New from | Used from |
|
Kindle Edition
"Please retry" | — | — |
- Kindle Edition
£9.49 Read with Our Free App - Paperback
£39.49Other options from £22.51
Purchase options and add-ons
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
- ISBN-100321503627
- ISBN-13978-0321503626
- Edition1st
- PublisherAddison-Wesley Professional
- Publication date22 Oct. 2009
- LanguageEnglish
- Dimensions17.78 x 2.92 x 23.24 cm
- Print length384 pages
Frequently bought together

Products related to this item
From the brand
-
Addison-Wesley is a premiere publisher of books and eBooks for those working with technology.
This includes resources for programmers, developers, administrators, data scientists and engineers, team managers, students, and more.
-
Who are our authors?
Our authors are the creators, innovators, and thought leaders in computer science and technology including Donald Knuth, Bjarne Stroustrup, Brendan Gregg, Martin Fowler, Robert C. Martin.
Are our books for professionals only?
Our catalogue includes tutorials, references, guides, and deep dives for all levels, including never haven written a line of code to being in the industry for 40+ years and wanting to upskill.
Why Choose Addison Wesley?
We have been publishing the leading texts on computer science for decades and our titles appear on numerous "most recommended" lists.
-
-
Signature Series
Books in the series are personally chosen by expert advisors who are proud to put their signatures on the covers.
-
Professional Computing Series
Brian W. Kernighan created this series to provide serious programmers & networking professionals with practical reference books.
-
Professional Scrum Series
Deep insights into overcoming the challenges that both teams and organizations face as they seek to reap the benefits of agility.
-
Robert C. Martin Series
For software developers, team-leaders, business analysts & managers who want to increase their skill to the level of a Master Craftsman
-
Data & Analytics Series
Practical knowledge for solving problems & answering questions with data with a focus on infrastructure, algorithms and visualization.
-
The C++ In-Depth Series
Bjarne Stroustrup designer of C++ selected this collection to provide programmers with reliable information on C++ programming language
Product description
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
- Publisher : Addison-Wesley Professional; 1st edition (22 Oct. 2009)
- Language : English
- Paperback : 384 pages
- ISBN-10 : 0321503627
- ISBN-13 : 978-0321503626
- Dimensions : 17.78 x 2.92 x 23.24 cm
- Best Sellers Rank: 283,887 in Books (See Top 100 in Books)
- 126 in Design Pattern Programming
- 265 in Amazon Online Shopping
- 342 in Functional Programming
- Customer reviews:
About the authors

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.

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.
Products related to this item
Customer reviews
Customer Reviews, including Product Star Ratings, help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyses reviews to verify trustworthiness.
Learn more how customers reviews work on Amazon-
Top reviews
Top reviews from United Kingdom
There was a problem filtering reviews right now. Please try again later.
Once you get beyond the basics of TDD examples covering things like the Fibonacci sequence or tiny parts of larger systems become less and less useful. Why? Because there is no design involved - if someone asks for a Fibonacci generator then the specification is completely fixed and understood right from the beginning. The implementation may vary but there will be (one hopes!) no real confusion or alternative specifications to consider. When starting most real-world software projects that is not how things begin and it is not until the project matures that the code takes on this clearer form. This maturation does not happen by itself or by magic and most developers will have worked on projects where that has never occurred. It is making this transformation happen through a combination of good design and the intelligent application of TDD that this book uniquely focusses on.
Having read this book whilst it was being produced on the authors' website, pre-ordering it from Amazon and returning to it on and off ever since I'm going to stick my neck out and say that this is my favourite software engineering book at the moment (and I have a lot to pick from). The easy and relaxed writing style makes it a joy to read, the advanced concepts covered and the way that the worked example really speaks to my experience in developing real-world software add up to an exciting read for any developer interested in pushing the boundaries of their craft.
As a final note, although the worked examples are all in Java I found it very easy to follow despite coming from a .net/C# background (I think a C# version of the code is now available as well).
With the above in mind it is still a good book. The target audience seems to be developers with interest in, but no experience in TDD. They show how to incrementally grow the software, writing the tests first. They mention TDD best practices, pitfalls and how to efficiently work with mock objects in order to test 'the right thing'.
If you have TDD experience this book will merely be a reminder of the things you should and should not do and admittedly you will quite often think "I am doing that".
If you do not have TDD experience then I believe this book would be much more beneficial as it shows how TDD is practised day-to-day.
I consider myself an experienced programmer when it comes to Test Driven Development. I've picked up the practice back around 2003, when I first read Kent Beck's XP Explained. The habit was further reinforced by Martin Fowler's Refactoring book, and those 2 guys are my programming idols to this day. I hope I grow to have as much an open mind to experimentation as they have.
After watching Kent's screencasts on TDD by the Pragmatic Programmers, I felt pretty confident I was doing the "right thing"™ when it came to TDD. I later interviewed with ThoughtWorks, and had some harsh feedback on my TDD skills. This is one of the books they told me to pick up in order to toughen up, and boy were they right.
Steve and Natan dig deep into "modern" mockist TDD, building a real application with a UI and testing it both inside-out and outside-in with unit and acceptance tests. While mocks and behaviour driven development are not new things as they were when they wrote the book, the practices and hints they give throughout the book will be just as valid as they were a few years ago.
Along with Eric Evans' DDD book, this is a must read and must have for anyone that considers themselves a professional programmer. My TDD skills have levelled up much after following the book, and most importantly, I have a reference to look into when I found myself stuck in a corner with a "real world application" and testing.

