Release It!: Design and Deploy Production-Ready Software und über 1,5 Millionen weitere Bücher verfügbar für Amazon Kindle. Erfahren Sie mehr
EUR 22,95
  • Alle Preisangaben inkl. MwSt.
Auf Lager.
Verkauf und Versand durch Amazon.
Geschenkverpackung verfügbar.
Release It!: Design and D... ist in Ihrem Einkaufwagen hinzugefügt worden
Ihren Artikel jetzt
eintauschen und
EUR 9,70 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

Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers) (Englisch) Taschenbuch – 20. April 2007

Alle 2 Formate und Ausgaben anzeigen Andere Formate und Ausgaben ausblenden
Amazon-Preis Neu ab Gebraucht ab
Kindle Edition
"Bitte wiederholen"
"Bitte wiederholen"
EUR 22,95
EUR 19,57 EUR 14,99
68 neu ab EUR 19,57 8 gebraucht ab EUR 14,99

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

Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers) + Ship It!: A Practical Guide to Successful Software Projects (Pragmatic Programmers)
Preis für beide: EUR 44,26

Die ausgewählten Artikel zusammen kaufen

Kunden, die diesen Artikel gekauft haben, kauften auch

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


  • Taschenbuch: 326 Seiten
  • Verlag: O'Reilly Vlg. Gmbh & Co.; Auflage: 1 (20. April 2007)
  • Sprache: Englisch
  • ISBN-10: 0978739213
  • ISBN-13: 978-0978739218
  • Größe und/oder Gewicht: 19 x 1,8 x 23,5 cm
  • Durchschnittliche Kundenbewertung: 4.7 von 5 Sternen  Alle Rezensionen anzeigen (3 Kundenrezensionen)
  • Amazon Bestseller-Rang: Nr. 13.458 in Fremdsprachige Bücher (Siehe Top 100 in Fremdsprachige Bücher)

Mehr über den Autor

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



""Agile development emphasizes delivering production-ready code every iteration. This book finally lays out exactly what this really means for critical systems today. You have a winner here.""--Tom Poppendieck, Poppendieck LLC.""It's brilliant. Absolutely awesome. This book would've saved [Really Big Company] hundreds of thousands, if not millions, of dollars in a recent release.""--Jared Richardson, Agile Artisans, Inc.""Beware! This excellent package of experience, insights, and patterns has the potential to highlight all the mistakes you didn't know you have already made. Rejoice! Michael gives you recipes of how you redeem yourself right now. An invaluable addition to your Pragmatic bookshelf.""--Arun Batchu, Enterprise Architect, netrii LLC


Whether it's in Java, .NET, or Ruby on Rails, getting your application ready to ship is only half the battle. Did you design your system to survive a sudden rush of visitors from Digg or Slashdot? Or an influx of real world customers from 100 different countries? Are you ready for a world filled with flakey networks, tangled databases, and impatient users? If you're a developer and don't want to be on call at 3AM for the rest of your life, this book will help. In "Release It!", Michael T. Nygard shows you how to design and architect your application for the harsh realities it will face. You'll learn how to design your application for maximum uptime, performance, and return on investment. Mike explains that many problems with systems today start with the design: "It's disconnected from the real world. It's the same as cars designed solely in the cool comfort of the lab - they look great in models and CAD systems, but don't work well in the real world.

You want a car designed by somebody who knows that oil changes are always 3,000 miles late; that the tires must work just as well on the last sixteenth of an inch of tread as on the first; and that you will certainly, at some point, stomp on the brakes while you're holding an Egg McMuffin in one hand and a cell phone in the other." With a combination of case studies and practical advice, Patterns to follow and Anti-Patterns to avoid, "Release It!" will help you manage the pitfalls that cost companies huge amounts of time and money each year.

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


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

Die hilfreichsten Kundenrezensionen

2 von 2 Kunden fanden die folgende Rezension hilfreich Von Dr. Gernot Starke am 27. Juni 2010
Format: Taschenbuch Verifizierter Kauf
Nygard schreibt interessant, sehr glaubwürdig und praxisbezogen.
Alle seine vielen "War-Stories" fand ich realitätsnah und gut beschrieben.

Er versucht, aus diesen "Katastrophen" eine Art Pattern-Familie zu entwickeln,
dazu allerdings kommen mir die konkreten Tipps zur Abhilfe etwas zu kurz (daher einen
Stern Abzug).

Aber: Ein wichtiges Buch für (fortgeschrittene) Software-Architekten,
die ihre Systeme in Produktion bringen möchten. Unbedingt lesenswert!

Fazit: Zur Inbetriebnahme von Software gibt's ansonsten (bisher) keine Bücher,
darum habe ich keinen Tipp für Alternativen...
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
Von Amazon Customer am 29. November 2013
Format: Taschenbuch Verifizierter Kauf
Dieses Buch ist ein Klassiker und gehört in jeden Entwickler/Dev-Ops-Schrank. Hat man sich erstmal an den Schreibstil gewöhnt, liest man es gut und gerne an einem Abend weg.
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
Von Hackbert am 21. April 2010
Format: Taschenbuch
Habe das Buch aufgrund einer Folge von Software Engineering Radio gekauft, in der der Autor interviewt wurde. Der gute Eindruck hat sich bestätigt, dass Buch ist voller praktischer Tipps und spannender Geschichten.
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 (beta) 44 Rezensionen
25 von 26 Kunden fanden die folgende Rezension hilfreich
Architecture for the paranoiac (or realist) 4. Juli 2007
Von James Holmes - Veröffentlicht auf
Format: Taschenbuch
The subtitle of this book might as well be Architecture and Design for the Paranoiac. The book lays out some critical aspects to creating and rolling out stable software systems. It's directed to those working in the enterprise arena and need the utmost from stability, capacity, and overall design. Nygard's definition of "enterprise" is somewhat broad in that he considers "enterprise" to be any system providing mission-critical support to a business. Regardless of how you define your particular software, I'm sure you'll find something useful in this book.

Nygard presents the book from an anti-pattern/pattern approach: he uses case studies to illustrate how critical errors in design or implementation (anti-patterns) have caused disasterous outages. He then moves on to show how application of solid design patterns could have avoided the problems. He also spends some time going in to detail on how some of the outages have happened, including brief discussions on network packet captures and decompiling third party drivers.

There are a lot of solid fundamentals in the book: dealing with exceptions at system integration points, thread synchronization, avoid rolling your own primative feature libraries such as connection pools, and make sure to test third-party libraries which play critical roles. The general approach of discussing anti-patterns followed by patterns is also a nice way of putting forth the material.

There are a lot of more complex bits covered as well, such as thinking ahead on how you'll deal with bots and crawlers, avoiding AJAX overkill, designing ahead for and using session. I also liked that Nygard talks about the importance of involving the customer in decisions on thresholds and other critical boundaries.

Despite the great content, there is a blistering flaw, IMO: A complete lack of solid implementation specifics. Nygard doesn't provide much detail at all on actual implementation of the critical patterns he espouses, nor does he point you in the direction of other sources of information. For example, the Timeout pattern is held up as a vital aspect in many parts of the book; however, there's no practical detail on actual code to implement a Timeout, and there's only one reference to a practical implementation. The Circuit Breaker pattern, central to many of Nygard's architecture assertions, doesn't have any code or a single reference to other material where you can find implementation details.

While I find that a major gap in the book, otherwise I think it's a solid addition to one's bookshelf. The writing style's very nice, his writing voice is light and concise, and the summary bullets in each section ("Remember This") are of great value. Additionally, there are plenty of references to other useful works. (Just not for the patterns I complained about above.)
9 von 10 Kunden fanden die folgende Rezension hilfreich
Design patterns of system architecture 4. Mai 2007
Von Larry MacNeill - Veröffentlicht auf
Format: Taschenbuch
This book is intended for architects, designers, and developers of software on which a business depends and whose failure costs money. The tone is informal and the style is easily read. Some architects may wish for more rigor and consider it too easily read but they might still benefit because it contains quite a bit of wisdom earned by experience.

The book discusses issues of uptime, failure, and maintainability with examples drawn from the author's experience and from other industries. Making the point from more than one point of view serves to drive it home.

This is not a programming book but the illumination of a problem is often improved by a snippet of code. The code is Java and is easily read by anyone familiar with programming. Having some familiarity with multi-threaded programming in following the explanations and their examples will make them a little easier to read but is not necessary to get the point. (Even if you truly have no knowledge of Java, looking up JDBC, JVM, EJB, JSP, J2EE, log4j, and servelet will not be much effort because not much knowledge of them is required.) The examples emphasize web applications because, I suppose, that's the environment most vulnerable to huge capacity requirements, more complex environments, more numerous causes of failure, and failures that are more visible.

The author's analysis of the problem space has two dimensions --- stability and capacity --- in which a given enterprise system can be located. The analysis also has two categories: general design and operations.

Stability and Capacity

A given coordinate, on the stability axis, for example, implies the presence and absence of features that improve and diminish stability. A feature that contributes to stability is the use of timeouts and one that detracts is the presence of many interfaces to other systems. The author identifies 8 such stability patterns that contribute to stability and 11 antipatterns that detract from it. Capacity has 4 patterns and 10 antipatterns.

General design and Operations

These two categories are less structured than those of stability and capacity.

"General design" contains advice about networking (integration with local and remote servers), security (principle of least privilege and managing passwords), availability (load balancing and clustering), and administration (QA vs production environments, configuration files, anticipating failure in start-up and shut-down, and an administrative interface).

