michaelnygard.com

According to the Theory of Constraints (ToC), every system has exactly one bottleneck that determines the throughput of the overall system.

Microservices were always a technical solution to an organizational problem.

Back in the Before Times, I went to a Haskell-flavored FP conference, where one of the speakers said something that blew my mind.

The “rule of eights” is a handy way to think about feedback cycle time and the effect it has on human attention spans.

About ten years ago, I was introduced to something called “The Bad Idea Game” by Danvers Fleury.

Suppose we build a road.

When trying to communicate, we sometimes use the same word thinking that it means the same thing to everyone.

When building an application, we tend to select a database technology based on its transactional characteristics.

Suppose we’ve had a recent error with a Kubernetes cluster.

Driving down a shady road, windows down, listening to the frogs and crickets, my family was in the car talking about various stuff and things.

In discussions about change in a complex system I commonly hear people object, “We can’t do that because X.”

I’ve seen a repeated pattern that plays out in many companies.

There’s a pattern I’ve observed a few times through scientific and computing history.

We’ve talked before about a walking skeleton.

Today, nobody wants to start up a competitor to Amazon.

Scaffold or Straightjacket?

Creating thousands or millions of entities and then deleting them does not return your database to its initial state.

In “A Philosophy of Software Design,” (ISBN-13: 978-1732102200) John Ousterhout describes the ideal functional interface as “narrow but deep.”

I’ve noticed a pattern in much business writing, including technical writing.

In the dim reaches of Unix history, the first shell was written.

Without an event, no time passes.

Architecture & Development Required Reading Architecture Decision Records C4 Model (Note: we will only use the first 3 C's.)

Shared State When programming distributed systems, the hardest kind of data to manage is shared mutable state.

An elegant design conserves mechanisms.

Another quick post based on a Twitter exchange.

Way back in January, Sam Newman tweeted this (perhaps rhetorical) question: I was in the middle of creating this slide (wrt patch hygiene) and had to stop half-way through and ask myself - aren’t we all just making this worse?

Hat tip to Stuart Halloway… once again a 10 minute conversation with Stu grew into a combination of code and writing that helped me clarify my thoughts.

The other day I tweeted that "Data is the New Oil."

This is a brief aside from my ongoing series about avoiding entity services.

This post took a lot longer to pull together than I expected.

In my last post I talked about the need to keep things separated once they've been decoupled.

Software doesn't have any natural boundaries.

Humans are great storytellers and even better story-listeners.

I’m excited to announce the beta of Release It!

I’ve come to believe that every system implicitly defines a spectrum of changes, ordered by their likelihood.

Queues are the enemy of high-velocity flow.

Last post covered technical definitions of fault, error, and failure.

Our systems suffer many insults when they contact the real world.

This is an excerpt from something I'm working on this Labor Day holiday: – Large scale power outages act a lot like software failures.

Do you remember Digital Audio Tape?

Many companies that have trouble delivering software on time exhibit a common pathology.

What does a philosopher born in the 19th Century have to say about software design?

If you help other people solve problems, you may have run into this phenomenon: a person gleefully tells you how messed up their environment is.

CRC I find the old object-oriented design technique of CRC Cards to be useful when defining service designs.

My daily language is Clojure.

While reading Bryan Cantrill's slides from Papers We Love NYC, I was struck by something.

Please understand, dear Reader, that I write this with positive intention.

Here's a syllogism for you: Every technical review process is a queue Queues are evil Therefore, every review process is evil Nobody likes a review process.

Every single person I've heard talk about Continuous Delivery says you have to change your system's architecture to succeed with it.

During this morning's drive, I crossed several small overpasses.