- 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:
#234,020 in Books (See Top 100 in Books)
- #88 in Books > Computers & Technology > Networking & Cloud Computing > Data in the Enterprise > Client-Server Systems
- #246 in Books > Textbooks > Computer Science > Software Design & Engineering
- #595 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.
Fulfillment by Amazon (FBA) is a service we offer sellers that lets them store their products in Amazon's fulfillment centers, and we directly pack, ship, and provide customer service for these products. Something we hope you'll especially enjoy: FBA items qualify for FREE Shipping and Amazon Prime.
If you're a seller, Fulfillment by Amazon can help you increase your sales. We invite you to learn more about Fulfillment by Amazon .
There is a newer edition of this item:
"Children of Blood and Bone"
Tomi Adeyemi conjures a stunning world of dark magic and danger in her West African-inspired fantasy debut. Learn more
Frequently bought together
Customers who bought this item also bought
Customers who viewed this item also viewed
""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
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.
Author interviews, book reviews, editors picks, and more. Read it now
Top customer reviews
There was a problem filtering reviews right now. Please try again later.
mission-critical web applications, such as airline or shopping
systems. The author picks his examples only from the Java world, and
many examples rely on what I assume to be idiosyncracies of old Java
versions. It surely cannot be that the default Java HTTP connection
class does not allow a timeout value on read operations. It is also a
bit surprising that asynchronuous IO is not widely discussed in the
context of service-oriented architectures and fault-tolerant socket
connections. But whatever, I thought, because the sample stories were
interesting and written in a witty style.
Things started to get unpleasant at a certain point, though. First of
all, did I mention the Java-only examples? Further, the author starts
talking about utility computing (i.e. cloud computing) on page 75, and
somehow talks himself into a corner while trying to find excuses why
it's not a "thing" and why "barring crises of the most extreme sort,
you are more or less stuck with the amount of resources you have"
(p.76). Well, I don't know about the environment the author works in,
or would like to work in, but utility computing has been a reality
since nearly a decade now, and nearly every new mission critical
online system is being built on AWS or something similar where a new
computing unit can be started within a few minutes, without the full
paragraph of excuses the author concocts to make his point valid.
What really broke the book for me was on the next page, though. In a
discussion of how the request-handling threads of an application are
distributed, the author speaks of how one could do a calculation of
"how many threads could be making simultaneous calls to the scheduling
system". At this point I was expecting a simple calculation based on
performance characteristics or something similar, and was hoping to
learn a little bit about the maths of predictive profiling. But the
next sentence was like an overview of so many books on programming
these days: "The math is not hard, though it does rely on statistic
and numerous assumptions, which is a notoriously easy-to-manipulate
combination" (p.77). That was it? Not a single equation, not even a
reference? So it's "the math is hard, let's go shopping"? I have
difficulty understanding the math aversion of the majority of
programming books; is it because they fear the "difficult to read"
review on Amazon? I couldn't take the book seriously after this point,
unfortunately. The fact that it got even wordier after this page, and
the concrete points and examples got fewer in between did not help
In today's publishing world filled with so many well-written and
interesting books, this one is a waste of time; I would recommend
everyone to spend their precious time on another book.
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.
Most recent customer reviews
The main takeaway is to be paranoid, watchful and cautious.Read more