Free Software vs Open Source

Richard Stallman has long said that open source software isn’t the same thing as free software.  Indeed, he’s spent a lot of time educating people about the distinction.  A distinction about which, frankly, few of us care.  Most of us admire his principles, but then get back to producing software for corporations and, as long as it’s open source, it’s fine.

Part of the point is that it’s free at the point of use.  Yes, there are many other advantages, but the simple fact that you just have to say to your manager “can we use this” rather than having to deal with a purchasing decision makes a huge difference to the time to market of anything you build with open source.  It’s not really about whether the price is $100 or $10,000, it’s just plain harder to get commercial software adopted.  Of course, people are always trying to find a loophole in the terms of these licences.  TiVo is the obvious example, which GPL3 addressed.  Even then most firms didn’t worry about the GPL.  Despite the FUD, if you just wrote internal applications and weren’t selling the software to third parties, the terms didn’t make much of a difference.

Then the web opened the mother of all loopholes.  You could run GPL software on the server, and it wasn’t considered “distribution”.  Who’s doing this?  Well, Google for one.  So, the AGPL was born,* that includes the products of your code.  So, you can’t use an AGPL PDF generation software component in your web stack without everything becoming subject to the AGPL’s requirements.**

Again, there are people trying to make money out of open source software.  However, the AGPL provides a new opportunity: the terms are so unacceptable to most firms they might well prefer to pay for the software.  The AGPL is the first license that’s likely to be free as in freedom but not free as in beer.  The phrase “open source and free software” is turning into “free software versus open source”.

People trying to develop commercial open source have a legitimate beef with the community.  So it’s not a surprise to see that some have decided to monetize their reputation*** and have been quite upfront about their reasons for doing so.  Now, you might think “what’s the problem?  No-one’s forcing you to use it.”  And you’d be right, both RavenDB and Lamson can be quietly ignored.  Nonetheless, it’s a pity open source has lost the likes of Zed Shaw.

Somewhat more problematic are the projects that have migrated licenses, like nServiceBus.  nServiceBus isn’t even a library, it’s a framework that most likely extends into most parts of your business critical code.  If you want to upgrade, and the chances are than any successful project will eventually, you’re going to be paying.  The first, and the second one, is free.  The third… well, it’s not gonna cost you anything like as much as BizTalk.  Maybe your manager won’t notice that the “free” library now costs money, but if he does, he’s likely to be asking much harder questions the next time you want to use a “free” library.

You could say that some of us have been leeching off the amazing work done by amazing developers and expecting a free ride for too long, and you’d be right.  Maybe open source software is fundamentally subject to the tragedy of the commons.  But RMS warned us: open source is not the same as free software. 

*I should point out for the sake of accuracy that the original AGPL in fact predates GPL3.

**This isn’t an idle example, iText has moved to AGPL.

***For the record, I think the arguments in the Oracle vs Google case suggest Oren’s understanding of “derivative work” is defective.  Unless Oracle wins, in which case he’s right on the money.

Clojure Macro Challenges #1

This is a bunch of ideas for macros that I know I’m never going to get around to implementing, but I would find insanely useful if anyone else did.

Magic Partial

Partial in Clojure works, but it’s slow.  You can tell this by the number of times you see functions that return other functions, rather than applying partial.  What you really want is to declare a function once and get the partials declared for you.  e.g.

(defn-partial wrap-authenticated [handler request]
    (handler (assoc request :user (get-user request)))

gets rewritten as

(defn wrap-authenticated
   ([handler request] (handler (assoc request :user (get-user request))
   ([handler] (fn [request] (handler (assoc request :user (get-user request))))

A better solution would be, of course, to fix the performance of partial, but that’s a lot harder.

There’s a harder version of this: to evaluate the function up to the point it needs the unprovided parameters.  But just the basic version would be a performance win.


C# implements generators like those in Python.  However, it’s worth noting that the feature is entirely supported by the compiler, there’s no MSIL level implementation.  The function gets written as a state machine.  To go purely functional, you’d probably want to do it by constructing a sequence of (value, continuation) pairs and then calling (map first coll) on that.  Obviously, you’d want to support all Clojure special forms.


Await is a new feature of C#, but that’s no reason Clojure can’t have it.  It’s already been done for CoffeeScript.  If you really want to be flash, implement generators and await using the same code.

Technorati Tags: ,,,,