This session is a companion to the session on competition r0ml presented on Wednesday. For those of us who, for whatever reason, were unable to attend the previous session, he provided us with five second summaries:

• Wednesday: Competition is bad, don’t do it.
• Thursday: Licensing is bad, don’t do it.

And with that, the session is over.

I’m kidding, of course. The best part of any of r0ml’s talks is the logic he uses to get from his observation to his conclusion. As he noted at the outset, the path typically takes us through the Middle Ages.

I don’t deal with lawyers very much in my day job, since I work in a support role for our engineering departments. However, I know several people in our Open Source group, and have attempted to release some of the Perl modules I’ve written while on the job. Doing so is decidedly non-trivial and, after two years I still haven’t been allowed to release my code. To say I’m disappointed is an understatement.

My experience with lawyers has been that they are extremely cautious. While frustrating, I understand that it’s their job to play it safe and to protect the company. They are scared, almost beyond reason, that an Open Source license will find its way into a piece of intellectual property that they’d rather not release. It can’t be easy trying to bridge the gap between the closed and open ways of doing business.

The topic was introduced with a question: What is the difference between copyright and plagiarism? Plagiarism is forever. I didn’t quite catch what r0ml meant by this, but I suspect it means that copyright (eventually) expires, granting the work in question to the public domain. Plagiarism, if one can get away with it, creates an attribution that lasts forever.

That, if one is an Open Source geek, leads one to think about licenses. Let’s take the attribution clause of the BSD, which contains two sub-clauses, for example. It’s redundant. It effectively means that the recipient of the source code can not claim credit for the author’s work. Under copyright law, this is already the case, so why the redundancy.

In the name of efficiency and refactoring, r0ml mused whether it would be possible to reduce the number of license clauses to one. He found this in the Do What The Fuck You Want To Public License.

Through inductive reasoning, if we can reduce the number of clauses from two to one, we should be able to similarly reduce the number of clauses from one to zero. After all, if we begin with the earlier premise that licenses are bad, this should be the goal, right?

First, briefly, why are licenses bad? There are many reasons and many arguments; too many of each for this post, but to summarize a few important ones, as of this writing, the Open Source Initiative lists 73 approved licenses. Choosing between them can be a daunting task. Neither do all of these licenses play well with each other, further complicating the selection task if one is attempting to integrate differently-licensed source code. Finally, it’s rare that anyone knows all that they are agreeing to in the license.

The Medieval sensibility was that all knowledge came either from God or from the Ancients. As such, no one could claim credit for a work, because, without exception, it would be plagiarism. For this reason, the majority of works produced during the Middle Ages were compilations, a representation of existing information.

We have a modern equivalent of this Medieval concept of copyright, called the Compilation Copyright. A compilation of files in the public domain is assembled with copyright only on the compilation. Further, no one may claim credit on the same collection of files. Instead, a new compilation, or derivative work, must be created.

How bad has copyright gotten? Well, thanks to the Apple development kit, there is a short piece of code, included in every project, that is separately copyrighted by everyone who has used the development kit. This is getting out of hand, to say the least.

So r0ml wrote unlicense.rb, which will scan a directory recursively, removing any licenses it finds. This, of course, is perfectly acceptable under the terms of the licenses being removed, so long as the files aren’t redistributed. It does have the effect of pleasing the obsessive-compulsive user.

Under the laws of many countries, a copyright notice isn’t actually required to have a copyright. This is particularly true in the United States and the European Union. In fact, in the latter one cannot even waive the protections of copyright. This creates the default case: without a license, nobody other than the author has the right to do anything with the code. The default is all rights reserved.

Richard Stallman, founder of the GNU project and the Free Software Foundation, was not trying to protect the author of code from people downloading the code; rather, he created the GNU General Public License to protect the users of the code. He felt that users have an inherent right to have access to the code running on their computer. Thus, the primary reason for the creation of Open Source licenses was to protect the user.

Many companies claim that they have an Open Source business model. Typically what this means is that they offer their software, or some subset of their software for free, under an Open Source license. Then they offer support contracts, for usually high prices. These aren’t really Open Source business models. The SQLite project has the only known true Open Source business model. The software itself is released into the public domain. This is a scary place for lawyers, especially those employed by large companies. To assuage their concerns, the company that employs the author of SQLite will be more than happy to sell them an Open Source license for the code.

Next, r0ml talked about warranties. In some jurisdictions, the default case under the law is that there is an implied warranty, unless stated otherwise. Most of us have seen the disclaimer of warranty, included to protect the author, attached to the license in code we have downloaded (or added it to code we’ve released), usually in all capital letters. While not a strict requirement to be in capital letters, it is a requirement that the disclaimer be made to stand out. Often, licenses are in plain text files, so using a bold face type isn’t possible. Hence, capital letters. The simplest case of a disclaimer is such:

/* This program comes without any warranty, to the extent permitted by law. */

As we recall, the default case under the law is an implied warranty so including the phrase “to the extent permitted by law” is redundant. Also, it should be noted that copyright law, in the United States, is codified at the Federal level, in Title 17 of the United States Code, while warranty law is codified by the states. This leads to many more jurisdictions, and far more potential confusion, for warranty law.

So finally, here is r0ml’s part serious, part humorous take away: don’t include either a copyright or a warranty with your code. If a user sues you for damages under the implied warranty in a state court, counter-sue them in US federal court for copyright infringement. After all, under the law they were not given permission to copy the code anyway.

A question came at the end of the session, from someone who appeared mildly upset and defensive. He pointed out that Stallman created the GNU General Public License for a good reason, which wasn’t mentioned by r0ml during his talk. Someone had taken the code Stallman was freely distributing and sold it. After which, they went back to Stallman to inform him that he could no longer distribute his own code, because he hadn’t licensed it. The questioner appeared to be offended by the whole point of the session, apparently feeling that all the work Stallman has done for Free Software was being ridiculed and that, without these licenses, “capitalists” will simply steal the code for their own nefarious purposes.

To this, r0ml did have a response. Copyright law has changed since Stallman faced the problem that led to his creation of Free Software. It has become more strict and the requirement for registration has been dropped. The point was made that the questioner is actually referring to the concept of provenance, not copyright. However, this concept was not further explored as, unfortunately, time had run out.

Originally, I hadn’t planned on arriving at the keynote until 9:00pm, when Damian Conway is schedule to speak on Temporally Quaquaversal Virtual Nanomachine Programming In Multiple Topologically Connected Quantum-Relativistic Parallel Timespaces…Made Easy!. I mean, granted, I’m sure I already know all there is to know about it, but it still might be a little interesting.

Anyway, the keynotes got started with Mark Shuttleworth, the founder of the Ubuntu project. He’s here to speak to us about “Free software and the art of software engineering.” It (whatever “it” is) boils down to three things: innovation, methodologies, and economics.

Innovation. Society has a responsibility to stimulate it. Innovation is extremely non-linear and the key to this is disclosure, as is done in (or was once done in) academia. Free Software is the scaffolding for innovation. The real successes are accessible. The Mozilla products are examples of wildly successful open platforms, with the extension architecture they have provided.

Methodologies. The purpose of methodologies is to organize talent. How is Free software changing the direction of these methodologies. The Free Software people, that is us, are organized and motivated by interest. A second driving factor is that developers are almost never located near each other, so things like pair programming completely fall apart. Creating architecture for collaboration and participation is essential to the success of any Free Software process. While a common set of tools can never be forced upon the community, the ability for a diverse set of tools to communicate with each other is vital.

Economics. It is the combination of the technical change and innovation in economics that really moves the world forward. For example, we had the Web for years before the business models started to spring up around it and really drove us forward, both technologically and economically. Today, there is an increasing use of online services, which both drive technology forward and allow platforms to work together, and more often than not, these services are built on Free Software.

Our great task over the next two years is to lift the Linux desktop from something that is stable and works and is not-so-pretty, to something that is art. At this point, someone started clapping, and a couple of people joined in. As Jaime Zawinsky once said, “We should design software that helps our users get laid.” But really, we need to make software that is phenomenally useable, beautiful, and functional.

Next up, Chris DiBona, the Open Source program manager at Google, joined Allison on stage to present the Google O’Reilly Open Source Awards.

Next up, with Exceptional Software Explained: Embrace Error is Robert “r0ml” Lefkowitz. He is fast becoming one of my favorite speakers. He’s here to talk about software development methodologies in Open Source. This talk is almost a sequel to one he gave last year, An Open Source Lexicon. He has a real penchant for language, particularly classical language, and how to apply it to themes in the Open Source community. Unfortunately, because of this very quality, it’s extremely difficult to write about it as he speaks. It’s hard to summarize as he speaks, and he’s far too entertaining to chance missing what he’ll say next.

Josh McAdams then took the stage to continue the long standing tradition—10 years now—of the White Camel Awards. So here’s something I don’t understand. What is it that drives people to design award trophies that have a high potential for lethality? Honestly, don’t run with them. They’re worse than scissors.

Finally, it’s time for Damian’s keynote. But you know what? I’m not going to miss any of it to write about it here. If you missed it, well, you should have been here.