A Contrarian View of Software Architecture

The presenter has spent an inordinate amount of time the past half decade across multiple companies working with very large, long-running enterprise software systems. Especially in long-running, constantly changing systems, you want the code and the software architecture to be easy to understand, relatively painless to extend or modify, and when advantageous, be simple to modernize with updated technology.

Unfortunately, the software systems he has worked on have consistently failed to satisfy these goals. Ironically enough, the judgment is that the code in these systems has been hard to understand, extend or change, and modernize because they had all adopted much of the very industry conventional wisdom about how to build large, maintainable systems.

This presentation wants to demonstrate and explain how prescriptive, layered software architecture styles like Clean or Onion Architecture can actually cause harm in larger systems. It also wants us to train our sights on how teams attempt to hide the actual persistence technology with “repository” abstractions and why this is also harmful. It wants us to shine a light on how teams fall down a trap of organizing code around business entities or data storage in ways that helps make the code in big systems hard to work with.

And of course, we are going to talk about alternatives, or at least ways to ameliorate the potential problems with prescriptive architectural approaches. In particular, this presentation shows the shift to vertical slice software architecture approaches for organizing code. It also examines ways to reduce code ceremony to improve code readability and use that to show the negative tradeoffs of using approaches like the Clean Architecture that mandate some elements of code ceremony to “force” developers into a consistent approach. And finally, we examine whether or not “consistency” should be a first class goal in code organization or architecture.

Video producer: https://ndcoslo.com/