The Complexity of Simplicity - a talk by Bryan Cantrill

I have always been fascinated by the concept of simplicity in software design. Recently, I had the opportunity to listen to a talk by Bryan Cantrill titled “The Complexity of Simplicity.” In this talk, Bryan delves into the intricacies of software complexity and the importance of abstraction in managing it.

Here is a link to the talk and here’s an earlier blog I wrote on software complexity.

Here are my lessons I have picked by listening to Bryan Cantrill laced with my own interpretations.

• A good abstraction hides the gory details.

• Bad abstractions leak: instead of sealing implementation details. End results are systems that are unwieldy and brittle.

• Accidental complexity _adapted from Fred Brooks’ paper - No Silver Bullet _ , is the kind of complexity that’s induced in a problem with that kind of entanglement. Essential complexity is the kind that is endemic to a particular problem.

• Your accidental complexity can easily become someone’s essential complexity.

This resonates so much. I have worked on a number of developer tools. Part of my thinking has always been making things simple enough to enable someone use a tool with minimal documentation. I have encountered tools that are so hard to use even with documentation because the abstractions are so hard to untangle.

• Focus on essential complexity and eliminate accidental complexity. (This is an EVERYDAY BATTLE in software engineering)

• Controlling complexity is the essence of software engineering - Brian Kernighan

• When simplicity in the abstraction is a non-goal, you do not know what to say no to.

• Focus is the art of saying NO.

An informative diagram from the talk: