What Would Albert Camus Think About Software Development?

Last updated Apr 26th, 2021
Thoughts about Absurdism, essence, and software design.

🌱 This blog post hasn't fully bloomed. It's very likely to change over the next little while.

Albert Camus was a French philosopher most well known for his ideas about absurdism.

Sometimes regarded as an existentialist philosopher among his peers like Jean-Paul Sartre and Simone De Beauvoir, he contemplated existence, the complexity of the world, and eventually declared that any meaning we find in the world is there because we have personally assigned it.

As software developers, the very essence of what we do is to create something productive and meaningful within the inherent entropy of the world.

As Julian Shapiro says, the world is a patchwork of systems. And in the real world, we are constantly clashing against complexities. We maneuver though clumsy incumbent systems like "making friends in a new city", "finding an apartment that suits our needs", and "getting our driver's licenses renewed".

Software cuts through this complexity. We help people get from A to B with less stress, less effort, faster, and easier.

But not all complexity is equal. In our attempts to cut through complexity, we often create complexity.

I imagine that if Camus were a software developer, his famous quote about suicide could be reworked to say:

"There is but one truly serious philosophical software design problem and that is maintainability. Judging whether code is maintainable or not amounts to answering the fundamental questions of software design. All the rest — whether we should use React, a hexagonal architecture, server-less functions — comes afterwards. These are games; one must first answer."

Our mission with software design (as we discuss in the introduction of solidbook) is fundamentally to implement these two high-level goals - one for users and the other for developers. If we're not doing both well, our software design attempts are failing.

    1. [Users] Satisfy the needs of the user
    1. [Developers] Do it in the most maintainable way possible

The first goal is accomplished by implementing the essential complexity, that is - the features. If it were possible to use a no-code builder to reliably do this every time, then we'd likely be doing that. However, that's not where we are as an industry, so we write code to realize systems that solve problems for people.

The second goal exposes surface area for accidental complexity. We need to use paradigms, languages, and tools to build software. Some of these introduce inherent concepts that are known to cause (like state and sequence, according to Ben Moseley in his influential "Out of the Tar Pit" paper), and some of them introduce other subtle forms of complexity like:

  • Cognitive load
  • Ripple
  • Poor discoverability
  • Poor understandability
  • and leaky abstractions

It's for this reason that I'm starting to believe, more and more, that aligning with the essence of the problem should be the school of thought to which we master software design.

I believe that we should seek out techniques that bring us asympotically closer to implementing the bare minimum - the essential complexity of the problem - and mitigates as much accidental complexity as possible.


Liked this? Sing it loud and proud 👨‍🎤.

Stay in touch!

About the author

Khalil Stemmler,
Software Essentialist ⚡

I'm Khalil. I turn code-first developers into confident crafters without having to buy, read & digest hundreds of complex programming books. Using Software Essentialism, my philosophy of software design, I coach developers through boredom, impostor syndrome, and a lack of direction to master software design and architecture. Mastery though, is not the end goal. It is merely a step towards your Inward Pull.

View more in Philosophy

You may also enjoy...

A few more related articles

GraphQL Schemas vs. RESTful DTOs
GraphQL schemas serve a similar purpose to RESTful DTOs. One of the main differences is tooling. In this post, I aim to strengthen...
Client-Side Architecture Basics [Guide]
Though the tools we use to build client-side web apps have changed substantially over the years, the fundamental principles behind...
Accidental and Essential Complexity
Determining if the complexity of a problem is related to the nature of the problem or related to the way that we approach solving ...
How I Write Testable Code | Khalil's Simple Methodology
The single biggest thing that improved the quality of my designs was understanding how dependencies influence my ability to write ...