- Series: Pragmatic Programmers
- Paperback: 326 pages
- Publisher: Pragmatic Bookshelf; 1 edition (April 9, 2007)
- Language: English
- ISBN-10: 0978739213
- ISBN-13: 978-0978739218
- Product Dimensions: 7.5 x 0.7 x 9.2 inches
- Shipping Weight: 1.7 pounds (View shipping rates and policies)
- Average Customer Review: 67 customer reviews
Amazon Best Sellers Rank:
#48,893 in Books (See Top 100 in Books)
- #12 in Books > Computers & Technology > Networking & Cloud Computing > Data in the Enterprise > Client-Server Systems
- #40 in Books > Textbooks > Computer Science > Software Design & Engineering
- #104 in Books > Computers & Technology > Programming > Software Design, Testing & Engineering > Software Development
Enter your mobile number or email address below and we'll send you a link to download the free Kindle App. Then you can start reading Kindle books on your smartphone, tablet, or computer - no Kindle device required.
To get the free app, enter your mobile phone number.
Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers) 1st Edition
Use the Amazon App to scan ISBNs and compare prices.
There is a newer edition of this item:
The Amazon Book Review
Author interviews, book reviews, editors picks, and more. Read it now
Frequently bought together
Customers who bought this item also bought
"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."
"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."
"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."
About the Author
Michael Nygard has been a professional programmer and architect for over 15 years. He has delivered systems to the U. S. Government, the military, banking, finance, agriculture, and retail industries. Michael has written numerous articles and editorials, spoken at Comdex, and coauthored one of the earliest Java books. Michael has designed, built, and engineered systems for B2B exchanges, retail commerce sites, travel and leisure sites, an information brokerage, and web applications for the intelligence community. Among other exciting projects in his position as Director of Engineering for Totality Corporation, Michael led the operations team through the launch of a tier 1 retail site. His experience with the birth and infancy of this retail platform gives him a unique perspective on building software for high performance and high reliability in the face of an actively hostile environment.
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
The main takeaway is to be paranoid, watchful and cautious. There a number of spots where a system can come to grief. For example, resource pools, threads and integration points where external services are being called. The code will never be 100% error-proof, there will unexpected errors - the question is how to deal with them. How do you learn what to expect from your system? What proven "design patterns" help in reducing system fragility?
Now, the book quotes a lot of Java stuff. And it is an older book.
Despite not being a Java dev, I deeply believe that, in this context, a lot of the same pitfalls that apply to Java apply to other languages. These are integration issues, not development/unitary issues. Sure, if you are a seasoned pro in system management, some of this may be familiar. Which is a good sign, if you think about it. Neither the exact age of the book or the exact technologies being used matter all that much - what matters is knowing which parts of the system(s) are more likely to fail. The exact tech doesn't matter if you're calling a dead server, what matters is that you anticipate that it could fail and build tolerance around that.
If like me, you are approaching system deployment and maintenance from the dev/devops side of things, then there are some very good ideas to take away. Probably ideas that you would have had on your own, once you had hit some of the same issues.
Point in case: the debrief that followed Amazon's Sept 20, 2015 outage ended up being precisely the kind of stuff that this book cautions about. An overloaded service bogs all the other ones down. Not to say that Joe Blow, or me, after reading this book, would have avoided what Amazon's very clever folks didn't. But the type of error that happened is precisely of the typology addressed here.
My only "issues" with the content are the following:
1) The book deals largely with good practices, but provides very few code examples.
2) The author's frame of reference is primarily JAVA development, so most of the few code references in the book are only applicable to that language. If you're using a different set of development tools (.Net for example), it will be up to you to locate libraries to provide equivalent functionality.
On the whole the content of this book was excellent; but, if you're looking for a "how-to" with specific code examples, you'll be disappointed.
As a side-effect, this book also provides useful insight into how retail/e-commerce businesses and web sites operate.
Also, despite the book's significant conceptual density the author maintains a lighthearted writing style. Nearly every page has some analogy (or similar) to make the reader break into a smile. For example, when describing legal action taken against screen scraping sites and the sort, the author quips, "Like shooing a dog away from the dinner table, though, they always come back -- sometimes even in disguise."
My only real criticism is that some of the discussion is a bit dated.
Still a great read.
Most recent customer reviews
mission-critical web applications, such as airline or shopping