Deterministic System Design: From Subjectivity to Derivation
This article challenges the subjectivity in software engineering and system design, advocating for a deterministic approach over subjective measurements. It introduces "Architecture Synthesis," a procedure to derive system architectures from service-level objectives using fixed rules, thereby removing personal judgment from design decisions. The author argues that this deterministic method, which can even be applied by AI agents, leads to verifiable and reproducible architectural outcomes.
Read original on Dev.to #architectureThe article critiques the prevalent subjectivity in software engineering, where terms like "readability" and "best practices" lack verifiable definitions and objective metrics. It highlights a common pitfall: equating objectivity with measurement, and instead proposes that determinism, achieved through fixed procedures, is the true path to objective and reproducible design decisions.
The Shift from Measurement to Derivation
Initially, the author sought measurable criteria to assess coding decisions, proposing five key areas: mental overhead, business/technical ratio, design impact, reliability, and complexity. While these criteria offer defensible comparisons, they still suffered from an inherent subjectivity in their selection and application. The critical realization was that objectivity isn't about numbers, but about reproducible derivations—a process where multiple individuals (or machines) starting with the same inputs and rules arrive at the same conclusion, eliminating personal taste.
Deterministic Design Principle
Instead of aiming to 'measure' the goodness of a design, focus on establishing a 'procedure' that deterministically 'derives' the design from a given set of requirements. This ensures reproducibility and reduces reliance on subjective judgment.
Architecture Synthesis: A Deterministic Procedure
The core of the proposed solution is Architecture Synthesis, a procedure that takes a system's service-level objectives (SLOs) such as latency, availability, consistency, and load, and applies a fixed set of rules to derive an architecture. This includes determining deployment units, data placement, consistency models, and failure handling mechanisms. The key benefit is that the outcome is a direct consequence of the inputs and rules, rather than a subjective choice. This method concentrates human judgment into two critical areas: defining the initial criteria and rules and establishing accurate business requirements.
- Input Requirements: Service-level objectives (latency, availability, consistency, load).
- Fixed Rules: Procedures for deployment, data location, consistency, failure handling.
- Derived Output: A concrete system architecture.
- Verifiability: The procedure's output can be checked against existing systems or real-world behavior, with failures indicating issues in business requirements or rule definitions, not subjective technical choices.
The article strikingly notes that a procedure deterministic enough for humans to learn quickly is also one a machine can execute. The author successfully tested this by using AI agents to derive architectures for well-known systems (e.g., Stack Overflow, Shopify) from their public commitments, demonstrating the method's machine-applicability and reinforcing its objectivity. This highlights the growing convergence of deterministic design principles with AI capabilities in automating architectural decision-making.