Some free software developers have started to use the term ``open source software'' instead of ``free software.'' While free software by any other name would give you the same freedom, it does make a difference which name we use. This article describes the three reasons that have been offered for the change, and explains why in both respects it is better to stick with ``free software.''
But nobody has found an unambiguously correct alternative for ``free software'' in English. (Some languages, such as French, Spanish, and Japanese, have obvious ways to do this.) Every proposed replacement for ``free software'' has a similar kind of semantic problem, or worse--and this includes ``open source software.'' Where ``free software'' has multiple meanings, not just the intended one, ``open source software'' has just one natural meaning, and it is not the intended one.
The obvious meaning for ``open source software'' is ``You can look at the source code.'' This category is distinctly not the same as free software. It includes free software, but also includes semi-free programs such as Xv, and even some proprietary programs, including Qt under its former license.
Of course, it is possible to address this by publishing a precise definition for the term. The people using ``open source software'' have done this, just as we have done for ``free software.'' But this approach is only partially effective in either case. For free software, we have to teach people that we intend one meaning rather than another which fits the words equally well. For open source, we would have to teach them to use a meaning which does not really fit at all.
Years ago, free software developers noticed this discomfort reaction, and some started exploring an approach for avoiding it. They figured that by keeping quiet about ethics and freedom, and talking only about the immediate practical benefits of certain free software, they might be able to ``sell'' the software more effectively to certain users, especially business. The term ``open source'' is offered as a way of doing more of this--a way to be ``more acceptable to business.''
This approach has proved effective, in its own terms. Today many people are switching to free software for purely practical reasons. That is good, as far as it goes, but that isn't all we need to do! Attracting users to free software is not the whole job, just the first step.
Sooner or later these users will be invited to switch back to proprietary software for some practical advantage. Countless companies seek to offer such temptation, and why would users decline? Only if they have learned to value the freedom in free software for its own sake. It is up to us to spread this idea--and in order to do that, we have to talk about freedom. A certain amount of the ``keep quiet'' approach is useful for the community, but we must have plenty of freedom talk too.
At present, we have plenty of ``keep quiet'', but not enough freedom talk. Most people involved with free software say little about freedom--usually because they seek to be ``more acceptable to business.'' Software distributors especially show this pattern. Some GNU/Linux operating system distributions add proprietary packages to the basic free system, and they invite users to consider this an advantage, rather than a step backwards from freedom.
We are failing to keep up with the influx of free software users, failing to teach people about freedom and our community as fast as they enter it. This is why non-free software such as Qt, and partially non-free operating system distributions, find such fertile ground. To stop using the word ``free'' now would be a mistake; we need more, not less, talk about freedom.
Let's hope that those using the term ``open source'' will indeed draw more users into our community; but if they do, the rest of us will have to work even harder to bring the issue of freedom to those users' attention. We have to say, ``It's free software and it gives you freedom!''--more and louder than ever before.
The advocates of ``open source software'' have made it a trademark, and say this will enable them to prevent misuse.
So far, though, it has not made a great deal of difference. I've heard reports of a number of companies' calling software ``open source'' even though it does not fit the official definition. I've observed some instances myself.
Companies have also found clever ways to give the impression that a
program is ``open source software'' without actually saying so. For
example, one IBM announcement, about a program that did not fit
the official definition, said this:
This did not say that the program is ``open source software'', but it takes careful reading to notice that. I should mention that it seems that IBM is sincerely trying to make this program free, but as of this announcement, they had not yet got the license right.
And here is how Cygnus Solutions, a former free software company
which has ``branched out'' into proprietary software, advertises
some of their proprietary software products:
Unlike IBM, Cygnus is not trying to make these packages free software (though one contains some GNU programs that are free), and they are not even close to qualifying. But Cygnus didn't actually say that these are ``open source software'', they just made a vague statement to obtain the favorable impression that comes with that term for software that is not entitled to it.
Individuals with no ulterior motive also misunderstand the term. Here
is how writer Neal Stephenson defined ``open source'':
He applied the conventions of the English language, and reached the natural conclusion.
Only time will tell if the trademark can someday bring an end to confusion like these. For the present, we have to recognize that the term ``open source software'' does not itself seem to prevent confusion.
The Open Source Definition is clear enough, and it is quite clear that the typical non-free program does not qualify. So you would think that ``Open Source company'' would mean one whose products are free software, right? Alas, many companies are trying to give it a different meaning.
At the ``Open Source Developers Day'' meeting in August 1998, several of the commercial developers invited said they intend to make only a part of their work free software (or ``open source''). The focus of their business is on developing proprietary add-ons (software or manuals) to sell to the users of this free software. They ask us to regard this as legitimate, as part of our community, because some of the money is donated to free software development.
In effect, these companies seek to gain the favorable cachet of ``open source'' for their proprietary software products--even though those are not ``open source software''--because they have some relationship to free software or because the same company also maintains some free software. (One company founder was quite explicit about trying to make that part of their work as small as they could get away with.)
Over the years, many companies have contributed to free software development. Some of these companies primarily developed non-free software, but the two activities were separate; so we could put their non-free products aside, work with them on free software projects, and honestly thank them afterward for their free software contributions.
What is different here is that these companies aim to blur the distinction; they want us to regard their non-free software as a contribution when in fact it is not. They present themselves as ``open source companies'', hoping that we will get a warm fuzzy feeling about them, and that we will be too fuzzy-minded to be selective in how we apply it.
This manipulative practice would be no less deceptive if it were done using the term ``free software''. But companies do not seem to use the term ``free software'' that way; perhaps its association with idealism makes it unsuitable for such misuse. The term ``open source'' opened the door for this.
At a trade show in late 1998, dedicated to the operating system often referred to as ``Linux'', the featured speaker was an executive from a prominent software company. He was probably invited on account of his company's decision to ``support'' that system. Unfortunately, their form of ``support'' consists of releasing non-free software that works with the system--in other words, using our community as a market but not contributing to it.
He said, ``There is no way we will make our product open source, but perhaps we will make it `internal' open source. If we allow our customer support staff to have access to the source code, they could fix bugs for the customers, and we could provide a better product and better service.'' (This is not an exact quote, as I did not write his words down, but it gets the gist.)
People in the audience afterward told me, ``He just doesn't get the point.'' But which point didn't he get?
He did not miss the usual point of the term ``open source''. That point says nothing about freedom, it says only that allowing more people to look at the source code and help improve it will make for faster advance of technology. This executive grasped that point completely; unwilling for other reasons to carry out this approach in full, users included, he is considering implementing it in part, within the company.
The point that he missed is the point that ``open source'' was
designed not to raise: the point that users
Spreading the idea of freedom is a big job--it needs your help. The GNU project will stick to the term ``free software'', and I hope that you will too.
Please send FSF & GNU inquiries & questions to firstname.lastname@example.org. There are also other ways to contact the FSF.
Please send comments on these web pages to email@example.com, send other questions to firstname.lastname@example.org.
Copyright (C) 1998, 1999 Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
Verbatim copying and distribution of this entire article is permitted in any medium, provided this notice is preserved.
Updated: 20 Mar 2000 tower