What is Emergent about Emergent Architecture?

“The best architectures, requirements, and designs emerge from self-organizing teams.” – Principles behind the Agile Manifesto

I follow in the footsteps of so many people who have long wondered at the meanings of such simple words, as though they were dogma from on high. Emerge? Self-organizing? Profound, to be sure. But what do we really make of this sentence?

First let me throw water on that whole dogma thing. The whole point to the Agile Manifesto and its Principles is to be less dogmatic about how we build good software. So I don’t really care what the esteemed crafters of this bite-size morsel of profundity actually meant by emerge and self-organizing.

Instead, what I do really care about is how to help our organizations achieve their goals – especially how to be more agile. Building great software is part of this story to be sure. And as it happens, emergence and self-organization are fundamental principles that can move us forward, especially now that so many enterprises are struggling with digital transformation.

The Notion of Emergence Emerges

Let’s start with the surprisingly multifaceted definition of the word emergence, and its verb form, to emerge. The dictionary defines emerge as to come into being through evolution; to rise from, come out into view. So right off the bat we have several related concepts.

Perhaps emergent refers to coming into being, as in going from not existing to existing.

Or maybe to emerge means to evolve, as in going from a less mature or advanced state to a more mature or advanced state, as opposed to being static.

Then there’s the notion of coming out into view, as in going from hidden to visible. It was always there, but emerged from the shadows.

But there are other senses of emergence that the dictionary definition doesn’t quite capture. For instance, the notion of being assembled piecemeal. The photo on a jigsaw puzzle emerges as we put it together.

And then there’s a sense of emergence popular in discussions of emergent architecture: the notion of unintentional. In other words, there is a spectrum between emergent architectures on one hand and intentional ones on the other, where intentional architectures are essentially pre-planned and on purpose, while emergent architectures are somehow accidental.

In spite of all these subtle differences in meaning, what most people are apparently trying to say when they use emergent in the context of architecture or design is: by deferring important architectural and design decisions until the last responsible moment, you can prevent unnecessary complexity from undermining your software projects (a quote I found on IBM DeveloperWorks, but if you know who actually said this first, please fill us all in by commenting).

This software-building principle thus introduces yet another notion into the mix: the concept of deferred. Human decision making is responsible for driving architecture and design, so such architecture and design emerges simply by virtue of the fact that we don’t make up our minds about any of it until we have to.

Then perhaps it comes into view, or evolves, or comes into being. And while such decision making would clearly be intentional, at least it wasn’t intentional at the beginning of the effort, in the sense that the team didn’t pre-plan anything.

The Elephant in the Room Emerges

All of the subtle variations in definition above miss one important element: the role of self-organization. Sure, people would generally prefer to organize themselves than to have someone else do it for them, so perhaps a self-organized team might be more productive or more collaborative than a team that a manager organized for them.

However, if you’ve read some of my recent articles on self-organization – or my book The Agile Architecture Revolution for that matter – you’ll recognize a bigger picture here: emergent in the context of complex adaptive systems (CAS).

In this context, an emergent property of a CAS is a property of the system as a whole that isn’t a property of any of the sub-systems of that system.

Self-organization is one of the primary driving forces behind complex systems. Natural systems from beehives to galaxies all have self-organizing subsystems. Perhaps the original Agilists were thinking about this sense of emergence when they wrote the sentence at the top of this Cortex.

Or perhaps not. But regardless of whether the original Agilists were thinking of CAS or not, many people over the last 15 years since the Manifesto appeared have made this association, for better or worse.

On the surface the appeal of emergent design or architecture being the sort of emergence that complex systems exhibit is tantalizing, as though emergence were some kind of secret magic. All we need to do is have our teams self-organize, and behold! Emergent design and/or architecture springs up out of the nothingness!

If only it were that easy, right?

Unfortunately, making this jump from emergent-as-deferred-and-evolving to emergent-as-property-of-CAS has serious issues. First of all, in the CAS context, emergence applies to the properties of complex systems. In the case of a software team working on some software effort, it’s not clear where the complex system is, let alone what properties it has.

Furthermore, it’s a stretch to think of architecture or design as a single property of a system. Perhaps they represent a collection of properties of a software system – scalability, performance, and what not – but architecture represents more than simply the properties of a system. How one component talks to another could be thought of as an element of an architecture, but not a property in the way that scalability is a property of a system.

And in any case, there’s no general reason to consider software systems to be complex systems, as the properties of their architecture or design are manifest in their components. Even when a property of a software system is a property of the system as a whole, it may still very well be a property of the components of that system – and thus it isn’t an emergent property.

Recognizing a Complex Adaptive System

Here’s how I like to think of emergence in the context of complex systems: if you look too closely at a CAS, you can’t see the emergent properties. Instead, you must step back – sometimes way back – and look at the big picture of the system as a whole to see its emergent properties. In other words, the pattern emerges from the big picture.

If you study the behavior of individual bees you’ll never see the structure of the hive. If you look at individual stars you’ll never see the shape of the galaxy. If you examine water molecules you’ll never know what it means to be wet.

When we think about the sorts of software systems that self-organizing teams can build – that is, the two-pizza teams that the Agile world favors – we’re simply not stepping far enough away from the component level to get any sense of emergent properties.

Bottom line: it doesn’t matter how self-organized individual teams are, there won’t be anything particularly emergent about the software design or architecture they produce, in the CAS sense of emergence.

Now, don’t throw up your hands and conclude that I’m missing the point of the sentence at the top of this article entirely. In fact, I’m pointing out a subtle but critical aspect of the entire Agile Manifesto. It’s not really about software at all – or at least, not just about software.

The Agile Manifesto is in reality about people and how people interact with software. How developers in collaboration with stakeholders create it and ensure it meets the ongoing needs of the organization.

However, even if we look at the self-organizing teams themselves plus the software they create, we’re still too close to see any emergent properties. We must step away and look at the organization as a whole.

Just how big the organization must be is rather slippery to define. It may be the entire company or perhaps a large division or business unit. Large enough, however, for emergent properties to manifest themselves.

The Intellyx Take

When we look at our enterprise as a whole, we may note several emergent properties, both positive and negative. We’re not likely, however, to see an emergent design or architecture for the enterprise – at least, not without stretching our definitions for those terms well beyond their usual application.

In my opinion, however, it doesn’t matter that neither design nor architecture emerges. Instead, I see architecture as a set of intentional acts that seek to influence the organization to exhibit desirable emergent properties, of which business agility is the most important.

I like to call this approach Agile Architecture, a reinvention of enterprise architecture that influences the behavior of human and technology subsystems in an organization to shift its emergent behavior toward business agility. But business agility is the property that emerges, not the architecture.

Intellyx advises companies on their digital transformation initiatives and helps vendors communicate their agility stories. As of the time of writing, none of the organizations mentioned in this article are Intellyx customers. Image credit: Hubble Heritage.