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/
Consider these dependencies between the components of a system.
Messy, right?
4/
Now, let’s change the layout a little.
What do you know? We get to see (less strict) layers.
5/
And if we trim the dependencies to only focus on the internal components and show only the direct external dependencies, the mess gets a lot cleaner.
6/
Now, if we go a step further and connect the graph with documentation in an interactive environment, we transform the “mess” into an exciting opportunity.
(These are actually the dependencies of #gtoolkit as shown in the live documentation)
7/
In this little experiment is that we did not change the system, yet the problem moved from apparently messy to interesting. This shows that messy/clean is not property of the system alone, but both of the system and of how we look at the system.
Of course, how the system is constructed matters a great deal and monolith vs microservices is a useful conversation. But, that conversation is not about messiness. It’s about other issues such as scalability or team organization.
9/
If it’s the evaluation of mess you are interested in, revisit how you look at the system.
That might sound like an investment. That’s because it is. And is one you should start making right away.
“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/