Software Engineering, geprüft · Teil 4 von 13
Organise: you ship your org chart
In 1968, a programmer called Melvin Conway published an essay in Datamation under the title "How do committees invent?". He had offered it to the Harvard Business Review first. They turned it down; Conway later said the reason was that he hadn't proved his thesis. The thesis was one sentence: organisations which design systems "are constrained to produce designs which are copies of the communication structures of these organizations."
His example was small. A contract research organisation had eight people to write two compilers, one for COBOL and one for ALGOL. Five went to COBOL and three to ALGOL. The COBOL compiler ran in five phases; the ALGOL compiler ran in three. Seven years later, Fred Brooks quoted the essay in The Mythical Man-Month and gave the idea a name: Conway's law. Engineers have repeated it ever since, usually as "you ship your org chart", usually with a knowing look.
Brooks's book had its own law, about adding people to a late project. Both laws say the same deeper thing: software is people talking, and the talking leaves marks in the code. This part checks how deep the marks go. The question is plain: does the shape of the team decide the shape of the software?
Where does Conway's law come from?
From an essay, an anecdote and a famous book. The evidence was the compilers, and the law travelled for forty years on Brooks's authority and on the fact that it felt true to anyone who had worked in a large organisation.
The proper tests came late. Alan MacCormack, John Rusnak and Carliss Baldwin compared pairs of products that did the same job, one built by a tightly coupled organisation, typically a company, and one by a loosely coupled one, typically an open-source community. In every pair they examined, the loosely coupled organisation produced the more modular product. In the company products, the potential for a change in one component to spread to others was up to eight times greater ~70 %. In 2016, Lyra Colfer and Baldwin reviewed 142 studies of the "mirroring hypothesis" across industries. Their verdict: mirroring is a prevalent pattern, but not universal ~70 %.
The gap between "prevalent" and Conway's "constrained" is where the interesting findings are. Firms break the mirror on purpose, by drawing modular boundaries inside the company or by building close working relationships across company lines. And open collaborative projects, most of them software, did not support the hypothesis ~30 %. Colfer and Baldwin's explanation is that digital tools let open-source contributors coordinate across module boundaries, so the code doesn't need to copy who talks to whom. The org chart is a strong default, not destiny.
That complicates a fashionable idea. If designs mirror teams, the inverse Conway manoeuvre says you should design the teams first and let the architecture follow. Nobody has tested it as a team-design technique ~50 %. The evidence shows that designs follow organisations and that deliberate redesigns can change a structure. Mozilla's redesign ended up more modular than both its predecessor and Linux ~70 %. It does not show that a reorganisation reliably delivers the architecture drawn on the slide.
Who needs to talk to whom
If code mirrors communication, the reverse question is practical: what happens when the people who need to talk, because their code depends on each other, don't? Marcelo Cataldo, James Herbsleb and colleagues measured exactly that in large industrial projects. They worked out who ought to coordinate, from the dependencies between the files people changed, and compared it with who actually did. Where the two matched, work got done faster. Where they diverged, failures went up ~70 %.
It isn't a clean law. A study of a project at IBM found the link with build success only for some kinds of build, and in some situations higher congruence went with lower success. Coordination is a cost as well as a cure.
The org chart predicts the bugs
The most striking finding in this area comes from Windows Vista. Nachiappan Nagappan, Brendan Murphy and Victor Basili built models to predict which binaries would fail, using the usual code measures (churn, complexity, coverage, dependencies, pre-release bugs) and, separately, measures of the organisation that built each binary. The organisational model was significantly better than all of the code-based ones ~50 %. An industrial replication found organisational metrics useful too, but beaten by pre-release bug counts. That the org chart competes at all is the point.
Ownership is the part of it engineers recognise. Christian Bird and colleagues found that in Windows Vista and Windows 7, code with one clear owner had fewer pre-release faults and post-release failures than code touched by many low-expertise contributors, and a replication across four more Microsoft products agreed ~70 %. In open-source Java projects, though, the link was weak or absent. Ownership may matter most where the org chart is real.
Change the organisation and quality moves with it. In a large Avaya project, Audris Mockus found that code changed close to a reorganisation, or after recent departures, had more customer-reported defects; in open source, the activity of newcomers hurt quality ~70 %. Both are observational and few in number.
Distance, or headcount?
Splitting work across sites and continents was the big organisational bet of around 2000, and it produced the area's best-known number. Herbsleb and Mockus studied two organisations and found that work items split across sites took about two and a half times as long as similar items done in one place ~70 %.
The number travelled; the mechanism mostly didn't. The data pointed to a specific cause: distributed work items involved more people, and the number of people involved was strongly related to how long an item took. Herbsleb and Rebecca Grinter's earlier study, subtitled "Conway's law revisited", described the other half: coordination broke down across sites largely because the informal conversations, the corridor and the coffee machine, didn't travel between sites. Distance mattered through who talked to whom and how many people had to agree. And the tools of 2000 are not the tools of now.
The quality half of the folklore fared worse. Two Microsoft studies, of Windows Vista and Office 2010, found that distributed development made negligible or practically irrelevant difference to failures, and the Vista difference shrank further once the number of developers on a binary was accounted for ~30 %. Mockus did find lower quality from distributed work at Avaya, so it can happen. It isn't the rule. Again, headcount explained more than geography.
Aristotle against Ringelmann
If more people slow things down, how big should a team be? Two research groups have been fighting about this, with names borrowed from the history of ideas. In 1913, the agricultural engineer Max Ringelmann found that people pulling on a rope pulled less hard the more of them there were. Aristotle supplied the other side: the whole is more than the sum of its parts.
On Aristotle's side, Didier Sornette and colleagues reported that in open-source groups, doubling the group more than doubled the output, by a factor of 2.5; their paper's title is "1 ⊞ 1 = 2.5" ~30 %. On Ringelmann's side, Ingo Scholtes and colleagues found the opposite. The largest study, by Christoph Gote and colleagues, covered 201 GitHub projects with more than 100,000 developers and found a strong negative relationship between team size and individual productivity, explained by how the collaboration structure changes as teams grow ~70 %. It held when it was re-run with four different mining tools. Gote's group also showed that skipping certain data-cleaning steps produces a spurious positive relationship.
A follow-up by Thomas Maillart and Sornette offered a truce: superlinear output for up to 30–50 contributors working at once, sublinear beyond that. Then a 2024 reanalysis found that instrumentation biases, choices about how to measure, had pushed the two groups' results in opposite directions. The fight was partly about rulers. On balance, individual output falls as teams grow, with small teams a possible exception.
That is the mechanism behind Brooks's law: "adding manpower to a late software project makes it later." New people need training, and every new person adds lines of communication. Fifty years on, the law has never been tested as worded. Repository data support the mechanism, but nobody has measured late projects being delayed further by new hires ~50 %.
The ceiling is just as soft. From their study of Apache, Mockus, Roy Fielding and Herbsleb proposed that a core team coordinating informally tops out at 10–15 people. It was a hypothesis, and Mozilla's module cores were already 22–36 people, made to work with ownership, process and inspections. Most GitHub projects do keep their cores under 16 ~50 %.
Aristotle turns up a second time in this field, as Google's Project Aristotle, which concluded that psychological safety was by far the most important factor in an effective team. Google reported the ranking but never published it as a study. In a survey of 38 software teams, psychological safety did predict effectiveness, but clear team norms predicted performance and satisfaction more strongly ~50 %. Feeling safe to speak up helps. Knowing what the team expects of you helps more.
When people leave
Every team eventually tests the other end of Brooks's law: taking people away. The truck factor (or bus factor) is the number of people who would have to be hit by a truck before a project stalls. Guilherme Avelino and colleagues estimated it automatically for 133 popular GitHub projects and put 65% at two or fewer ~70 %. The estimate is rough: asked about it, the projects' developers agreed only about half the time. Engineers do take the risk seriously; in a survey of 269, the bus factor was seen as an important problem.
What is lost when someone goes is lumpier than an average suggests. Peter Rigby and colleagues simulated turnover in Chrome and an Avaya project and found the projects exposed to knowledge losses three to five times the expected loss. Naming successors reduced the expected loss by up to 15% ~70 %. Two case studies, so the size of the tail isn't general, but the shape will be familiar from part 3.
Yet losing the core is not a death sentence. Avelino's group later followed 315 popular projects that had lost their truck-factor developers; 41% survived because new people took over the maintenance ~30 %. Rigby's simulations also suggested simple truck-factor counts exaggerate the loss.
What doesn't work
- Treating Conway's law as fate. Mirroring is common in companies and largely absent in open collaborative projects, where tools let people coordinate across module lines ~30 %.
- Reorganising to get an architecture. The inverse Conway manoeuvre is plausible and untested ~50 %.
- Blaming distance for bugs. At Microsoft, distributed development made negligible difference to failures once headcount was accounted for ~30 %.
- "1 + 1 = 2.5". Superlinear team output fades beyond a few dozen contributors and was partly a measurement artefact ~30 %.
- Psychological safety as the one factor. It helps, but the famous ranking was never published, and clear norms predicted more ~50 %.
Try this
- Map dependencies to conversations. For the parts of the code that depend on each other, check that the people who change them actually talk. Where they don't, that's where the failures will be.
- Give every module an owner. Not a gatekeeper, but one person who knows it best and sees most of its changes. Watch for code touched by many people who each touch it rarely.
- Count heads before blaming time zones. If cross-site work is slow, look first at how many people each item needs to involve, and cut that.
- Be careful around reorganisations. Expect quality to dip near an organisational change or a wave of departures, and review and test those areas harder.
- Name successors. For each critical area, know who would take over, and let them work in it before they have to.
18 Behauptungen geprüft
Die Belege hinter diesem Artikel
Jede Behauptung oben, bewertet nach der Chance, dass sie der Forschung standhält. Öffne eine für die Quellen und ihren genauen Wortlaut.
- Avelino, Constantinou, Valente, Serebrenik (2019). On the abandonment and survival of open source projects: An empirical investigation · Studie
- Avelino, Passos, Hora, Valente (2016). A novel approach for estimating Truck Factors · Studie
- Bird, Nagappan, Devanbu, Gall, Murphy (2009). Does distributed development affect software quality? An empirical case study of Windows Vista · Studie
- Bird, Nagappan, Murphy, Gall, Devanbu (2011). Don't touch my code! · Studie
- Caglayan, Turhan, Bener, Habayeb, Miransky, Cialini (2015). Merits of Organizational Metrics in Defect Prediction: An Industrial Replication · Replikation
- Cataldo, Herbsleb (2013). Coordination Breakdowns and Their Impact on Development Productivity and Software Failures · Studie
- Cataldo, Wagstrom, Herbsleb, Carley (2006). Identification of coordination requirements · Studie
- Colfer, Baldwin (2016). The mirroring hypothesis: theory, evidence, and exceptions · Quelle
- Foucault, Falleri, Blanc (2014). Code ownership in open-source software · Replikation
- Foucault, Palyart, Blanc, Murphy, Falleri (2015). Impact of developer turnover on quality in open-source software · Studie
- Gote, Mavrodiev, Schweitzer, Scholtes (2022). Big data = big insights? operationalising brooks' law in a massive GitHub data set · Studie
- Greiler, Herzig, Czerwonka (2015). Code Ownership and Software Quality: A Replication Study · Replikation
- Gut, Goldman (2024). Revisiting Aristotle vs. Ringelmann: The influence of biases on measuring productivity in Open Source software development · Replikation
- Herbsleb, Grinter (1999). Splitting the organization and integrating the code: Conway's law revisited · Studie
- Herbsleb, Mockus (2003). An empirical study of speed and communication in globally distributed software development · Studie
- Hoess, Paradis, Kazman, Mauerer (2025). Oops!... I did it again. Analysing and Handling Conclusion (In-)Stability in Socio-Technical Software Engineering · Replikation
- Jabrayilzade, Evtikhiev, Tüzün, Kovalenko (2022). Bus Factor in Practice · Studie
- Kocaguneli, Zimmermann, Bird, Nagappan, Menzies (2013). Distributed development considered harmful? · Replikation
- Kwan, Schroter, Damian (2011). Does Socio-Technical Congruence Have an Effect on Software Build Success? A Study of Coordination in a Software Project · Studie
- Lenberg, Feldt (2018). Psychological safety and norm clarity in software engineering teams · Studie
- MacCormack, Baldwin, Rusnak (2012). Exploring the duality between product and organizational architectures: A test of the “mirroring” hypothesis · Studie
- MacCormack, Rusnak, Baldwin (2006). Exploring the Structure of Complex Software Designs: An Empirical Study of Open Source and Proprietary Code · Studie
- Maillart, Sornette (2019). Aristotle vs. Ringelmann: On superlinear production in open source software · Studie
- Mockus (2010). Organizational volatility and its effects on software defects · Studie
- Mockus, Fielding, Herbsleb (2002). Two case studies of open source software development · Studie
- Nagappan, Murphy, Basili (2008). The influence of organizational structure on software quality · Studie
- Rigby, Zhu, Donadelli, Mockus (2016). Quantifying and mitigating turnover-induced knowledge loss · Studie
- Sornette, Maillart, Ghezzi (2014). How Much Is the Whole Really More than the Sum of Its Parts? 1 ⊞ 1 = 2.5: Superlinear Productivity in Collective Group Actions · Studie
- Verwijs, Russo (2024). The Double-Edged Sword of Diversity: How Diversity, Conflict, and Psychological Safety Impact Software Teams · Studie
- Yamashita, McIntosh, Kamei, Hassan, Ubayashi (2015). Revisiting the applicability of the pareto principle to core development teams in open source software projects · Studie