One good reason to read Release it!

One good reason to read Release it!

Release It! is a book from Michael Nygard, and everywhere you look, the ratings are very good. At this post I will tell you just one reason (or should I say chapter?) why reading it worth the price and time.

Book structure

The book is divided into 4 big parts:

  • Part I: Create stability
  • Part II: Design for production
  • Part III: Deliver your system
  • Part IV: Solve systemic problems

To simplify, they verse around the idea of building and managing a software system without dying in the process. From a first block (my favorite) talking about low level patterns and technical ideas to make your code more resilient, to the next ones talking about topics you have to take care at the same time as you build, run and evolve that system.

In my own experience, ideas described in the part II or III are more spread around the technical community, but at code level there are more flaws that sometimes are not that hard to solve or improve. That is why I loved the first block more than the others, which are good anyway.

Below, an abstract of the patterns described in larger detail in the book.

The one big failure everyone experienced (or will experience)

Before jumping into the patterns, let’s talk about the anatomy of those big failures a lot of people suffered in their professional life at some point. Failures that create a chain reaction that takes down an entire system.

Anatomy of a global failure
Anatomy of a global failure

Most of the time the problems are related to unavailable systems, network conditions, let’s say at integration points. The following patterns don’t solve the problem completely, but reduce the impact.

A chapter that worth the price of the book

Preventing these kind of problems completely could be quite difficult, too expensive, or just impractical, but applying some of the following patterns could help us to stop receiving a phone call (in the middle of the night) because our entire system is down.

Michael Nygard describes the following list of patterns:

  • Timeout
  • Circuit-breaker
  • Bulkheads
  • Steady state
  • Fail fast
  • Let it crash
  • Handshaking
  • Test harness
  • Decoupling middleware
  • Shed load
  • Create back pressure
  • Governor

I created a sketchnote for each one of those, and I would like to share here with anyone that believes they could be useful.

Timeout

Timeout pattern
Timeout pattern

Circuit-breaker

Circuit-breaker pattern
Circuit-breaker pattern

Bulkheads

Bulkhead pattern
Bulkhead pattern

Steady state

Steady state pattern
Steady state pattern

Fail fast

Fail fast pattern
Fail fast pattern

Let it crash

Let it crash pattern
Let it crash pattern

Handshaking

Handshaking pattern
Handshaking pattern

Test harness

Test harness pattern
Test harness pattern

Decoupling middleware

Decoupling middleware pattern
Decoupling middleware pattern

Shed load

Shed load pattern
Shed load pattern

Governor

Governor pattern
Governor pattern

Extra ball

At this point you could be thinking about, where the hell is the backpressure sketchnote? I’ve already had one for that topic, and I just didn’t create a new one.

Backpressure pattern
Backpressure pattern

I hope you liked this post, feel free to share and use it :-)

Misc and references

Share: Twitter
Yeray Darias's Picture

About Yeray Darias

Software developer, I am like The Wolf, I solve problems (and I bake cookies)

Madrid, Spain https://ydarias.github.io