- Buy this product and stream 90 days of Amazon Music Unlimited for free. E-mail after purchase. Conditions apply. Learn more
Growing Object-Oriented Software, Guided by Tests (Beck Signature) Paperback – 12 Oct 2009
|New from||Used from|
- Choose from over 13,000 locations across the UK
- Prime members get unlimited deliveries at no additional cost
- Find your preferred location and add it to your address book
- Dispatch to this address when you check out
Special offers and product promotions
Frequently bought together
Customers who viewed this item also viewed
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Would you like to tell us about a lower price?
If you are a seller for this product, would you like to suggest updates through seller support?
Summary Mock Objects is an approach to Test-Driven Development that changes the way programmers think about code. It encourages them to think about how objects interact with each other, rather than just how they work in isolation - as the founders of Object Oriented programming intended. Objects should be defined in terms of what they do, not what they are. Using Mock Objects with Test-Driven Development guides developers towards code with clearly focused objects and an emphasis on behavior over data - both features of good Object Oriented programming. This book has been written by two of the originators of the concept, who have developed and refined their understanding over years of practice on real projects. The book describes the basic concepts and shows how they fit into the development cycle. It also addresses the common misunderstandings and pitfalls that they have encountered. Author(s) Expertise Steve Freeman (UK) is a consultant with ThoughtWorks and has been involved in the XP community since before there were books. He has a PhD in Computer Science and degrees in Statistics and Music, and was one of the authors of the first Mock Object paper.Nat Pryce (UK) is an independent consultant with expertise in software design, software development process and practices.He is also a research fellow at Imperial College. Nat is a developer of the jMock and nMock libraries for testdriven development. Audience This book is intended for people who are directly concerned with the writing of code: developers at various levels, technical leaders, development managers. They are expected to have experience with an OO language such as C# or Java. The CD/DVD/Web Site http://www.mockobjects.com/
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
See all Product description
Customers who bought this item also bought
There was a problem filtering reviews right now. Please try again later.
It is the first clear, detailed description I have seen of how test-driven development (TTD) not just improves the quality of code, but can and should be used as a driver to change the actual design of the code. In other words, why you don't merely write less buggy code with TDD, but fundamentally different (and better) code.
The book describes how to kick off a new project with a "walking skeleton" - a minimal end-to-end feature that exercises the entire automated build-deploy-test infrastructure that you will need for the rest of the project.
It describes how end-to-end acceptance tests differ from unit tests and integration tests, and how the three types fit together.
Much of the book is an extended worked example, including asynchronous networking and UI code. This level of detail requires effort to read, but prevents the authors from hiding behind any form of hand-waving, and is well worth the effort - I am currently re-reading all the way through.
If you aspire to test-first programming then you need this book. If you don't aspire to test-first programming then you should read this book.
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.
Growing Object Orientated Software Guided by Tests was the first place I read about the Walking Shelton. Originally described by Alistair Cockburn, this is a technique I've been using for the last few years and didn't realise there was a name for. The Auction sniper example that covered by the middle chapters introduces not only testing techniques, but lots of useful and practical lessons about good design. The later chapters discuss improving your tests, including readability. The final two chapters cover testing threaded code and asynchronous code. Some of the ideas presented here were new to me and would have have been very useful refactoring exercises for some projects I used to work on.
If you want to develop higher quality, robust software, read and apply the lessons in the book.
Warning: The code examples in the Kindle version of this book are difficult to read and there are a few misprints compared to the paper version.
If you can master TDD, this will open up a whole new world of software engineering.
This book appears to be the best there is on the subject, and contains many valuable bits of info. Also talks about, though briefly, the Ports and Adapter architecture (aka Hexgonal), which looks like a great architecture.
The crux of the matter, is if your code is easy to test (read 'use'), it's good code. And the only way to know if it's easy to test, is to test it.
Buy this book, study it, become a better coder, get a payrise...
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