HjemGrupperSnakMereZeitgeist
Søg På Websted
På dette site bruger vi cookies til at levere vores ydelser, forbedre performance, til analyseformål, og (hvis brugeren ikke er logget ind) til reklamer. Ved at bruge LibraryThing anerkender du at have læst og forstået vores vilkår og betingelser inklusive vores politik for håndtering af brugeroplysninger. Din brug af dette site og dets ydelser er underlagt disse vilkår og betingelser.

Resultater fra Google Bøger

Klik på en miniature for at gå til Google Books

Indlæser...

Growing Object-Oriented Software, Guided by Tests

af Steve Freeman

MedlemmerAnmeldelserPopularitetGennemsnitlig vurderingOmtaler
274396,042 (4.25)1
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, youll 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… (mere)
Indlæser...

Bliv medlem af LibraryThing for at finde ud af, om du vil kunne lide denne bog.

Der er ingen diskussionstråde på Snak om denne bog.

» See also 1 mention

Viser 3 af 3
A great read for anyone interested in automated testing and TDD.

Pros:

* Makes a strong case for testing: better design, faster feedback, user experience first, regression, and most importantly, the confidence to make changes quickly.
* Includes a nice walk through of an iterative, test driven development process of a small app.
* Lots of great examples of how "listening" to tests leads to better design (ie, what the "driven" really means in TDD).
* I learned a lot from the discussion of how to make tests readable and maintainable.

Cons:

* The book is 100% Java. How do these lessons apply to other OO languages?
* The authors spend too much time selling the jMock framework
* The app they develop iteratively is a Java swing app full of distracting details like the way Swing manages threads. It was a bit boring at times and the code was verbose, so it was easy to lose focus.

Fun quotes:

What if software wasn’t “made,” like we make a paper airplane—finish folding it and fly it away? What if, instead, we treated software more like a valuable, productive plant, to be nurtured, pruned, harvested, fertilized, and watered? Traditional farmers know how to keep plants productive for decades or even centuries. How would software development be different if we treated our programs the same way?

As John Gall wrote in [Gall03], “A complex system that works is invariably found to have evolved from a simple system that works.”

In our work, we apply feedback cycles at every level of development, organizing projects as a system of nested loops ranging from seconds to months, such as: pair programming, unit tests, acceptance tests, daily meetings, iterations, releases, and so on. Each loop exposes the team’s output to empirical feedback so that the team can discover and correct any errors or misconceptions.

One lesson that we’ve learned repeatedly is that nothing forces us to understand a process better than trying to automate it.

Our experience is that, when code is difficult to test, the most likely cause is that our design needs improving. The same structure that makes the code difficult to test now will make it difficult to change in the future.

When composing objects into a new type, we want the new type to exhibit simpler behavior than all of its component parts considered together. The composite object’s API must hide the existence of its component parts and the interactions between them, and expose a simpler abstraction to its peers.

In most systems we build, we end up writing a runtime exception called something like Defect (or perhaps StupidProgrammerMistakeException). We throw this when the code reaches a condition that could only be caused by a programming error, rather than a failure in the runtime environment.

By repeatedly fixing local problems in the code, we find we can explore the design safely, never straying more than a few minutes from working code. Usually this is enough to lead us towards a better design, and we can always backtrack and take another path if it doesn’t work out. One way to think of this is the rock climbing rule of “three-point contact.” Trained climbers only move one limb at a time (a hand or a foot), to minimize the risk of falling off. Each move is minimal and safe, but combining enough of them will get you to the top of the route. ( )
  brikis98 | Nov 11, 2015 |
Maravilloso libro sobre el pensamiento architectural usando TDD.Tiene un explicación muy detallada de cómo abstraer un sistema orientado a objetos y verdadero significado del paradigma OO
  agilenature | Jun 23, 2011 |
Good book but its completely Java oriented (more than i expected) so not too much to learn for .Net oriented people.
Still there are some very good chapters for every professional like chapters on unit testing threading and asynchronous calls etc.
Also first-hand chapter on history of mocking is very nice. ( )
  spavkov | Mar 31, 2010 |
Viser 3 af 3
ingen anmeldelser | tilføj en anmeldelse
Du bliver nødt til at logge ind for at redigere data i Almen Viden.
For mere hjælp se Almen Viden hjælpesiden.
Kanonisk titel
Originaltitel
Alternative titler
Oprindelig udgivelsesdato
Personer/Figurer
Vigtige steder
Vigtige begivenheder
Beslægtede film
Indskrift
Tilegnelse
Første ord
Citater
Sidste ord
Oplysning om flertydighed
Forlagets redaktører
Bagsidecitater
Originalsprog
Canonical DDC/MDS
Canonical LCC

Henvisninger til dette værk andre steder.

Wikipedia på engelsk

Ingen

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, youll 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

No library descriptions found.

Beskrivelse af bogen
Haiku-resume

Current Discussions

Ingen

Populære omslag

Quick Links

Vurdering

Gennemsnit: (4.25)
0.5
1
1.5
2 1
2.5
3 3
3.5 2
4 12
4.5
5 14

Er det dig?

Bliv LibraryThing-forfatter.

 

Om | Kontakt | LibraryThing.com | Brugerbetingelser/Håndtering af brugeroplysninger | Hjælp/FAQs | Blog | Butik | APIs | TinyCat | Efterladte biblioteker | Tidlige Anmeldere | Almen Viden | 203,187,542 bøger! | Topbjælke: Altid synlig