Growing Object-Oriented Software, Guided by Tests (Addiso... und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
EUR 37,95
  • Alle Preisangaben inkl. MwSt.
Nur noch 7 auf Lager (mehr ist unterwegs).
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Menge:1
Ihren Artikel jetzt
eintauschen und
EUR 10,80 Gutschein erhalten.
Möchten Sie verkaufen?
Zur Rückseite klappen Zur Vorderseite klappen
Anhören Wird wiedergegeben... Angehalten   Sie hören eine Probe der Audible-Audioausgabe.
Weitere Informationen
Alle 2 Bilder anzeigen

Growing Object-Oriented Software, Guided by Tests (Beck Signature) (Englisch) Taschenbuch – 12. Oktober 2009


Alle 2 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
Taschenbuch
"Bitte wiederholen"
EUR 37,95
EUR 33,65 EUR 47,98
60 neu ab EUR 33,65 11 gebraucht ab EUR 47,98

Hinweise und Aktionen

  • Studienbücher: Ob neu oder gebraucht, alle wichtigen Bücher für Ihr Studium finden Sie im großen Studium Special. Natürlich portofrei.


Wird oft zusammen gekauft

Growing Object-Oriented Software, Guided by Tests (Beck Signature) + Working Effectively with Legacy Code + Refactoring: Improving the Design of Existing Code (Object Technology Series)
Preis für alle drei: EUR 124,85

Die ausgewählten Artikel zusammen kaufen
Jeder kann Kindle Bücher lesen — selbst ohne ein Kindle-Gerät — mit der KOSTENFREIEN Kindle App für Smartphones, Tablets und Computer.


Produktinformation

  • Taschenbuch: 384 Seiten
  • Verlag: Addison Wesley; Auflage: 1 (12. Oktober 2009)
  • Sprache: Englisch
  • ISBN-10: 0321503627
  • ISBN-13: 978-0321503626
  • Größe und/oder Gewicht: 17,8 x 2,3 x 23,1 cm
  • Durchschnittliche Kundenbewertung: 4.7 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 9.517 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)
  • Komplettes Inhaltsverzeichnis ansehen

Mehr über die Autoren

Entdecken Sie Bücher, lesen Sie über Autoren und mehr

Produktbeschreibungen

Synopsis

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/

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

Welche anderen Artikel kaufen Kunden, nachdem sie diesen Artikel angesehen haben?


In diesem Buch (Mehr dazu)
Ausgewählte Seiten ansehen
Buchdeckel | Copyright | Inhaltsverzeichnis | Auszug | Stichwortverzeichnis
Hier reinlesen und suchen:

Kundenrezensionen

4.7 von 5 Sternen
5 Sterne
2
4 Sterne
1
3 Sterne
0
2 Sterne
0
1 Sterne
0
Alle 3 Kundenrezensionen anzeigen
Sagen Sie Ihre Meinung zu diesem Artikel

Die hilfreichsten Kundenrezensionen

17 von 18 Kunden fanden die folgende Rezension hilfreich Von kb am 21. März 2010
Format: Taschenbuch Verifizierter Kauf
Das Buch besteht aus einer allgemeinen Einleitung in modernes Test-Driven Development (und objektorientiertes Design) aus Sicht der Autoren, danach einem über mehrere Kapitel erstreckten Beispielprojekt und Tipps zu anspruchsvolleren Problemen. Codebeispiele basieren auf Java, allerdings wird gelegentlich auch .NET erwähnt, wo es signifikante Unterschiede gibt.

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.
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
5 von 6 Kunden fanden die folgende Rezension hilfreich Von Stefan Macke am 31. Oktober 2012
Format: Taschenbuch Verifizierter Kauf
Nachdem "Growing Object-Oriented Software, Guided by Tests" von Steve Freeman und Nat Pryce bei den "Ruby Rogues" besprochen wurde (siehe Episode 68), war mir klar, dass ich es auch lesen musste. Und ich muss sagen: es hat sich definitiv gelohnt. Es ist das beste Buch zum Thema Test Driven Development, das ich bislang gelesen habe.

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.
Lesen Sie weiter... ›
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen
0 von 8 Kunden fanden die folgende Rezension hilfreich Von Grzegorz Smajdor am 7. April 2013
Format: Taschenbuch Verifizierter Kauf
All OK!

Item like as described
Very fast delivery time and without any problems.
Really good and worth to recommend!
Kommentar War diese Rezension für Sie hilfreich? Ja Nein Feedback senden...
Vielen Dank für Ihr Feedback. Wenn diese Rezension unangemessen ist, informieren Sie uns bitte darüber.
Wir konnten Ihre Stimmabgabe leider nicht speichern. Bitte erneut versuchen

Die hilfreichsten Kundenrezensionen auf Amazon.com (beta)

Amazon.com: 36 Rezensionen
66 von 68 Kunden fanden die folgende Rezension hilfreich
Deep OO and TDD in one book 25. November 2009
Von Michael C. Feathers - Veröffentlicht auf Amazon.com
Format: Taschenbuch
There are many books about Test-Driven Development on the market, but this book is unique. It presents a style of TDD which originated in the London software development community. It's a style which pushes several key ideas to the extreme: "tell, don't ask" object design, fully end-to-end incremental development, and the deep synergy between testability and good design. Steve and Nat have done a stellar job refining and presenting these ideas. The text is lucid and precise. When you read this book you'll be exposed to far more than just another style of TDD, you'll be exposed to a depth of insight about emergent object oriented design which is both rare and extremely valuable.
43 von 45 Kunden fanden die folgende Rezension hilfreich
Excellent TDD book for actual practitioners 14. Januar 2010
Von Bas Vodde - Veröffentlicht auf Amazon.com
Format: Taschenbuch Verifizierter Kauf
This book has been in my Amazon pre-ordered list for quite a while and I was looking forward to this. I found the title alone already excellent. Steven and Nat (authors of jMock) are well known expert TDD practitioners, so I was looking forward to what they had to say. The book was better than I had expected.

