The GNU Project, whose mascot appears here, started something commonly known as the “GPL” (GNU Public License) that you may have come across.
Basically it says that the licensed item, commonly a piece of software, is available in source code form and that you may use it. It also says that, if you change it, you must also make those changes available to anyone and that you must do so without charging them anything.
You may have noticed I’m avoiding the word free in that description. That’s because free has two different meanings in English, one of which applies to the GPL but the other.
In the GPL, you could say that the software is available to anyone and everyone without charge and, once an author makes something “GPL”, then it has to stay that way.
What the GPL doesn’t say, however is that creating that software, writing it, testing it, documenting it, is going to be cheap.
On the contrary, creating GPL software can be quite expensive.
But before we get into that, let’s deal with the English word <em>free</em> to understand how the GPL is using it.
A good synonym to use here is libre or its English equivalent, liberty. Just as you have the right to speak your mind as I am doing on my blog, you have that same right. You can start a blog and pontificate to your heart’s desire.
But my blog costs money. I have to spend money to do this blogging.
To be precise, I purchased the flat5.net domain and pay an annual fee to use it. I also pay a web-hosting service a monthly rental and I pay my neighborhood internet service provider each month so I can get to the internet, to my web-host, and thereby post my opinion on my domain’s web host.
You might say, “Yes, but I can do all that without paying anything!”
But think, is that really an accurate statement?
Yes, you can go to companies such as blogger.com, wordpress.com and many others who will host your blog for nothing, but you still have to pay to get to the internet, you still have to pay to buy a computer in the first place.
“But I can go to the library and use theirs for free,” you might object.
Did you drive your car to get there? Was the gas free?
Did you take the bus and deposit coins as you boarded?
If you walked then, Okay, I’ll agree you didn’t spend anything to get to the library.
But who paid to build the library, stock the books, buy the computer and connect it to an Internet service?
Trust me, you paid for it, one way or another.
If you have income, you pay income taxes. If you spend money, you pay sales taxes. City taxes, county taxes, state taxes and federal taxes. And while your city may be getting federal funds to help build and run that library, those federal funds are coming out of someone’s pocket.
The library may be free, but it isn’t free. And while you are just as free to write a blog as I am, you can’t do so for free.
“Okay,” you might say, “I understand how the GPL makes something widely available and keeps it that way, but where does the expense come in?”
With free software (in the GPL sense), while it may have been started by software developers in their spare time and out of the goodness, or curiosity, of their hearts, today’s developers are being paid.
They aren’t writing GPL’d code for free.
On the contrary, they expect to be paid.
That is, most of today’s developers of open source software (to which the GPL might be applied) are professional software developers who are paid by their employers to write, and make freely available, their software.
The employers know what these employees are doing, that they are giving away their work, and the employers are paying them to do so. That’s what the employers want them to do.
“How can this possibly work?” you might ask. “If they give it away, why would anyone pay for it?”
I’ve been pleased to be a member of several organizations, my present one included, who engage in such activity. There are several different “business models” that companies have tried, some of which have failed.
From a business standpoint, “open source” and the GPL can be quite profitable if you understand a couple of facts and conduct your business accordingly.
First of all, software has become enormously complex, so complex that it no longer compares to the writing of, for example, a book.
Instead, software is built up in layers, each one using the previous as its foundation. You could say that Microsoft’s Windows is the first layer. You then use a web browser such as Internet Explorer, Mozilla, Opera or Safari to surf the net. Then, the web pages you download are, in turn, built up with things called “Style Sheets” that control the page layout and fonts you see. The style sheets and web pages are understood by the browser which, in turn, uses the operating system to get to the Internet.
That’s three layers but I’m oversimplifying.
In reality, the operating system itself has dozens of layers to which the web browser adds several more, and then the web pages themselves further pile up even more complexity.
By the time a web page reaches your LCD, your mouse click on that hot-link has traversed dozens of computers and passed through hundreds of layers. And those numbers could easily — I say easily — be counted in hundreds of computers and thousands of layers.
For the experts who have watched the Internet and computers grow to what we see today, the scale is utterly mind-boggling.
It’s so big and complicated that no one person or even one company can do it all anymore.
That’s where “open source” fits in.
In the past twenty or so years, the “open source movement” and its work has become the foundation of many commercial products. For example, much of the internet you used to retrieve this web page runs on “open source” software.
But the computers that power the Internet are built, and sold, by companies that use that open source software for a specific purpose. They build the machine, customize the software, and package the whole thing up to be, for example, an Internet router.
Companies sell Internet routers that use open source software.
And those same companies who wish to enhance those products, or their competitors who want to sell you an even better product pay their software engineers to enhance the open source code that runs the Internet.
They do this because, to get the enhancements they want into the product, they have to write the software and make it generally (freely) available.
But they don’t have to give away their product. Only the software that makes it work.
They can still charge you for the electronics, the packaging, the instructions and the warranty. They can charge you a shipping fee, an upgrade fee, a maintenance fee for on-going support which you may or may not use.
And they can charge to pick and choose open source components and package them in a form that’s easier for software developers to then use.
And they can charge to help you put that free software together if you would like their help.
“Yes but,” you might object, “they’re still giving away the smarts, the intelligence, the software that makes one product better than another.”
And yes, that’s true. But it also takes time to assemble a system, to package it with documentation, to get it to the stores and out there on the store shelves. And then it sits there until someone buys it.
Writing the open source to do what your product wants versus someone else taking your code, after the fact, and building it into their own product, takes them longer to get to market. If you write the code, you get there first.
Lead time is everything.
The company I work for, Wind River Systems, makes software that “powers” (in a software sense) many products. For example, our software is the foundation, the operating system, upon which several aircraft are flying. The pilot moves the control stick and the software decides what to do but it is our software that is sitting under the program that decides what to do. Our software provides the overall environment in which the flight avionics software decides what to do. And when the avionics decides to move the ailerons so the plane rolls slightly to the left, it is the operating system that runs the tasks and communications to carry out that decision.
But I fear you might be getting the wrong idea so let me quickly add that the software used in these ultra-high reliability environments is not open source. It is a Wind River proprietary product called VxWorks. And we don’t make the source code available to any except paying customers, and they have to abide by our license which prohibits their sharing that software with anyone else.
It is also true that Wind River works on the GPL’d Linux operating system. We write code for it and then make that code available according to the terms of the GPL.
But both of those operating systems need something else to make a workable system that flies an airplane. They both need <em>tools</em> to put the whole system together. They both need <em>tools</em> to test them to make sure the avionics does what it is supposed to do, and they both need <em>tools</em> to help designers understand what that GPL’d open source code is doing.
The software tool used to build a flight control system based on our VxWorks product is an “open source” product. It’s the same “tool” used to assemble a complete Linux system. That tool is called Eclipse. If you are a software developer, or even if you are just curious, you can download a copy, freely and without having to pay anything — it is “free” in both senses — from http://www.eclipse.org/.
And here is where we discover that “open source” means more than what the GPL says. The GPL is simply one kind of open source license. It’s not the only one.
Eclipse does not use the GPL open source license. Eclipse has their own, and different but still “open,” source license.
With the Eclipse open source license, you can add something but not you can choose to keep your changes, your additions, proprietary. With the Eclipse license, you can choose to keep your additions private. With the GPL, on the other hand, if you add something you have to give it away.
Both licenses are “open source.” You can take it — it is freely available — and modify it as you wish.
But with Eclipse, that “next generation” of software you create doesn’t have to be given away.
Eclipse chose this different license to encourage private companies to help Eclipse grow. Eclipse was a great starting point but it didn’t have all the features the original authors wanted. They didn’t have the time to make it perfect. So, the Eclipse designers hoped that companies might want to add features to Eclipse but not otherwise give away they those additions.
Wind River does that. Wind River adds features to Eclipse — features that Wind River customers need to build better avionics and other products using the Wind River operating systems and tools. And so do the other companies that base their products on Eclipse.
And sometimes those changes, those enhancements, required some very fundamental changes in Eclipse, and those are in areas that are common to all companies using Eclipse. What one company fixed in those areas, is available to all companies using Eclipse.
And so Eclipse began growing.
And, also over time, companies have decided to give up their proprietary additions, to make them “open source”.
Why would they give away their proprietary software?
They’ve done this because, at some point, software products simply become too big for any one company to maintain. Both Linux and Eclipse, while subject to slightly different but still “open source” licenses, are too complex for any one company to maintain.
And so, Wind River and these other companies, sometimes release their proprietary additions into the open source community. For the companies that do so, they gain the advantage of having a much larger pool of software developers to maintain that product. For the open source community, they gain the advantage of growing a much more comprehensive and useful “product”.
And it is the complexity of layers upon layers upon layers of software that makes this “open sourcing” particularly attractive.
Software components are measured by counting the number of lines of code they contain, somewhat analogous to counting the lines of text in a novel. Twenty years ago, the numbers of lines of code in software products were counted in the thousands or tens of thousands for most companies. A few big companies were managing source files that totaled out a perhaps a million lines of code but that was comparatively rare.
One of the first systems I worked on, the Red Baron Operating System at American Express, probably contained no more than a few thousand lines of code. That was back in the mid 1970s.
But with the layering that has become commonplace today, one company’s “million lines of code” are now relying on several other “million lines of code” as their foundation. And there aren’t just two levels. There are dozens of levels, each with “million lines of code” relying on still deeper levels.
This is where “writing software” becomes profoundly different from “writing a book”. While someone might write a series of related novels — The “Master and Commander” series by Patrick O’Brian is one of my favorites where the characters, locations and circumstances may span the entire set — that’s not the same as happens in software.
By analogy, with software we would have to say that, for example, Book #6 in the series specifically tells you on page 147 to “insert book #1 here” and, then later on perhaps page 276, “insert chapters 7-9 and 14 from book #12” at this point. And, in book #8, we then find it requires “insert book #6 here” at some point, thereby stacking not one but two levels, one on top of the other.
This is what software does. It gets unbelievably complicated — so much so that even those of us who understand what it is doing are still in awe.
And almost none of that software is written for free anymore. It’s all being done by educated professionals who are paid by their employers to write that kind of software all day long and add the features and abilities they can then sell to their customers.
And you are then free to buy it.
Open source was once labelled as a Communist plot.
“How can business survive if we have to give everything away?”
Today, businesses have found a way to not only profit from open source, but to add to it, enhance it, to work collectively for mutual benefit.
And they make a damn good profit, too.
When someone says, “Liberty is not free”, what we’ve seen evolve in the software industry over the past several decades epitomizes the statement.
Your personal “freedom” works the same way, but that’s a different story.