A while back, I asked “what is architecture?” and I got many responses within just one day. Some serious, some more (bitter-sweet) joking. We can identify some cluster of responses, but even so, there are certainly a dozen distinct perspectives.
That there are many perspectives is not a surprise given that the literature is full with competing definitions. For example, it's not atypical for architecture books to say something like: “there exists many definitions, so here is ours”.
The search for the perfect definition of architecture captured the imagination of several generations by now, yet it still seems to remain elusive. But, what if it’s Ok to have many of them?
It's decision making all the way down. Or up. Given that this is what occupies largest chunk of our energy, perhaps it is worthwhile to regard software engineering as being primarily a decision making activity rather than a construction one.
It is also interesting to observe how because we are so focused on the construction part, it's now ridiculously cheap to create new code. At the same time, we are unable to recycle existing systems.
It is imperative to optimize how we reason about our own systems, too.
Back to architecture (you see, I promised). Instead of focusing on architecture and architects, we can simply focus on the properties we want our systems to have.
The time spent on code reading is not distinguishable from what is considered as architecture time. Developers are architects, and whatever architecture is, it is the result of a negotiation that perpetuates with every commit.
People might disagree with the above assertion and emphasize that architecture captures the important parts. This view begs the question of what is not important, and also when.
11/
Indeed, a system can have a gazillion details, and most of those details will not be relevant for most decisions. At the sane time, most of those details will be relevant for at least one decision.
12/
If you only prepare yourself to decide about some parts, you will not be prepared to react to issues in the rest of the parts. So, rather than debating what is important and what is not, what if we equip ourselves to deal with any detail instead?
13/
Architecture is an emergent property that results from daily, often minuscule and implicit interactions. You cannot control the result, but you can orchestrate the interactions. The process should host the negotiation explicitly.
Through daily assessment:
- A stakeholder identifies a concern.
- A facilitator creates a tool to capture the concern.
- The data together with the proposal of how to address the concern are presented to the team.
...
15/
- Anyone can challenge.
- If the team agrees, it takes action.
- The conversation only happens if there is data.
- If the conversation lasts for more than 5 minutes, it's stopped because the data is not clear enough
Most often, this leads to decisions within minutes.
16/
When talking about architecture, people often think of the construction part. Daily assessment is about knowing where you are at all times and being able to react and adjust. It's not a replacement for design. It's complementary.
Some people ask how is this different from a typical standup. A typical standup is focused on synchronization, and it mostly talks about what's on the board, which is functionality. It's rarely about technical parts and it's almost never about decisions.
18/
Daily assessment empowers the team to make the conflicts in code explicit. It does rely on the technical ability of creating architectural checks and visualizations quickly, but the emphasis is on how the team can make and execute technical decisions as a group.
19/
What concerns are allowed? Any concern. From how a function is named to how the global dependencies are organized. A concern is valid as long as there is an interested stakeholder. Who can be a stakeholder? Anyone that has a stake in the system. Yes, developers too.
20/
Is this not wasteful? On the contrary. All details are important at some point. It does not matter how trivial it might appear, it's more important to exercise the collective muscle of grasping the probelm and correcting it. The best way to build muscle is to train daily.
21/
Daily assessment relies on the two #MoldableDevelopment roles:
- the stakeholder owns the problem and the decision, and
- the facilitator molds dedicated tools.
Of these, it is the stakeholder role that is the hardest to train.
22/
• • •
Missing some Tweet in this thread? You can try to
force a refresh
By now there is plenty of evidence that both architectures can lead to a “mess”. This only shows that we should not look at these as mechanisms for controlling the said mess” in the first place.
Well, as long as it’s people building the system, of course it’s the people. But, saying that does not get us closer to figuring a way forward though.
2/
Now, what exactly does “mess” mean? The famous spaghetti code?
Mess tends to assume that there is a clean way. And by clean, people typically mean easy to understand and change.
3/
“Developers spend most of their time figuring the system out."
Let’s dissect this a little.
🧵
1/
The oldest reference on the topic I know of dates back to 1979:
Zelkowitz, Shaw, and Gannon. Principles of software engineering and design. Prentice-Hall Englewood Cliffs, 1979.
2/
It said that most of the development time was spent on maintenance (67% in the book).
Granted, the book does not specify how the figure was obtained. Still, it was deemed an important enough problem to attract significant research attention since then.
This is how the software environmentalism crisis looks like. An explanatory thread. 1/
In the software development industry, we focus exclusively on building systems. The conversations are dominated by new languages, new frameworks, new deployment options. And the body of software grows exponentially. At the same time, we are unable to remove old systems. 2/
From this perspective, our software industry behave not unlike the plastic industry: we focus on building without any regards to recyclability. That is not sustainable. And, given the breadth of software’s reach, it is not responsible either. 3/