In February 2009, I enjoyed the privilege of attending a lecture series by Dr. Richard Stallman, founder of the free software movement, and main author of the GNU General Public License – a copyleft free software license. With his lectures still fresh in my mind, I would like to wrestle with a lingering question, for which I have not yet found a satisfying answer.
A backgrounder on the free software movement
Understand, first of all, that the free software movement aims not to abolish the sale of software, but to to protect a person’s freedom to use, inspect, modify, and share software. As they say: free, as in speech, not free, as in beer. In order for a piece of software to conform to the free software foundation’s definition of free, its license must grant users of the software the following four freedoms:
- The freedom to run the program, for any purpose (freedom 0).
- The freedom to study how the program works, and adapt it to your needs (freedom 1). Access to the source code is a precondition for this.
- The freedom to redistribute copies so you can help your neighbor (freedom 2).
- The freedom to improve the program, and release your improvements (and modified versions in general) to the public, so that the whole community benefits (freedom 3). Access to the source code is a precondition for this.
Source: “The Free Software Definition”
The GNU GPL goes one step further to say that any time you redistribute software that is derivative or comprehensive of free software, your software must be redistributed under a GPL-compatible license. It is this share-alike provision and its implication for software based on interpreted programming languages like Javascript, whose usefulness is only truly realized when the source code is distributed over a network and executed on a client computer, that forms the subject of this essay.
When use means use, and distribution means distribution
The share-alike provision of the GNU GPL is designed to prevent middlemen from stripping away any of the four freedoms from free software, on its way to the end user. To be clear, a person is free to build a piece of software atop someone else’s GPL code, and to use that software to conduct business activity for profit; this would constitute the exercising of freedoms 0 and 1 – the freedom to run a program, for any purpose, and the freedom to adapt it to their needs. To subsequently exercise freedoms 2 and 3 is purely optional, but if the user chose to exercise their freedom to distribute copies of their modified software, and distributed those copies under a license that restricts any of the four freedoms that they themselves were treated to, they would be in violation of the GNU GPL’s share-alike provision.
When use and distribution go hand in hand
Considering the scenario I’ve just mentioned, what if the software in question is written in an interpreted language like Javascript, and built atop GNU GPL licensed Javascript code? Further, what if the person’s business is the provision of a web application – a type of application which, by virtue of its architecture, requires that Javascript source code travel over-the-wire to be executed on the client side, in order for the web application to be usable? Is the business owner exercising freedom 0, to run free software for any purpose, or do we say that she has exercised freedom 3, to distribute a modified copy of the software – her modifications now being subject to the share-alike provision of the GNU GPL?
Intent only to use
One might say that the business owner’s intent was to exercise freedoms 0 and 1 exclusively. The business owner may think of herself as the sole end user of the Javascript software – software that they use to provide a service to their customers over the Internet. Said service might be a dating service, or perhaps a service for ordering pizza delivery.
De facto, though, the distribution is
Whatever the business owner’s intent, the fact is that the architecture of a Javascript-based web application requires Javascript source code to be distributed over-the-wire in order for it to be useful; de facto distribution of Javascript source code occurs every time a web application is accessed. The users of the business’ service are, in fact, the end users of the business’ modified version of the original, free program.
Freedom isn’t free
Chances are that one of those arguments will have seen readers get a little hot under the collar, so let’s relax for a moment. By now we all understand the principles of free software, and our business owner surely wants to uphold the agreement that she entered into when she chose to build her software atop GNU GPL code. We’re all essentially on the same side, but because of the nature of the web, we find that we’ve been stripped of our agency to decide when to exercise our freedom to use free software, and when to exercise our freedom to distribute it. The two have become inseparable; client side Javascript is only usable when distributed.
There exist some edge cases where Javascript code need not be distributed to be useful. You could wrap it in an Adobe AIR or Silverlight application for your own personal use. You could use Rhino to embed it in a Java application for your own personal use. You could even build an application that runs in a browser, but only ever load it locally. These examples are specious, though. However plausible, the choice to use Javascript in these instances would likely not be the best available one.
For the remaining, typical, client-server, web-centric uses of Javascript, it would seem to me that there exists no opportunity for the creator of a derivative work based on GNU GPL Javascript code to derive value from their program without being forced to exercise freedom 3 by virtue of the consequential distribution of Javascript source code. Proponents of free software call Javascript a trap. I sense that “trapped” is how most of us feel about the deadlock between the Javascript community and the free software movement.
Repercussions and implications
The licenses of the free software foundation have found themselves the target of a number of Javascript developers’ ire. When Jack Slocum’s ExtJS project relicensed their Javascript library under the GNU GPL, their community fractured (of interest is this conversation between Jack Slocum and jQuery’s John Resig). Google around and you will find Javascript developers blogging the GNU GPL as “sneaky,” or “a virus.” This is likely a consequence of people failing to recognize that the explicit aim of the GNU GPL is not to sneakily restrict the freedoms of developers, but to guarantee the freedoms of users, of whom developers (don’t forget) are a subset. Put another way, copyleft, share-alike licenses like the GNU GPL concern themselves with user freedoms, while more permissive, BSD style licenses concern themselves with developer freedoms. Since BSD style licenses permit the total appropriation of free software by middlemen, and the GNU GPL doesn’t, one might argue that GNU GPL licensed projects are more sustainable. However true elsewhere, this has not proven to be the case with Javascript libraries.
Perhaps the decision facing the Javascript developer who wants to build software atop GNU GPL Javascript code involves choosing the lesser of two evils.
Consider the case of the pizza parlor, who uses a web application based on GNU GPL Javascript, with custom modifications, to improve the efficiency with which they can deliver their service, namely: tasty pizza to your door in 30 minutes or less. If the employees of the pizza parlor used the web application to process the order of someone who called in over the telephone, there would be no problem – the parlor is exercising their freedom to run the program without distributing it. The moment they cut out the telephone, and expose that web application to the public so that customers can key in their own orders, de facto distribution has occurred, and the pizza parlor’s modifications are subject to the share-alike provision of the GNU GPL.
That being the case, it’s not clear that this is anything to fear. If the core business of the pizza parlor is the delivery of tasty pizza, and not the provision of software to manage a pizza parlor, should they be afraid of sharing their modifications? If the user’s core business is something other than the provision of software, it’s likely that their software modifications are trivial, or at least peripheral to their core competency – an animation class that makes a wedge of pizza fly across the screen, or a validation class that validates form input on the client side. In this case, the lesser evil may be to embrace the conditions that force her to share-alike, in exchange for the benefits the business owner enjoyed by having access to the GNU GPL Javascript upon which she based her application in the first place.
On the other hand, if your business actually is the provision of an online pizza parlor management service, then you’re probably in the business of providing software as a service, and ultimately, because of the nature of the web, the business of distributing software; a move that will reliably trigger the share-alike provision of the GNU GPL. In this form, we find that the GNU GPL functions as intended: to discourage the incorporation of free Javascript software into proprietary Javascript software, of which software as a service is a part. No surprises there.
A world where all users are free, except those who happen to be less free than the rest
A creator of a web application which incorporates client-side GNU GPL Javascript code may think of themselves as the end user of that web application, but they’re not; the architecture of the network forces them to distribute their modified Javascript source code in order for their application to deliver value to them. Though circumstance alone triggers the share-alike provision, it’s probably also the case that the creator should not fear having to share their client-side code, since their competitive advantage should come from the work they do in the back office (or, in the case of the pizza parlor, the kitchen).
If distribution, as a precondition of use, is going to trigger the share-alike provision for all web-delivered Javascript software, then so be it. There’s something unsatisfying, though, about knowing that all users of free software are free to exercise their freedom to adapt free software, and to run that software for any purpose, without being required to exercise their freedom to distribute their modified version… except if the purpose requires that it execute on a remote, client runtime.
But after all, it’s about being free, as in speech, not free, as in a decaf grande half-soy, half-low fat, iced vanilla, double-shot, gingerbread cappuccino, extra dry, light ice, with one Sweet-n’-Low and one NutraSweet.
Tags: javascript, law
