Residues: Time, Change, and Uncertainty in Software Architecture.

In this book a new approach is defined that fuses Software Engineering, Complexity Science, and Philosophy to produce an entirely new way to think about how to design software.

Author: Barry M O’Reilly

Personal Rating: 4.9/5

Link: https://leanpub.com/residuality

Personal Review:

This is a very interesting book. The author skillfully combines philosophy with software engineering and complex systems (which I am not very familiar with). As someone who works on building software architectures daily, I strongly resonated with this book. It delves into the philosophy behind different ways of solving architectural problems, many of which are already being implemented unofficially by architects. Inspired by this book, I plan to spend more time learning about complex system.

It's a small book, around 90 pages, with lots of breaks in the chapters, making it a fun and easy read. It's a must-read for senior+ engineers. One small critique is that the pricing might seem a bit high compared to the book's content. The price could have been more affordable 🤷🏽‍♂️."

Quote from the book:

In software engineering patterns can be seen as attractors. Attractors are the reason that we are able to engage with complex systems that seem to have innumerable variables-they provide a degree of predictability that is not related to the individual properties of elements of the system.

It is the job of the architect to design a structure for the complicated system that will allow it to survive as the complex context around it changes and moves. This is incredibly difficult as the nature of the complex context means that we cannot know what is going to change and the number of possibilities is enormous. Trying to solve this by somehow predicting the future of the complex context is impossible.

Architecture is the structure of a software application that drives the behavior of a software application in its environment. That is, the way the system responds to scale, load, changes, integrations, and things we normally refer to as non-functional concerns.

The goal of the architect is criticality, not correctness. Correctness is the goal of the programmer and the mathematician. This is one of the first major lessons a becoming architect must learn.

Linear thinkers make excellent programmers. They often come to architecture with a sense of mastery over programming, and often a sense of superiority. It can be quite shocking for many to find themselves outmaneuvered by seemingly lesser programmers who have a knack for lateral thinking and can use their imagination to skip many steps ahead in a single leap. I would venture to say that for the mythical 10X developer, 9X is lateral thinking.

Software architecture is the practice of being consistently wrong until you reach a point of being a little bit less wrong.

A talk by the Author if you do not wanna buy the book: