Could open source build a jetliner? | Opensource.com
Could open source build a jetliner?
I know this might sound like an odd question. It first came up in a conversation I had with Gary Hamel, the eminent business thinker and one of the first people to recognize the importance of distributed co-creation and that it will change management in the 21st century. We were discussing how the power of participation could replace traditional management for purposes of coordination and what it's limits might be. We ended up using the analogy of building a jetliner as our best example of where tight coordination is required. This question has been nagging on my mind ever since.
Airplanes are truly modern marvels of tight coordination on a massive scale. A well designed airplane is the result of tens of thousands of small design tradeoffs that are perfectly balanced and tightly managed. The end product is an engineering marvel that is a modern jetliner.
Design to manufacturing introduces a myriad of new coordination challenges. Hundreds of thousands of components must come together with minute tolerances. Indeed, the design and manufacture of an airplane represents the pinnacle of what modern top-down coordination can produce.
Which brings me back to the question. Can a bottoms-up, participative system develop something as complex as a jetliner, considering it requires such close coordination amongst the various parts? The more I think about it, my answer is both no and yes. Here's my thinking and I would very much like to hear your thoughts.
My knee-jerk answer to Gary was no. That's not what participative systems are good at. Upon further reflection, I would more clearly say, "In the very short term and in the strictest sense of the question, my answer is no." While open source has shown an amazing ability to develop highly complex systems, it's power is the distributed nature of the innovation process. Look no further than Linux.
Think about how Linux is created. Those closest to individual components are able to drive optimized solutions to those problems. In these self-emergent systems, the underlying detail and complexity of the components can be far beyond anything a top-down, centrally planned system can muster. However, if those components must be tightly coordinated to work together, I'm not sure participative systems have a way to do that.
The more I thought about the problem, the more I realized that IT'S THE WRONG QUESTION. It is asking whether a participative system stuck into the middle of a traditional command-and-control ecosystem, can outperform it. And to that question, I still say no. The right question to ask is, "Could an open ecosystem in aviation produce a superior aircraft over time?" And to that question, my answer is "yes."
The power of participative systems in the bottoms-up innovation comes from having those closest to the problems involved in solving them. Linux is successful not because Linus Torvalds specified his requirements for each component, but rather because he did not. He allowed others, with different skills and expertise to drive the various components of the system, and ultimately the whole has benefited. If the various parties involved in the myriad components of aviation were allowed to drive their own designs forward, would the benefits of the individual components being superior offset the fact that they are not as tightly optimized to work together?
Let's again look at x86 and Linux as an analogy. For many years, tightly coupled RISC/Unix systems represented the ultimate in computing performance. They dominated high-end computing. Today, the performance mantle has moved to x86 and Linux. Red Hat Enterprise Linux alone, runs over half the world's equity trading volume—and those are systems bought for performance, not price. Why?
Simply, no single engineered system can keep up with the mass of innovation that is happening in an open system. Intel can drive it's microprocessor roadmap without worrying about "breaking" applications that are tightly joined to hardware. Application vendors can drive their own roadmaps without worrying about optimizing it for hardware. And Linux operates at its own pace. Each of these systems have innovated faster because they are not encumbered with the need to coordinate across the entire system. And together, open systems based on x86 and Linux now represent the gold standard for performance in computing.
What is the lesson learned from our experience with Linux and the jetliner question? An open system could not create the tightly coupled, highly coordinated system that is a RISC/Unix computer. Instead, it created something better, faster, and cheaper. Why would aviation be any different?