Rethinking Software Architecture: Beyond Clean and Onion Models

Challenging Conventional Wisdom in Software Architecture

In a realm where best practices are often regarded as inviolable truths, it's refreshing to encounter perspectives that challenge the status quo. Jerry Miller, a seasoned software architect and open source developer, offers a contrarian viewpoint that questions some of the most lauded architectural frameworks in software development. With extensive experience in .NET and as the creator of StructureMap, Miller brings a wealth of practical insights into the pitfalls of conventional software architecture practices.

The Problem with Layered Architecture

Over the last decade, Miller has observed troubling trends in large, long-running systems. These systems, initially crafted with the best architectural intentions, have become unwieldy. Code is hard to follow, upgrades are daunting, performance is compromised, and the tightly-knit logic of business requirements becomes obscured by sprawling codebases. Despite starting with a solid plan and adhering to widely accepted architectural patterns like Hexagonal, Clean, and Onion architectures, these systems often end up as high-friction, difficult-to-maintain monoliths.

The Illusion of Flexibility

A common justification for adopting layered architectures is the supposed ease of upgrading or swapping out components, such as database engines. However, Miller argues that in reality, the vast horizontal spread of these layers makes it practically impossible to undertake significant upgrades without a prohibitive amount of regression testing. The theoretical flexibility offered by these architectures rarely translates into real-world adaptability.

Advocating for Vertical Slice Architecture

In contrast to the horizontal layering approach, Miller champions a vertical slice architecture. This model emphasizes organizing code around cohesive features rather than technical layers. By doing so, it becomes feasible to upgrade or modify one feature at a time, making the system more adaptable and easier to maintain. Moreover, vertical slicing aligns more naturally with how developers think about and work on software, focusing on use cases rather than abstract technical layers.

Integration-Friendly Technologies

Miller also stresses the importance of choosing technologies that are friendly to integration testing. By leveraging tools that simplify the inclusion of real components in tests, developers can reduce the complexity of their systems. This approach allows for a more straightforward and effective testing strategy that doesn't rely on elaborate abstractions or mocks.

Rethinking Database Abstractions

One of the sacred cows of software architecture is the abstraction of databases, often seen as a necessity for testability and flexibility. Miller challenges this notion, arguing that in many cases, database abstractions can lead to performance issues and complicate code unnecessarily. Instead, he advocates for keeping infrastructure concerns out of business logic without automatically resorting to traditional abstraction layers.

The Importance of Adaptation and Iteration

At the heart of Miller's philosophy is the belief that the key to high-quality software lies in the ability to adapt and iterate. Effective test automation, low ceremony code, and a focus on keeping closely related code together are all critical components of this approach. By fostering an environment where iteration is not only possible but encouraged, developers can build systems that are both maintainable and adaptable.

Conclusion

Jerry Miller's critique of conventional software architecture practices serves as a valuable reminder that there is no one-size-fits-all solution in software development. By questioning established norms and advocating for approaches that prioritize adaptability, maintainability, and real-world usability, Miller offers a compelling alternative perspective for developers and architects alike. As the software development landscape continues to evolve, embracing flexibility and questioning the status quo will be crucial for building effective, resilient systems.

Watch the original talk here.