Raising the Level of Abstraction

This book is about building software systems at the right level of abstraction.

In many codebases, the structure of the system is buried in implementation details—classes, methods, and glue code that obscure how data actually flows and how components interact.

Over time, this makes systems harder to understand, harder to change, and more fragile than they need to be.

Instead of starting with code, we describe the system using a simple, domain-focused model. That model defines the data, the flow of that data, and the components that transform it. From that description, we generate the implementation using explicit, deterministic rules.

The result is a system where:

• the architecture is visible and intentional
• the implementation follows a consistent pattern
• repetitive infrastructure is generated instead of hand-written

This is not about generating code faster. It is about generating code correctly and consistently, in a way that preserves the structure of the system over time.

The techniques in this book use simple tools—YAML, Python, and Jinja2—but the goal is not the tools themselves. The goal is to move from programming at the level of syntax to designing at the level of systems.

This approach is especially relevant for embedded and systems software, where control, predictability, and long-term maintainability matter.

If you have worked on systems that became difficult to reason about as they grew, this book offers a different path.