Download the free Kindle app and start reading Kindle books instantly on your smartphone, tablet, or computer - no Kindle device required. Learn more
Read instantly on your browser with Kindle for Web.
Using your mobile phone camera - scan the code below and download the Kindle app.
Release It!: Design and Deploy Production-Ready Software (Pragmatic Programmers) 1st Edition
There is a newer edition of this item:
- ISBN-109787392136
- ISBN-13978-9787392133
- Edition1st
- Publication dateJuly 12, 2017
- LanguageEnglish
- Dimensions8.5 x 0.79 x 11 inches
- Print length350 pages
Customers who viewed this item also viewed
Product details
- ASIN : 0978739213
- Publisher : Pragmatic Bookshelf, The; 1st edition (July 12, 2017)
- Language : English
- Paperback : 350 pages
- ISBN-10 : 9787392136
- ISBN-13 : 978-9787392133
- Item Weight : 1.6 pounds
- Dimensions : 8.5 x 0.79 x 11 inches
- Best Sellers Rank: #997,829 in Books (See Top 100 in Books)
- #140 in Client-Server Networking Systems
- #1,361 in Microsoft Programming (Books)
- #1,386 in Software Development (Books)
- Customer Reviews:
Important information
To report an issue with this product, click here.
About the author

Discover more of the author’s books, see similar authors, read author blogs and more
Customer reviews
Customer Reviews, including Product Star Ratings help customers to learn more about the product and decide whether it is the right product for them.
To calculate the overall star rating and percentage breakdown by star, we don’t use a simple average. Instead, our system considers things like how recent a review is and if the reviewer bought the item on Amazon. It also analyzed reviews to verify trustworthiness.
Learn more how customers reviews work on Amazon-
Top reviews
Top reviews from the United States
There was a problem filtering reviews right now. Please try again later.
Finishing the code is just a beginning of a system's life. It goes to the production and all sorts of things tend to happen. Guy who wrote this book had an incredible knowledge and experience with dealing with the production environments and he's sharing his experience with us. This book is well structured and grouped by related topics, but essentially it is just a set of stories and advices on operating production systems, and creating code that is supposed to run in the production. I'd like to name two "main" topics that you're going to read about: common programming practices and non-programming part - dealing with the live production systems.
Common programming practices include a rich variety of things like: Dealing with timeouts, capturing and understanding thread dumps, working with networks, understanding and tuning garbage collection, configuring proper logging, or understanding ORMs and related issues.
Dealing with the live production systems will discuss topics like: Embracing "fail fast" approach, understanding and dealing with SLAs, scaling of systems, performance monitoring, load balancing, designing configurable systems and so on.
Even though that "Release It!" is ~8 years old (as of this review), time didn't hurt it much. Yes, yes - we don't need to deal with RMIs and CORBas and old EJBs and manual synchronisation so often in "enterprise programming" today (thanks to the rich variety of mature enterprise frameworks) - but it's a no big deal. I still felt that this book was very relevant even today in the world of clouds, and MEANs and microservices and other buzzwords. I'm pretty sure that its message is going to last here for quite a while.
"Release It!" is the "Clean Code" of production systems. Somebody's already been there. Take this shortcut and learn how to make your life after the release easier. Avoid mistakes, learn from the best. It's been a wonderful read.
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.
Top reviews from other countries
É o que o autor chama de Stability patterns and anti-patterns destacando itens relacionados a Capacity e a arquitetura de software que influenciam sobremaneira na vida do sistema em produção. Alguns patterns são dedicados para evitar que a falha no software se torne um desastre. É são nesses patterns que pra mim esta o grande mérito do autor pois por mais prolífico que possam ser os erros, as causas tem um mínimo denominador comum como é descrito no livro. Ele apresenta vários casos de desastres de sistemas que poderiam ser evitados ou minimizados e que poderiam reduzir milhões em custo e manutenção caso os desenvolvedores e arquitetos se atentassem para os itens aqui mencionados.
Além disso, o livro é escrito com muito bom humor. As passagens em que ele relata seus casos na operação são muito engraçadas. Muito embora, cada uma delas representassem perdas significativas em dinheiro e imagem da empresa.
Altamente recomendado para desenvolvedores, arquitetos e equipe de sustentação de TI. Os itens aqui mencionados podem reduzir alguns milhões se seguidos e implantados com a colaboração de todos. Vale a pena conferir.
Come si può facilmente intuire dai case study disseminati per il libro, si tratta di una raccolta di cicatrici di guerra che hanno dato modo all'autore di sviluppare un'esperienza straordinaria nella scrittura e nel design di software.
Il libro fornisce definizioni chiare di termini oggi oltremodo abusati (Performance? Capacity?) e descrive una serie di pattern (e relativi antipattern) che se usati con giudizio vi consentiranno, fondamentalmente, di dormire tranquillamente la notte.
Esempio: è stato il libro che ha reso celebre il pattern Circuit Breaker, fondamentale per evitare effetti a cascata.
Il libro è uscito nel 2007, periodo in cui il monopolio di Java negli ambienti enterprise era incontrastato, per cui troverete spesso riferimenti a tecnologie disponibili solo in quel mondo. Il libro è comunque godibilissimo anche per chi vive al di fuori della JVM (come me) :D
Scritto in modo impeccabile, con la dovuta ironia e con citazioni di parecchie altre opere, anche non appartenenti al mondo informatico.
The only disappointment for Kindle users will be the footnotes: For some reason they get truncated - no matter which font size you select.
Over all that's still a solid 4* book - with a refresher to current state of technology could be 5* (yes, so few years have passed, but it feels like 10 years ago!)
The book is very well written, and gives solid examples of catastrophic failures that read like a story then goes in to these examples and explains patterns for avoiding them.
I'd recommend this book to anyone in the field of software development, architecture, release management and operational support who wants to learn how to avoid system failures and understand the techniques that can be used to achieve this.







