Deliver to your Kindle or other device

 
 
 

Try it free

Sample the beginning of this book for free

Deliver to your Kindle or other device

Read books on your computer or other mobile devices with our FREE Kindle Reading Apps.
Growing Object-Oriented Software, Guided by Tests
 
 

Growing Object-Oriented Software, Guided by Tests [Kindle Edition]

Steve Freeman , Nat Pryce
4.9 out of 5 stars  See all reviews (16 customer reviews)

Digital List Price: £26.30 What's this?
Print List Price: £33.99
Kindle Price: £19.42 includes VAT* & free wireless delivery via Amazon Whispernet
You Save: £14.57 (43%)
Unlike print books, digital books are subject to VAT.

Formats

Amazon Price New from Used from
Kindle Edition £19.42  
Paperback £25.89  


Product Description

Product Description

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

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

 


Product details

  • Format: Kindle Edition
  • File Size: 12314 KB
  • Print Length: 384 pages
  • Publisher: Addison-Wesley Professional; 1 edition (12 Oct 2009)
  • Sold by: Amazon Media EU S.à r.l.
  • Language English
  • ASIN: B002TIOYVW
  • Text-to-Speech: Enabled
  • Average Customer Review: 4.9 out of 5 stars  See all reviews (16 customer reviews)
  • Amazon Bestsellers Rank: #28,762 Paid in Kindle Store (See Top 100 Paid in Kindle Store)
  •  Would you like to give feedback on images?


More About the Authors

Discover books, learn about writers, and more.


Tags Customers Associate with This Product

 (What's this?)
Click on a tag to find related items, discussions, and people.
 
(1)

Your tags: Add your first tag
 

Customer Reviews

3 star
0
2 star
0
1 star
0
Most Helpful Customer Reviews
20 of 20 people found the following review helpful
Format:Paperback
Growing Object Oriented Software, Guided by Tests, by Steve Freeman and Nat Pryce is a TDD book, but unlike any other on the market today. First of all, the book deals mostly with advanced unit testing topics, such as designing tests for readability and mocking, and addresses many common stumbling points that people experience with unit testing a few years after they started their journey, such as applying unit testing in multi-threaded and asynchronous environments. Second, it explains and demonstrates in practice the dynamics of designing software through TDD, which is still a dark art for many programmers. And third, it gives the reader insight into Freeman's and Pryce's brains, which is why this book is a must-read for anyone serious about unit testing, even to people that have been doing it in the last century.

Given the authors' backgrounds, it's not surprising that this book has a lot to say about using mock object libraries. Mock objects are arguably the most misunderstood and misused concept in software development today, so this book should be a valuable resource for most software development teams. In the part dealing with mock objects you will find strategies for using them successfully for software design, guidelines what to mock and what not to mock and lots of examples how all that looks in code.

The book isn't written in the usual imperative way ("you should use this because of...") but reads much more as an experience report ("we use this because of"). This might be unusual at first but I really like it, as it puts the things into a much more different perspective. Many of the topics addressed by this book are quite controversial and the authors have wisely chosen the voice to avoid any notion of preaching. I found myself disagreeing with parts, especially around bundling acceptance and end-to-end testing together. However, as the material doesn't preach but tell what the authors are thinking about, this did not bother me at all.

All in all, an excellent book. Grab a copy now.
Comment | 
Was this review helpful to you?
7 of 7 people found the following review helpful
Format:Paperback|Amazon Verified Purchase
Some of the other reviewers are referring to this book as 'advanced'. I think it's advanced if you're relatively new to TDD. It would certainly help if you're a competent developer (which is probably why you're looking at TDD anyway), but it's 'advanced' if you want to change the way that you develop software.

It's a good read and I found quite a few "aha" paragraphs (my copy's now punctuated with permanently folded corners/post it notes).

It's nicely written without sounding arrogant. I think it's quite a hard topic to cover without getting bogged down in the minutiae of whys and wherefores of decisions, which it covers at exactly the right level

My only criticism is that I found it wee bit annoying the way it referred to the latter worked example when introducing an aspect of TDD, forcing me to skip back and forth a bit - but I think that's just a personal book reading preference.

