Neu:
34,99€34,99€
GRATIS Lieferung:
Dienstag, 28. Mär.
Versand durch: Amazon Verkauft von: Amazon
Gebraucht kaufen 22,88 €
Andere Verkäufer auf Amazon
& Kostenlose Lieferung
91 % positiv in den letzten 12 Monaten
& Kostenlose Lieferung
96 % positiv in den letzten 12 Monaten
& Kostenlose Lieferung
85 % positiv in den letzten 12 Monaten

Lade die kostenlose Kindle-App herunter und lese deine Kindle-Bücher sofort auf deinem Smartphone, Tablet oder Computer – kein Kindle-Gerät erforderlich. Weitere Informationen
Mit Kindle für Web kannst du sofort in deinem Browser lesen.
Scanne den folgenden Code mit deiner Mobiltelefonkamera und lade die Kindle-App herunter.


Mehr erfahren
Den Autoren folgen
OK
Growing Object-Oriented Software, Guided by Tests (The Addison-Wesley Signature Series) Taschenbuch – Illustriert, 13. Oktober 2009
Preis | Neu ab | Gebraucht ab |
- Kindle
26,24 € Lies mit kostenfreien App - Taschenbuch
34,99 €
Erweitere deinen Einkauf
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
- Seitenzahl der Print-Ausgabe384 Seiten
- SpracheEnglisch
- HerausgeberAddison Wesley
- Erscheinungstermin13. Oktober 2009
- Abmessungen17.78 x 2.92 x 23.24 cm
- ISBN-100321503627
- ISBN-13978-0321503626
Weitere Artikel entdecken
Produktbeschreibungen
Buchrückseite
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
Über den Autor und weitere Mitwirkende
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.
Produktinformation
- Herausgeber : Addison Wesley; 1. Edition (13. Oktober 2009)
- Sprache : Englisch
- Taschenbuch : 384 Seiten
- ISBN-10 : 0321503627
- ISBN-13 : 978-0321503626
- Abmessungen : 17.78 x 2.92 x 23.24 cm
- Amazon Bestseller-Rang: Nr. 339,288 in Bücher (Siehe Top 100 in Bücher)
- Nr. 159 in Objektorientiertes Softwaredesign
- Nr. 923 in Softwareentwicklung (Bücher)
- Nr. 1,328 in Programmiersprachen
- Kundenrezensionen:
Über die Autoren
Entdecke mehr Bücher des Autors, sieh dir ähnliche Autoren an, lies Autorenblogs und mehr
Entdecke mehr Bücher des Autors, sieh dir ähnliche Autoren an, lies Autorenblogs und mehr
Kundenrezensionen
Kundenbewertungen, einschließlich Produkt-Sternebewertungen, helfen Kunden, mehr über das Produkt zu erfahren und zu entscheiden, ob es das richtige Produkt für sie ist.
Um die Gesamtbewertung der Sterne und die prozentuale Aufschlüsselung nach Sternen zu berechnen, verwenden wir keinen einfachen Durchschnitt. Stattdessen berücksichtigt unser System beispielsweise, wie aktuell eine Bewertung ist und ob der Prüfer den Artikel bei Amazon gekauft hat. Es wurden auch Bewertungen analysiert, um die Vertrauenswürdigkeit zu überprüfen.
Erfahre mehr darüber, wie Kundenbewertungen bei Amazon funktionieren.-
Spitzenrezensionen
Spitzenbewertungen aus Deutschland
Derzeit tritt ein Problem beim Filtern der Rezensionen auf. Bitte versuche es später erneut.
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.
Ein Training und dann dieses Buch haben dann Hoffnung gegeben. Wir haben einfach den Platz von Unit Tests in der SW-Entwicklung missverstanden. Es geht um viel mehr, als um bessere Testabdekcung, kürzere Testlaufzeiten, schnelleren Feedback und Stabiliserung der Tests.
Freeman und Pryce zeigen Theorie und Praxis, wie mit Hilfe von TDD feingranular inkrementeller Design erfolgen kann. Nach einer prinzipiellen Einführung folgt über 150 Seiten die Entwicklung eines kleinen SW-Systems von Null aus.
- Zuerst wird die grobe Architektur überlegt, inklusive End-to-End Testautomatisierung.
- Es wird der erste End-to-End Test Entwickelt.
- Dann wird geschaut, dass ein Walking Skeleton diesen Test besteht.
- usw.
Was ich noch gelernt habe:
- Der unglaublich lesbare Kodierstil, der hier gezeigt wird.
- Das Verwenden von Mocking für das Voranbringen der Entwiclung von Klasse zu Klasse, nach dem Pull-Prinzip aus Lean. Es kommt keine Funktion in eine Klasse hinein, die nicht von Aussen durch einen End-to-End Test erfordert wird, oder durch eine andere Klasse konkret benötigt wird.
Definitv eines der besten Bücher über OOP/OOD!
Der erste Teil ist exzellent - griffig, klar und motivierend. Besonders wer bisher noch nicht viel mit TDD anfangen konnte, wird hier einiges klarer sehen können.
Für das Beispielprojekt muss man mehr Geduld haben. Es erschließt sich erst, wenn man's zur Gänze durcharbeitet. Trotzdem fand ich es insgesamt nicht besonders erhellend, auch weil das Beispiel recht "künstlich" ist und man sich für eine Swing-Applikation entschieden hat. Die große Mehrzahl der Leser dürfte aber mit serverseitigen (Web-)Applikationen arbeiten, und gerade dort gibt es spannende Herausforderungen ans Testen. Ebenso hätte es dem Buch gutgetan, wenn man hin und wieder auch andere Mocking-Libraries als das (m.E. eher umständliche) jMock erwähnt hätte.
Trotzdem bleibt das Fazit: die Konzepte werden gut vermittelt, das Buch liest sich angenehm und die Praxiserfahrung der Autoren ist gut erkennbar.
Any software developer should read this book.
Es gibt einen Einblick in Test Driven Development. Dies geschieht mit schönen Beispielen und leicht verständlichen Wörtern.
Das Buch versucht nicht durch neue Wortkreationen und Erfindungen das Rad neu zu erfinden, sondern versucht mit Beispielen aus der Realität, aus Erfahrungen und anderen Methodiken der Programmierung einen neuen Weg zu zeigen, der in der Software-entwicklung zu einer besseren und fehlerfreieren Software führt.
Sehr zu empfehlen!
Spitzenrezensionen aus anderen Ländern

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.

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.

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.

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).

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