Building Evolutionary Architectures
Support Constant Change
Neal Ford, Rebecca Parsons, Patrick Kua
Paperback, Kindle, ePub
Publisher:O'Reilly Media Inc
For a variety of reasons, parts of software systems defy change, becoming more brittle and intractable over time. However, the world we inhabit has exactly the opposite characteristic. Business constantly changes, but so does the software development ecosystem. New tools, techniques, approaches, and frameworks constantly impact that equilibrium in unanticipatable ways. While this creates a headache for brittle systems, it also provides the ultimate solution. Over the last few years, incremental developments in core engineering practices for software development created the foundations for us to rethink how architecture changes over time, along with ways to protect important architectural characteristics as it evolves. This book ties those parts together with a new way to think about architecture and time.
Along the way, we also answer the questions How is long term planning possible when everything changes all the time? and Once I've built an architecture, how can I prevent it from gradually degrading over time?.
This book is about evolutionary architectures, building systems that allow architects and developers to make sweeping changes to the most important parts of their systems with confidence. It covers practices that allow developers to build continual architectures, which evolve cleanly without the need for a crystal ball.
An evolutionary architecture supports guided, incremental change across multiple dimensions.
Our book consists of three parts, reflecting each portion of the definition.
Incremental change relies on continuous delivery practices like deployment pipelines, mature DevOps, good testing culture, and other current agile engineering best practices. When combined with a granular, modular architecture, incremental change allows developers to make small modifications at the architectural level without breaking unrelated pieces. Incremental change is the machinery that enables evolutionary architectures to evolve.
Architects commonly focus on a narrow dimension of a software project, the technical architecture: frameworks, dependencies, integration architecture, and so on. But real software projects contain numerous orthogonal concerns: data architecture, security, scalability, testability, and a host of others. Modern architectures that support evolution must accommodate all these important dimensions of architecture--continuously.
When building an evolutionary architecture, architects must consider each dimension affected. For example, it isn't useful to build an evolvable technical architecture with an intractable data schema, or evolve in a way that harms security.
Evolutionary architecture allows different parts of the system to evolve in the ways most sensible to solve a problem. However, we don't want the system to evolve in a way that harms some architectural dimension. For example, improving performance with caching might accidentally harm security in the process. How can we build guidelines within the architecture to support change but guard specific characteristics?
An architectural fitness function provides an objective integrity assessment of some architectural characteristic(s).
Fitness functions employ a wide variety of implementation mechanisms: tests, metrics, monitoring, logging, and so on, to protect one or more architectural dimensions. We define a variety of categories of fitness functions: triggered versus continual, atomic versus holistic, and a variety of others.
When we identify a dimension in architecture affected by change, we define fitness functions to protect against undesirable breakage.
We offer a new perspective on evolving architecture, making "evolvability" a first-class "-ility" in software projects. We provide a logical framework for identifying and protecting parts of the architecture that evolve: identify the important dimensions, define fitness functions to ensure compliance, and use incremental change engineering practices such as deployment pipelines to automatically verify fitness.
The concepts of evolutionary architecture also help automate previously underserved constituents ("non-functional requirements") by providing a framework for identifying important dimensions, with their critical characteristics, and the mechanism (via fitness functions) for verifying the veracity of those attributes continually. This in turn allows architects to build systems that support ongoing change with confidence that important qualities won't degrade. Identification of architecture dimension and fitness function occurs at both project inception and as an ongoing concern, building continual architecture.
This book is packed with nomenclatures and deliberate practices that will significantly benefit anyone in the role of an architect. Wish I had this in my hands decades ago, glad its here now.
--Dr. Venkat Subramaniam, award winning author and founder of Agile Developer, Inc.
Software development has changed in recent years, from long release cycles characterised by up-front planning, to the development of software in small valuable increments that deliver value quickly, allowing changes in direction in response to the experience gained from early delivery. In this book, Neal, Rebecca and Pat draw on their extensive experience to explain how to create architectures that can enable constant change, by evolving throughout the lifetime of the system. It is a valuable guide for any software architect who needs to support the rapid delivery of valuable software.
--Eoin Woods, Endava
The timely "Building Evolutionary Architectures" sits at the intersection of two key trends in the software industry. At one hand software engineers face increasing demand for delivery and quality at 'Internet' pace and scale. The only way to address this is to build evolving architectures. We do not have all the answers at the beginning, nor do we have time to find all the answers. At the same time, the role of the software architect is changing. They are increasingly becoming hands on members of highly effective product teams, instead of a separate group making the 'big decisions'. The book not only addresses these points, but is also full of pragmatic and insightful advice. A great read for all software engineers and architects.