Peace of mind through maintainable software
Anyone can generate a simple one-off app or a prototype with AI now. The barrier to getting something working has never been lower.
But how do you build software that people can actually rely on? Software that doesn't just handle the happy path? That won't break at the worst possible moment?
Once you have something working, how do you evolve it over time? How to make it easy to add new features or change large parts of the system without a "simple" change turns into a three-week debugging nightmare?
Tests help, but they can only prove the presence of bugs, not their absence. You can't test your way out of fundamental design problems.
The key to maintainable software is threefold:
- Deeply understanding your tech stack
- Making the best of your compiler
- Structuring your system according to its purpose — designing for change, not trying to predict the future
The goal of this website is to find out how to achieve this.
We'll explore the latest developments in programming languages, OS design, performance-aware and declarative programming.
We'll ignore ecosystem boundaries and tribal thinking, searching for techniques that work regardless of your stack, language, or paradigm.
We'll dive into fundamentals when they matter — from assembly and memory models to programming language design — demystifying how things actually work and questioning established assumptions.
Even if AI slop ends up comprising 90% of the software in the coming years, building this fundamental knowledge will help serious developers stay in control and build robust, maintainable software that serves real needs and stands the test of time.
Quick question
What best describes your role?
This helps me direct new content.