Moishe Lettvin, a former Microsoft engineer, writes about software craftsmanship and large-company dysfunction, best known for his Windows shutdown post.
HN links his Windows shutdown post as an explanation of how bureaucracy in large organizations produces odd results like Vista's shutdown menu.
> When you use Win32 you get the latest fixes and features even in applications that haven't been updated for two decades - for example you get new common dialogs and access to shell extensions (e.g. TortoiseSvn/Git integration) that didn't exist back when those applications were made.
What you're describing is not backward compatibility, it's forward compatibility.
The OS is backward compatible with old applications that continue to run. The old applications are forward compatible with newer versions of the operating system including some of the new features that are added.
Achieving backward and forward compatibility (the combination is often called "full compatibility") is actually quite difficult. The resources Microsoft throws at this problem and the related coordination costs are massive (and conversely, the progress any individual developer sees on their particular tasks is often glacial)[0]. In the open source world, I think only web browsers typically see anything resembling a similar level of effort applied to evolving the platform while maintaining compatibility with extant (and often buggy) code, and that's still a much smaller problem (though it might not be after another decade or two), since for all intents and purposes, the web as a whole is a "rolling release" system with bugs and incompatibilities popping up and being fixed constantly.
[0] http://moishelettvin.blogspot.com/2006/11/windows-shutdown-crapfest.html
You may not have read this article before: http://moishelettvin.blogspot.com/2006/11/windows-shutdown-crapfest.html
Here's a relevant quote from the article:
In Windows, this [centralised] model breaks down simply
because there are far too many developers to access one
central repository. So Windows has a tree of
repositories: developers check in to the nodes, and
periodically the changes in the nodes are integrated up
one level in the hierarchy. At a different periodicity,
changes are integrated down the tree from the root to the
nodes. In Windows, the node I was working on was 4 levels
removed from the root. The periodicity of integration
decayed exponentially and unpredictably as you approached
the root so it ended up that it took between 1 and 3
months for my code to get to the root node, and some
multiple of that for it to reach the other nodes. It should
be noted too that the only common ancestor that my team,
the shell team, and the kernel team shared was the root.
With a distributed system, it would be possible to send changes directly between the two groups. You might have a problem keeping the whole Windows source code repository stored locally on your development machine though.
Three big problems with a split up codebase:
1) Instead of doing one large release every week (which facebook does: http://www.facebook.com/video/video.php?v=10100259101684977) you now have dozens or hundreds of smaller releases, a lot more heterogeneity to test for.
2) If you have inter-dependencies on modules you have to grapple with the "diamond dependency" problem. Say module A depends on module B and C, and suppose that module B also depends on C. However, module B depends on C v2.0 but A depends on C v1.0. If they're all split across repositories it's not possible to update a core API in an atomic commit.
3) Now you rely on changes being merged "up" to the root and then you have to merge it "down" to your project. This is one of the reasons Vista was such a slow motion train wreck: http://moishelettvin.blogspot.com/2006/11/windows-shutdown-crapfest.html -- kernel changes had to
be merged up to the root, then down to the UI, requiring months of very slow iterations to get it right.
>they are unable to conceive of a company as anything other
>than a single, gestalt entity, with a single opinion and
>purpose, whose actions are driven by the most basic
>emotions and can be classified as good or evil with
>absolutely no grey-area.
Seems like quite a straw man argument, there probably isn't a single person that actually fits your description. And it certainly does not describe a typical developer.
As infamously documented in "The Windows Shutdown Crapfest" [1], in order for anything to be publicly observed outside of most large bureaucracies, a large number of people are involved, and their only common interest comes from very high up in the bureaucracy. So you usually do end up with a single, simple ideology presented to the public, even though there are a lot of people internally fighting for different things.
[1] http://moishelettvin.blogspot.com/2006/11/windows-shutdown-crapfest.html
But some of it was just math -- a large company with many teams that need to coordinate slows things down. I like this anecdote from a Microsoft engineer about how it took a year to design a really crappy shutdown menu with nine (nine!) options.
It turns out there 43 different people who had a voice in the feature, which was hashed out over a series of grinding meetings involving teams responsible for kernel, shell, Tablet PC, Longhorn, and (drumroll please) "Windows Mobile PC User Experience"."
"In Windows, the [repository] node I was working on was 4 levels removed from the root. The periodicity of integration decayed exponentially and unpredictably as you approached the root so it ended up that it took between 1 and 3 months for my code to get to the root node, and some multiple of that for it to reach the other nodes."
http://moishelettvin.blogspot.com/2006/11/windows-shutdown-crapfest.html
Some more links of how bureaucracy inevitably creeps in as organizations get larger:
- http://moishelettvin.blogspot.com/2006/11/windows-shutdown-crapfest.html
- http://www.lizengland.com/blog/2014/04/the-door-problem/
Another famous anecdote was Google CEO Larry Page firing all of his project managers during its early startup days because he felt they just got in the way of his programmers getting things done. But his executive team convinced him to reverse his decision. Think about that, even the powerful owner of Google couldn't get rid of the layers of bureaucracy. He eventually relented.
No non-trivial project has come up with a way to coordinate a large # of programmers where the participants themselves don't complain about the bureaucracy. In other words, learn to love Jira -- because it's inevitable?!?