"Operations" contains advice about recovery-oriented computing (surviving failure by restarting components, et al.), transparency (allowing a view of the system's internals), and adaptation (managing change).

The idea of patterns from software development is raised from the level of programming to the level of systems. I might have called them, for example, stability patterns and anti-stability patterns but the author's meaning is clear enough.

At the end of each pattern and antipattern section is a short and effective summary that begins with "Remember this". The design chapter has a summary and the operations chapter has two section summaries. The author clearly has in mind the reader's take-home lesson and the possibility that the book may be skimmed to reread a section. The book is cross-referenced, forward and back -- if an idea of current relevance is explained elsewhere in more detail, the page number is noted. For example, if an antipattern has a countermeasure identified by a pattern, then the relationship is noted with a page number.

Implementing some suggestions may make the QA phase of testing easier by making diagnosis and (white box) testing itself easier. If you want to design your software to be more reliable and easier to maintain after the QA phase of testing, then this book is for you.
6 von 6 Kunden fanden die folgende Rezension hilfreich
Everything a J2EE architecte should know about real life deployment 6. Juli 2007
Von Christophe Addinquy - Veröffentlicht auf
Format: Taschenbuch
Once in a year, I tag a book as "book of the year", the best book I read during the year. 2007 is not over, but this my "2007 book of the year", I know that.
Frankly, I just bough this book because it's published by the "pragmatic programmers" and I trust these guys. The title is not even appealing. I knew quickly that I will discover many things.
For a long time, I wonder what to do to build up a system which is fine in production, but I didn't understand quite right what was needed (I know now that I really misunderstood the problem). The first thing that came to my mind was to make the software strong (a good thing to do by the way) ; the second thing that came to my mind was to make it really, really strong (which starts to be stupid).
Michael helps us to understand that systems fail anyway. But it should fail fast (and can often fail only partially), it must facilitate diagnosis and quick restart. And design must deal with that. But the author doesn't stay in general considerations, he points out specific patterns and antipatterns for the systems design, by means of stability and capacity. The vast majority of article tend to exposes how new technologies make the life so easy. The author revisit technologies and technical choices throught the production glasses: why AJAX should be considered with care, why we must think about pre-computed pages instead of ynamic composition in some cases, why caches is not a one-size-fits-all answer and so on. Another important point well illustrated: a system is software + hardware and the architecture must be though with physical deployment and hardware architecture in mind. Promotion of full independance of the architecture over the deployment is plain wrong. There are so many subjects tackled her, I can't speak about them all, sorry.
Michael knows his stuff, because he worked on very big e-commerce sites and his horror stories (they are numerous) are quite impressive. Maybe you don't work for a huge e-commrce site ? I don't. Believe me, the lessons learned here are still valuable, because they are emphasized by the size of the system.
This is a 334pages long book, with not so many pictures. I tend to prefer short books, simply because it takes time to read books. Here, each word count, it's not too long, for sure.
Oh, one last thing. I hate to give 5 stars. To deserve 5 stars, it must be hell of a book ! It is !!
Great job Micheal, please notify me for the next one.
8 von 9 Kunden fanden die folgende Rezension hilfreich
Is your product really ready to ship? Are you ready for it to ship? 24. April 2007
Von T Michael Testi - Veröffentlicht auf
Format: Taschenbuch
It is the decisions that you make during development that will affect the quality of your release. Release It!: Design And Deploy Production-Ready Software was written to help you understand what causes good software to go bad, and to show you how to take control of the situation when it happens.

Release It! was written for architects, designers, and developers of enterprise class software systems. This includes applications, websites, web services, and EAI projects. According to the author, "enterprise class" means if the software stops, the company loses money.

All in all I found Release It! a very easy read. While the author comes from a Java and Unix perspective, the book's focus is generally neutral and grounded toward concepts and techniques that are portable across all platforms and technologies. Each of these case studies is based on real events, only the names (of people, companies, methods, and classes) have been change to protect the innocent. The detail of the information is very helpful, giving insight into the problems and their solutions.

My full review can be found over at Blogcritcs, but if you are looking for a better way to deliver your product, a way to avoid the traps and pitfalls, then Release It! is a good place to begin.
4 von 4 Kunden fanden die folgende Rezension hilfreich
Stories, Facts and Resources for Reliable Production Code 21. Juli 2007
Von Steve Berczuk - Veröffentlicht auf
Format: Taschenbuch Verifizierter Kauf
This book helps you to understand why creating production ready code requires work at many levels: creating the deployment architecture, operations scenarios, and just plain writing code and testing. The book covers issues that every architect, developer and release engineer should know. The book has principles, patterns, and resources to help you identify production problems, prevent them, and survive them when all else fails.

One of the better features of the book is the stories that help you to understand issues and demonstrate that Nygard's lessons are based in experience. The lessons are (as the name of the series suggests) pragmatic, and each chapter leaves you with enough information to make changes to improve your application.

In books of this sort there is a balance between "principles" that are timeless and "how to" techniques that you can use immediately. This book is biased slightly towards Java, and contains a few references to current tools, there are enough general principles that there is little in the book that will date it.

As I read the book I found information about many topics that arose in each project that I have worked on, as well as things that I felt that I needed to learn more about.

After I finished the book I felt energized to do things better. If you build enterprise applications buy this book to learn how to build more production-ready applications. If you already know the lessons in the book, buy a copy or two for your colleagues who may not so that your life will be easier and you can get fewer late-night phone calls about a system you helped build.
Waren diese Rezensionen hilfreich? Wir wollen von Ihnen hören.