Home > Articles > Programming

Source Code Is Dead! Long Live Source Code!

  • Print
  • + Share This
Dhanji R. Prasanna illuminates the unseen (and often unconsidered) costs to a company of keeping its source code proprietary and closed, rather than sharing it as open source with the world.
Like this article? We recommend

I used to work at Google, a company that's entirely dependent on the source code its engineers produce for its lifeblood. And yet, Google has a rather strange attitude toward source code, giving it away like there's no tomorrow.

From various APIs and libraries to its two programming languages (DART and Go) and its flagship web browser (Chrome), Google has a multitude of high-profile open source projects. This has gained the company a lot of fans in the developer community, and has enabled real extensions and real projects that are offshoots (for example, RockMelt was a startup built on Chromium).

And yet, there's a definite tension at Google between the old guard, who believe that source code is very valuable, and the open source "evangelists," who believe that nearly all code at the company should be released as open source. Fortunately for Google (and for developers at large), its track record generally shows a willingness to share. Even in cases where Google has been reluctant to release source code (GFS, BigTable), engineers have published papers describing how others may be able to implement their own versions.

This situation mimics a tension seen at many companies—some folks (engineers) want to see their source code released in the open, and others (management) find the idea very scary. In the old days, source code was genuinely an advantage—tools such as compilers and development editors were few and far between, often jealously guarded if they did anything at all capable, and in many cases even sold as a vended product. As time progressed, having source code became less important—we have the GNU Project to thank for this change, primarily. The GNU C Compiler, Emacs, and various other free tools made it much easier for anyone to produce and release their own tools. Fantastic purpose-driven tools like Python and the Apache web server expanded and democratized the landscape enormously.

Open Software vs. Product

While the first great battle of using open-source software at companies has largely been won, there is still a latent hesitance about promoting or sponsoring open source internally. The old reluctance of releasing tools and scripts largely melted away, but was replaced with a similar reluctance toward releasing libraries. Libraries are the modern equivalent of the aforementioned tools. They're developed in-house for all kinds of interesting and useful purposes: parsing and converting formats, sophisticated caching, interfacing with legacy systems, data storage, and so on.

Furthermore, many shops have a pervasive sense that spending time on open source software is somehow a distraction, or even a waste of time: "Why build something our competitors could use?" I believe that at the heart of this fear lies a basic misunderstanding of the economy of software. Software as it stands has little intrinsic value—the product in which the software is packaged has the real value. And that includes everything from the brand name to customer support and interface usability.

In this economic sense, the distinction goes beyond apps and libraries. It speaks to the distinction between a product (an intangible packaging of customer desires being met) and the underlying software (the ever-depreciating package of source code). Apple's WebKit project is a good example of such a system. As consumer software, the WebKit engine isn't particularly useful or user-friendly. It's the packaged product, Safari, that really shines. Features like multiple tabs, extensions, and download managers all originated to fulfill customer desires, while the workhorse that rendered web pages was freely given away and developed in the open, where contributions were democratically accepted.

The WebKit engine actually began life as a fork of KHTML, which was an open source rendering engine started under the Konqueror web browser. When Safari began, it was able to take advantage of the good work already done in the open by KHTML. The trail of growth is long, pyramidal, and thoroughly full of value to all involved.

Catalysis

One of the most powerful catalysts for new startups is the incredible availability of open source libraries. A startup working in Java today can pick from a range of 10[nd]15 different high-quality libraries for common tasks such as HTTP serving, and often between 4[nd]5 libraries for uncommon, high-barrier-to-entry requirements such as full-text search or image processing. They can move much faster than traditional companies that have any part of their stack using legacy, closed-source code. This is a subtle point, but it enhances the traditional cliché about startups and agility:

Sure, startups move faster because they start from a completely clean slate, but nowadays they also start farther ahead. It used to be that the amassing of code over time gave incumbents the advantage—if a new project at Google needs to store data sharded across a thousand machines, the obvious choice would be BigTable, which was developed to store crawled web pages. But this advantage is no longer clear; a startup with similar sharding needs can choose between MongoDB, CouchDB, Cassandra, HBase, and a multitude of others. All these projects came into existence well after BigTable, learned much from it, and have advanced beyond it in many ways. By not releasing BigTable as open source, Google made it impossible to advance BigTable at the speed and level of sophistication that open source has made possible for these other projects.

Google presumably has only the choice of BigTable; and any new storage needs must be met by either by retrofitting it (as in the case of Megastore) or by creating something completely new—an exercise that could take months of preparatory effort (as in the case of the Colossus File System, and its older counterpart, GFS).

Meanwhile, a startup can choose MongoDB for fast-write, low-reliability needs (for instance, storing "check-ins" à la Foursquare); VoltDB for reliable, durable storage (bank details, credit card info, and so on); and HBase for someone who is adamant about running a pure Java data store. All of these systems satisfy the sharded data requirement, and a single person can set up and administer them. In fact, a single person can run all of them simultaneously, coordinated by the same application that faces users. This is a zero-to-sixty and a kind of flexibility that has never before been seen in the world of software engineering.

If companies continue to prize innovative but non-critical parts of their software stack by keeping them closed, they'll make it increasingly difficult to stay competitive in this open-catalyzed world. I don't mean to single out Google; as I said at the beginning of this article, they're better than most other companies with regard to this issue. However, they're still far behind the eight ball, as things stand.

The artful trick lies in distinguishing code from product. For Google, the search engine is the product. In other words, its web page ranking and spam controls meet and serve the desires of its users, and this is what is legitimately guarded as a competitive advantage. Everything else is collecting rust, in my opinion, so long as it remains behind closed doors.

Conclusion

Some readers might walk away from this article thinking that I advocate the opening of all source code, and that this is tantamount to the advocacy of the Free Software Movement. This isn't exactly the case. Certainly, I've put forth the case for a majority—and, in some cases, all—of source code to be open if companies want to thrive in the long term. But apart from the caveats of competitive advantage, there's also the caveat of noise. Not all source code is of equal quality. Sometimes replacement of legacy systems requires writing duplicate code, and sometimes performance demands the same thing. Also, simply releasing code for the sake of making it open isn't particularly helpful. If your team isn't committed to working in the open, regularly maintaining the code and building a healthy, engaged community, there's very little point in open source.

Finally, we can come full circle and learn a lesson from two very divergent ideas of "open" at Google itself:

  • Google Wave was developed in secret, closely adhered to internal libraries, and then bits and pieces were released as open source because of a promise made. Much of the software stack had to be rewritten to be released as open; and, as you might expect, it wasn't rewritten with the same attention to quality, performance, or scalability. When priorities changed, and the project was under pressure, the open source component was the first to be cut, and the team recycled to higher-priority tasks.
  • On the other hand, Chrome is a project that thrives on being open. At its heart is WebKit, which, as I mentioned previously, has a long history in the open source world. Chromium.org is an active, vibrant project with a deeply engaged community that actively reports bugs and provides patches. Except for a short period when the Chrome project was being bootstrapped in secret, it has always been in the open and continues to be so. All its affiliated projects (Chromium OS, Chrome Frame) are similarly open and enjoy the same level of respect and engagement from the community as does the original. Sure, being a desktop application, Chrome never had the closed-source encumbrance that Wave had—but it took real effort, dedication, and an overriding commitment to the value of open source and open community, from which Chrome never wavered.

Rather than thinking about open source as a short-term cost, distracting from your project's immediate priorities, I encourage you to think in the long term. What cost are you placing on your project's and your company's future by keeping even a part of your software stack closed?

  • + Share This
  • 🔖 Save To Your Account