The book consists of 5 parts. The first part of a very quick introduction to TDD and jMock. The second part discusses the tdd cycle in more detail. The third part (150 pages) is a very large example of growing a piece of software. The fourth part discusses topics on how to sustain TDD and the last part covers some advanced topics.

In this review, I'll skip part 1 as it was short and nothing special. Part two covers the TDD cycle and the link to evolutionary design. Steve and Nat have a design style that focuses almost purely on the interactions between classes which are most frequently tested using expectations on mock objects (which, as authors of jMock, they have lots of experience with). Most notable from part 2, for me, were the classifications of objects that they used, the strong focus on interaction and mocking (more than I usually have when test-driving) and their lack of focus on classes but focus on roles and responsibilities. Nat and Steve clarify their thinking exceptionally well which makes it all easy to understand.

Part 3 takes the largest part of the book, which is where they test-drive an AuctionSniper application. It is a small application, but large for a book example. The authors show how they gradually build up the application by adding one test at the time and how they gained insights during this process which made them adjust their design. I had mixed feelings about this part as a book didn't seem like the best medium for doing this, but still I appreciate the insights they had and also their attempt to make it as close to "real world" as possible.

Writing tests is one thing, maintaining them in another. Part 4 discusses how to make the tests maintainable and the tdd cycle sustainable. Personally, I found this part very insightful and the authors discipline exemplar. The authors start of with different test smells and what to do about it. They then discuss readability of the tests and of the error messages and spend some time of test object creation. Most notable from that part (for me) was their focus on using builders for creating test data, rather than object mothers.

The final part covers three (or actually two!) advanced topics. First is testing persistence where most interesting was how the authors seemed to prefer to "go all the way" whereas the common advise (for test speed) is to rollback and mock more. (this was actually a common theme in their book). The last two chapters deal with multi-threading and async code. I was unclear why these were separated in two chapters and they they were in this particular order. The content was excellent though, except that I missed some typical design guidelines related to multi-threading design. It almost felt they were in a hurry to write the last two chapters...

Anyways, in conclusion, this will definitively be one of my favorite (if not the favorite) TDD books and general design books. Steven and Nat did a wonderful job on this one. Though the book is not perfect, I enjoyed it thoroughly. A definite recommendation for anyone interested in modern design and TDD.
20 von 21 Kunden fanden die folgende Rezension hilfreich
This GREAT book deserves a better kindle version 26. November 2012
Von Bigodines - Veröffentlicht auf Amazon.com
Format: Kindle Edition Verifizierter Kauf
This is a GREAT book... one of those you don't wanna stop reading. But the kindle version sux so bad that I gave up when I saw the first code samples...

A programming book with code samples that are almost impossible to read is a huge drawback. 70% of the value is lost in the kindle version.. I am sure that sooner or later this will be fixed but until then... stick to the printed version.
21 von 23 Kunden fanden die folgende Rezension hilfreich
Food for nurturing your TDD mastery 17. Dezember 2009
Von Johannes Link - Veröffentlicht auf Amazon.com
Format: Taschenbuch
In a way this book presents the essence of a decade of test-driven development practice. The authors bring together the various tools of uptodate TDD like mock objects, bdd-style naming and acceptance tests. Open the book on any chapter and you will most likely find useful and deep advice, even if you consider yourself already a TDD expert.

There's one catch, though, that made me lower the rating to 4 stars: The authors go for an extended example which covers the full TDD cycle; from a walking skeleton, to the first acceptance test, into many obvious and some non-obvious refactorings. As noble as this endeavour is, it didn't work for me as a reader. Coming back to the text - and the code - after a day or two I often got lost trying to grasp the subtle nuances; I just couldn't remember all the necessary details of previous chapters.

Nonetheless, it's an excellent book and I enjoyed it. Get a copy, read it and become a better TDD practitioner.
9 von 9 Kunden fanden die folgende Rezension hilfreich
5 stars on the non-case study parts 21. Juni 2011
Von Jeanne Boyarsky - Veröffentlicht auf Amazon.com
Format: Taschenbuch
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 therefore covers Hamcrest matchers for both JUnit and JMock. I like the authors cover best practices, good design and clearly indicate what is a personal preference. I really liked part 4's emphasis on things that are hard to test at a higher level than "extract method."

The only thing that prevents me from giving full marks, is the case study. While I did read this part in one sitting, it was still hard to follow. There was a lot of information to keep in mind while trying to focus on the lessons of the example. I also think it was admirable for the authors to use a Swing example since Swing is harder to test. However, Swing is also less common for Java developers to use actively adding another block to understanding the software growing/testing aspects. And it is even harder for non-Java developers who are in the target audience for the book.

Except for the case study, I thought the book was amazing. And I'm sure the case study is a matter of taste.

---
Disclosure: I received a copy of this book from the publisher in exchange for writing this review on behalf of CodeRanch.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.