{ignasibosch .com}

#Design

 A philosophy of software design - John Ousterhout

I read A Philosophy of Software Design about 18 months back. It's a well-structured, concise read about managing complexity in software design. I don't think the suggested approaches are applicable in all situations (and John Ousterhout says this himself IIRC), but I recognised a lot of the problems described in the book and found it provided some useful ways to articulate concepts during code reviews (eg. whether adding a shallow function is increasing complexity in a codebase, if complexity can be pulled down into an implementation, or where it's useful to have consistency in the code).

Design Philosophy Software Development

May 1 2025

 Design Discovery In Existing Systems

We all want the best design but often that is not directly obtainable. Our tools for understanding systems behaviour may lead us to the abstractions we would want to use in a rewrite but what about the abstractions that exist in the system now? Do they matter? What about the structure? Are there unnamed concepts we can see through the current cohesion and coupling in the system that will help us get to where we need to go? In this talk, Michael Feathers will describe cases where being aware of what currently exists leads to better solutions. We can often leverage what we have instead of building up a domain from a greenfield.

Abstraction Design Systems Video

Feb 18 2025

 Shades of Conway's Law

In short, Conway's Law says any organisation that designs a system will come up with a system design that copies the organisational communication structures. Over the years, many individuals rephrased Conway's Law in various ways. Every paraphrase brings new insights and non-negligible consequences. Sometimes they give the impression of contradicting each other. However, in the end, they all come to the same conclusion. The organisation and the system keep each other in balance. Modifying the organisation will have an impact on the system. Modifying the system will have an impact on the organisation. Not considering that will cause friction in the organisation or the system with dramatic consequences. To be competitive as an organisation in the market, and to effectively design the right thing our customers expect us to deliver, we'd better understand and take advantage of this. About Thierry de Pauw: Thierry is a lean IT Engineer at the fintech startup Abbove. On the side, he founded ThinkingLabs, an advisory firm for optimising IT delivery while reducing stress, burnout and fatigue. From time to time he is asked to conduct technology due diligence for investors to review the technology capabilities of organisations. Thierry is a CI/CD advocate and jack-of-all-trades. Instead of balancing quality & delivery, he believes and practices that better quality is actually a way to more and better deliveries.

Conway's Law Design Video

Oct 14 2024

 Visual Agility: Why We Model

Design of complex systems is hard -- wickedly hard! It takes all the cognitive assist we can muster. Trade-offs must be made because there is interaction -- not just interaction among components to create a capability, but interaction among properties. And interaction between the system and its users and containing systems(-of-systems). And more! These systems are evolving -- the more agile, the more we try to take this co-evolution, this learning across boundaries, this symmathesy, into account.

Abstraction Design

Jul 19 2024

 Design Principles Behind Smalltalk

The purpose of the Smalltalk project is to provide computer support for the creative spirit in everyone. Our work flows from a vision that includes a creative individual and the best computing hardware available. We have chosen to concentrate on two principle areas of research: a language of description (programming language) that serves as an interface between the models in the human mind and those in computing hardware, and a language of interaction (user interface) that matches the human communication system to that of the computer. Our work has followed a two- to four-year cycle that can be seen to parallel the scientific method: Build an application program within the current system (make an observation) Based on that experience, redesign the language (formulate a theory) Build a new system based on the new design (make a prediction that can be tested) The Smalltalk-80 system marks our fifth time through this cycle. In this article, I present some of the general principles we have observed in the course of our work. While the presentation frequently touches on Smalltalk "motherhood", the principles themselves are more general and should prove useful in evaluating other systems and in guiding future work.

Design OOP Philosophy

Jan 2 2024

 12 Software Architecture Pitfalls and How to Avoid Them

Developing a successful software architecture is simple, but it’s not easy. Understanding QARs and then understanding and making the trade-offs that will maximally satisfy the QARs takes insight and experience, much of which has to be gathered through iterative experimentation on the architecture itself. The process itself is simple, but the trade-offs that need to be considered are often tough, and there are seldom easy answers.

Architecture Best Practices Design

Dec 18 2023

 Cell-Based Architecture — Architecture Pattern

Cell-based architecture in computing involves designing systems that consist of interconnected cells, each cell capable of executing tasks independently. Like the cells in a biological organism, these computing cells have their own processing units, memory, and communication capabilities. They operate in parallel, exchanging information and collaborating to solve complex problems efficiently.

Architecture Design

Sep 4 2023

 How to do distributed locking

As part of the research for my book, I came across an algorithm called Redlock on the Redis website. The algorithm claims to implement fault-tolerant distributed locks (or rather, leases [1]) on top of Redis, and the page asks for feedback from people who are into distributed systems. The algorithm instinctively set off some alarm bells in the back of my mind, so I spent a bit of time thinking about it and writing up these notes.

Design Disributed Systems

Aug 20 2023

 The lost art of software design

“Big design up front is dumb. Doing no design up front is even dumber.” This quote epitomises what I’ve seen during our journey from “big design up front” in the 20th century, to “emergent design” and “evolutionary architecture” in the 21st. In their desire to become “agile”, many teams seem to have abandoned architectural thinking, upfront design, documentation, diagramming, and modelling. In many cases, this is a knee-jerk reaction to the heavy bloated processes of times past, and in others, it’s a misinterpretation and misapplication of the agile manifesto. As a result, many of the software design activities I witness these days are very high-level and superficial in nature. The resulting output, typically an ad hoc sketch on a whiteboard, is usually ambiguous and open to interpretation, leading to a situation where the underlying solution can’t be communicated, assessed, or reviewed. If you’re willing to consider that upfront design is about creating a sufficient starting point, rather than creating a perfect end-state, you soon realise that a large amount of the costly rework and “refactoring” seen on many software development teams can be avoided. Join me for a discussion about the lost art of software design, and how we can reintroduce it to help teams scale and move faster.

Design Video

Aug 13 2023