The Architecture of Complex Systems
These are some notes and comments on the MIT Sloan School of Management Working Paper: The Architecture of Complex Systems: Do Core-periphery Structures Dominate?
The paper sets out to investigate common structural features of several open source applications and how these structures evolve over time. 1 286 releases of 19 different applications have been investigated and the most interesting conclusions drawn are:
1. … we find evidence that variations in system structure can be explained, in part, by the different models of development used to develop systems. That is, product structures “mirror” the structure of their parent organizations (Henderson and Clark, 1990). This result is consistent with work that argues designs (including Dominant Designs) are not necessarily optimal technical solutions to customer requirements, but rather are driven more by social and political processes operating within firms and across industries (Noble, 1984; David, 1985; Tushman and Rosenkopf, 1992; Tushman and Murmann,
1998; Garud et al, 2002).
2. Our findings highlight the cognitive difficulties that face a system architect. In particular, we find no discernible pattern of direct dependencies that can reliably predict whether a system has a core, and if it does, how large it is. In essence, system structure is driven to a large extent by the indirect dependencies between components, which are much harder for an analyst to understand.
It would be very interesting to extend on this work and to investigate business applications/systems rather than Operating Systems, Databases and Desktop applications.
It would also be interesting to see if the same results can be obtained when looking at Java/JEE software rather than applications written in C/C++. The reason I think we need updated numbers is because software development has taken a few important steps forward lately.
A huge problem with C/C++ (manually handling memory) has been removed in languages like Java and C#. However, early (2000-2005) Java/JEE applications are likely equally complex as earlier systems because of the accidental complexity of EJB 1.x and 2.x. Also, the rise of dynamic languages (2007-) such as Python and no-nonsense frameworks such as Ruby on Rails have further reduced the amount of code necessary to implement a system.
So, even though the study is very interesting it is sad that it doesn’t investigate the current state of art. If anyone knows of such a study, please let me know. It would be very interesting to see if we’ve moved forward since 2002.
On average, professional coders make 100 to 150 errors in every thousand lines of code they write, according to a multi year study of 13,000 programs by Humphrey of Carnegie Mellon.
- Why Software is so Bad -Technology Review July/August 2002
