Aucun appareil Kindle n'est requis. Téléchargez l'une des applis Kindle gratuites et commencez à lire les livres Kindle sur votre smartphone, tablette ou ordinateur.

  • Apple
  • Android
  • Windows Phone
  • Android

Pour obtenir l'appli gratuite, saisissez votre numéro de téléphone mobile.

Prix Kindle : EUR 24,52

Économisez
EUR 30,80 (56%)

TVA incluse

Ces promotions seront appliquées à cet article :

Certaines promotions sont cumulables avec d'autres offres promotionnelles, d'autres non. Pour en savoir plus, veuillez vous référer aux conditions générales de ces promotions.

Envoyer sur votre Kindle ou un autre appareil

Envoyer sur votre Kindle ou un autre appareil

Growing Object-Oriented Software, Guided by Tests par [Freeman, Steve, Pryce, Nat]
Publicité sur l'appli Kindle

Growing Object-Oriented Software, Guided by Tests 1 , Format Kindle

2.0 étoiles sur 5 1 commentaire client

Voir les 2 formats et éditions Masquer les autres formats et éditions
Prix Amazon
Neuf à partir de Occasion à partir de
Format Kindle
"Veuillez réessayer"
EUR 24,52

Longueur : 384 pages Composition améliorée: Activé Page Flip: Activé
Langue : Anglais

Description du produit

Présentation de l'éditeur

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

Quatrième de couverture

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

 


Détails sur le produit

  • Format : Format Kindle
  • Taille du fichier : 16626 KB
  • Nombre de pages de l'édition imprimée : 384 pages
  • Utilisation simultanée de l'appareil : Jusqu'à 5 appareils simultanés, selon les limites de l'éditeur
  • Editeur : Addison-Wesley Professional; Édition : 1 (12 octobre 2009)
  • Vendu par : Amazon Media EU S.à r.l.
  • Langue : Anglais
  • ASIN: B002TIOYVW
  • Synthèse vocale : Activée
  • X-Ray :
  • Word Wise: Non activé
  • Lecteur d’écran : Pris en charge
  • Composition améliorée: Activé
  • Moyenne des commentaires client : 2.0 étoiles sur 5 1 commentaire client
  • Classement des meilleures ventes d'Amazon: n°161.348 dans la Boutique Kindle (Voir le Top 100 dans la Boutique Kindle)
  • Voulez-vous nous parler de prix plus bas?

click to open popover

Commentaires en ligne

2.0 étoiles sur 5
5 étoiles
0
4 étoiles
0
3 étoiles
0
2 étoiles
1
1 étoile
0
Voir le commentaire client
Partagez votre opinion avec les autres clients

Meilleurs commentaires des clients

Format: Broché Achat vérifié
beaucoup de bonnes idées. Le DDD et la façon de faire des test est très stimulante. beaucoup d'exemples. Tout n'est pas toujours applicable mais c'est à étudier.
1 commentaire 2 personnes ont trouvé cela utile. Avez-vous trouvé ce commentaire utile ? Oui Non Commentaire en cours d'envoi...
Merci pour votre commentaire.
Désolé, nous n'avons pas réussi à enregistrer votre vote. Veuillez réessayer
Signaler un abus

Commentaires client les plus utiles sur Amazon.com (beta) (Peut contenir des commentaires issus du programme Early Reviewer Rewards)

Amazon.com: 4.4 étoiles sur 5 44 commentaires
5 internautes sur 5 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Great book that's shedding light on TDD Evolution 29 décembre 2015
Par Serge Medvedev - Publié sur Amazon.com
Format: Broché Achat vérifié
If you've always been wondering how...
- to apply TDD for designing not only small pieces of functionality but entire features, too,
- to connect all those little pieces developed in TDD micro-cycles together,
- to take ultimate advantage of Mock Objects usage and to know their unique place among other Test Doubles,
- to test-drive "difficult" code such as multi-threaded or DB-related one,
... then this book is for you.
Finally, there is something that doesn't just say that TDD is as easy as "Red-Green-Refactor" but describes the Big Picture instead.
I do recommend this book for those who have already read some stuff on the topic but still have some questions unanswered.
3 internautes sur 3 ont trouvé ce commentaire utile 
4.0 étoiles sur 5 Essential reading for OO software developers 24 octobre 2015
Par vsharkey - Publié sur Amazon.com
Format: Broché Achat vérifié
GOOS is a revealing walk through the construction of an online bidding system. The authors demonstrate how to evolve meaningful object design during the development process, as opposed to deriving simplistic and static designs by identifying the nouns and verbs in use cases as described in earlier OO books. Throughout the book the reader is guided through a powerful approach to test-first development.

The only reason I did not give this book five stars is that some of the frameworks the authors used are no longer available or are obsolete. This makes it nearly impossible to build the system along with the authors.
49 internautes sur 51 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 Excellent TDD book for actual practitioners 14 janvier 2010
Par Bas Vodde - Publié sur Amazon.com
Format: Broché Achat vérifié
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.
3 internautes sur 3 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 A must read for all OO developers 20 mai 2010
Par Wojciech Buras - Publié sur Amazon.com
Format: Broché Achat vérifié
This book deserves its place among the most important writings in the TDD and OOD field in the recent years. Its greatest advantage is the presentation of the continuous evolution of high-quality software guided by tests (as the title says it). While reading the third chapter, the audience may clearly see, how Steve Freeman and Nat Pryce really worked on their example project - sometimes making necessary tradeoffs, sometimes taking a step back and so on. From their experience with the example project comes a clear message to the reader about the deep synergy between pragmatic and to-the-point object oriented design and test driven development: if you make good OO analysis and design, your code is more testable - if you drive your code with tests, it will probably also positively influence your design. The authors not only describe this synergy, they also give some very valuable advice about how not to lose it in the long run of your project in the fourth chapter. Last but not least, the authors give a short theoretical introduction about TDD and some hints related to testing corner cases like persistence or concurrency. All in all, I highly recommend this book to anyone interested in Test Driven Development and Object Oriented Design.
4 internautes sur 5 ont trouvé ce commentaire utile 
5.0 étoiles sur 5 test your program, not your api 22 février 2013
Par Jeff Davis - Publié sur Amazon.com
Format: Broché Achat vérifié
I spent the first part of my career doing computational work, primarily in FORTRAN and C, before jumping into traditional "application development" about 18 months ago. My academic work consisted of applied math and statistical work; I knew precious little of being a quality "engineer" beyond proper syntax then. This book was a game changer for me.

What I discovered was that I was thinking about tests the wrong way. In my current shop, I often got frustrated at what was, I was thrilled to discover, a completely pointless test that felt like coding pablum to make the CI server happy with "test coverage". Genuine testing is much, much more. A dev that genuinely embraces TDD, and doesn't use it as a mere add on on his/her resume, won't be doing "Test Driven Development" but really "Test Driven Design". Some of the important higher level concepts this includes are:

1.) Listening to tests to create a more supple architecture.
2.) How to avoid "gold plating" features ( a big one for me )
3.) Using tests to describe the action of the object.
4.) Using syntactic sugar to make your exposed API far more readable to a future reader
5.) Spectacularly compact APIs
6.) If you've done XP, "ping pong" development is a real pleasure ( one writes the test, the other is forced to implement the feature to make the test pass, then they switch roles ).
7.) Focusing on the "message" an object passes to its peers or its delegators, which puts OOP in an entirely new light to me.

The standard "implementation tools" are also covered in depth to give you the ability to do the things listed above. Can't recommend it strongly enough.
Ces commentaires ont-ils été utiles ? Dites-le-nous