I’ve been a huge proponent of open source and open development for years. I may not be as vocal about it as some of my peers, but I’ve always had my eye on things coming out of the open community. As networking and virtualization slowly open their processes to these open development styles, I can’t help but think about how important this will be for the future.
Eyes Looking Forward
Open development isn’t just about having multiple sets of eyes looking at code. It’s about modularizing functionality to prevent issues from impacting multiple systems. Look at what OpenStack is doing with their plugin system. Networking is a different plug in from block storage. Virtual machine management isn’t the same as object storage. The plugin idea was created to allow very smart teams to work on these pieces independently of each other. The side effect is that a bug in one of these plugins is automatically firewalled away from the rest of the system.
Open development means that the best eyes in the world are looking at what you are doing and making sure you’re doing it right. They may not catch every bug right away but they are looking. I would argue that even the most stringent code checking procedures at a closed development organization would still have the same error rate as an open project. Of course, those same procedures and closed processes would mean we would never know if there was an issue until after it was fixed.
Code of the People
Open development doesn’t necessarily mean socialism, though. Look at all the successful commercial projects that were built using OpenSSL. They charged for the IP built on a project that provide secure communication. There’s no reason other commercial companies can’t do the same. Plenty of service providers are charging for services offered on top of OpenStack. Even Windows uses BSD code in parts of its networking stack.
Open development doesn’t mean you can’t make money. It just means you can’t hold your methods hostage. If someone can find a better way to do something with your project, they will. Developers are worried that someone will “steal” code and rewrite a clone of your project. While that might be true of a mobile app or simple game, it’s far more likely that an open developer will contribute code back to your project rather than just copying it. You do take risk by opening yourself up to the world, but the benefits of that risk far outweigh any issues you might run into by closing your code base.
It may seem odd for me to be talking about development models. But as networking moves toward a background that requires more knowledge about programming it will become increasingly important for a new generation of engineers to be comfortable with programming. It’s too late for guys like me to jump on the coding bandwagon. But at the same time, we need to ensure that the future generation doesn’t try to create new networking wonders only to lock the code away somewhere and never let it be improved. There are enough apps in the app stores of the world that will never be updated past a certain revision because the developer ran out of time or patience with their coding. Instead, why not train developers that the code they write should allow for contribution and teamwork to continue. An open future in networking means not repeating the mistakes of the past. That alone will make the outcome wonderful.