I'm not sure how much an experienced TDD practioner would gain from it (except to see some of your own thoughts mirrored in black and white), but would very much recommend it to those new or getting started with TDD, wishing to `do it right'

Although the code samples are in Java it is applicable to other languages, such as C#, as the concepts are language independent
Comment | 
Was this review helpful to you?
3 of 3 people found the following review helpful
Format:Paperback
This book is excellent, showing you not only how to do great TDD, but also how to do great design.
I would recommend it to all programmers out there who can read Java.
(The one caveat is that the book is all in Java, and so if you find reading Java hard you won't get as much out of the book.)

Steve and Nat walk you though a non-trivial example over many chapters which allows you to see how they think and how they write code.
Of course they use evolutionary design. So if you haven't got much experience with evolutionary design this book will show you how it works in practice.

TDD has improved and evolved over the years, making many of the earlier books on TDD seem outdated.

This books is full of personality and show how Steve and Nat approach TDD today.

I liked the state transition diagrams they used to visualise the system, and show which bits have been tested, and which bit is currently being worked on.
Comment | 
Was this review helpful to you?
Most Recent Customer Reviews
Changed the way I think
This book fundamentally changed my understanding of TDD.

It is the first clear, detailed description I have seen of how test-driven development (TTD) not just improves... Read more
Published 1 month ago by David Allsopp
Excellent
This is a very clear and well thought out book. The authors have a wealth of real programming experience behind them and present a series of techniques and ideas that should help... Read more
Published 11 months ago by Ian Miller
I'll cut straight to the chase: This is a great book!
I'll cut straight to the chase: This is a great book! In fact I'd put it second, behind Test Driven Development by Kent Beck, on my must read list for developers. Read more
Published 12 months ago by Mr. Paul J. Grenyer
Essential
I think this is the single most important contribution to software engineering that I have read in the last two years.
Published 14 months ago by Wee Engineer
Good TDD book
I enjoyed reading this book. I was not very familiar with TDD and this book gave me an idea of what TDD is about by providing both theoretical and practical contents. Read more
Published 16 months ago by Dax
A good book about TDD.. but...
Having read Test Driven development by Koskela (Manning) and having some experience in the 'art' I felt that this book added just a few bits and pieces. Read more
Published 16 months ago by A. A. Iglesias
Must be read
This book should be read by everyone who wants to be a professional OOP and also wants to be "agile". Read more
Published 18 months ago by Padovani Gianluca
Puts design front-and-centre in TDD
There are many excellent books out there covering TDD from the basic concepts to the technical application of TDD but for me this book stands out from the crowd as the only one... Read more
Published 18 months ago by Finn Newick
Excellent exploration of how professional developers should behave
Test driven development is something that separates programmers from developers, but until recently there was little literature beyond "write a failing test, write the code,... Read more
Published 20 months ago by florien
An imperfect but must read book
This book has changed the way I code. As someone that has been coding for 20 years and using TDD for 3 or 4 years that is as clear a recommendation as I can think of. Read more
Published on 25 Mar 2010 by Adrian Bates
Search Customer Reviews
Only search this product's reviews

Popular Highlights

 (What's this?)
&quote;
Our heuristic is that we should be able to describe what an object does without using any conjunctions (and, or). &quote;
Highlighted by 109 Kindle users
&quote;
nothing forces us to understand a process better than trying to automate it. &quote;
Highlighted by 92 Kindle users
&quote;
Acceptance: Does the whole system work? Integration: Does our code work against code we cant change? Unit: Do our objects do the right thing, are they convenient to work with? &quote;
Highlighted by 91 Kindle users

Customer Discussions

This product's forum
Discussion Replies Latest Post
No discussions yet

Ask questions, Share opinions, Gain insight
Start a new discussion
Topic:
First post:
Prompts for sign-in
 

Search Customer Discussions
Search all Amazon discussions
   



Look for similar items by category


Look for similar items by subject


Amazon Media EU S.à r.l. GB Privacy Statement Amazon Media EU S.à r.l. GB Delivery Information Amazon Media EU S.à r.l. GB Returns & Exchanges