RMS 珠海演讲听译
Free software means software that respects the user's freedom. It's a matter of
freedom, not price, so you should translate it as "自由" not "免费". If a
program is not free, then it's proprietary software, non-free software,
user-subjugating software.
Non-free software keeps users divided and helpless. Divided, because they're
forbidden to share copies, and helpless, because they don't get the source code,
so they can't change it, they can't even study what it's really doing to them.
And often the non-free software has malicious features. There are malicious
features to spy on the user. There are malicious features to restrict what the
user can do. And there are malicious features which are backdoors, that can be
used to attack the user. But fundamentally, non-free software gives the
developer power over the users, and nobody should have that power. Software must be free.
But my definition, so far, is very general. To say it,
respect your freedom, what's that means?
There are four essential freedoms that the user of a software deserves. Freedom
zero is the freedom to run the program as you wish. Freedom one is the freedom
to study the source code of the program and change it to make the program do
what you wish. Freedom two is the freedom to help your neighbor, that's the
freedom to redistribute exact copy of the program when you wish. And Freedom
three is the freedom to contribute to your community. That's the freedom to
distribute copies of your modified versions when you wish.
If the program gives you this four freedom then it is free software, which means
that the social system of the distribution and use of this program is an ethical
system. One has to respect the user's freedom and social fidelity of the user's
community.
But if one of this freedom is missing, or insufficient, then the program is
proprietary software, which means that it imposes an unethical social system on
the users.
So to develop a free program. Oh actually, first I should explain that whether a
program is free or proprietary is not a question of the technical details of the
code, it's a question of how the users get the code, what condition they can use
it.
So to develop a free program is, in general, a contribution to society, more or
less, depending on the details. But develop a proprietary program is not a
contribution, it's a power grant. The use of a non-free software is social
problem.
And so,the goal of free software movement is that all software be free, so that
all users can be free. But why this four freedom is essential, why define free
software based on these four freedoms.
Each freedom has a reason. Freedom two, the freedom to help your neighbor, the
freedom to redistribute that copy of the program is essential on fundamental
moral grounds, so that your can live an upright live as a good member of your
community. If you use a program without freedom no.2 then you are in danger at
any moment of falling into a moral dilemma. Whenever your friend says this
program is nice, could I have a copy. In that moment you will be in a dilemma,
you'll face the choice of two evils. One evil is to give your friend a copy and
violate the license of the program, the other evil is to refuse your friend a
copy and comply with the license of the program.
If you were in this dilemma, _you what_ choose a lesser evil, which is to give
your friend a copy and violate the license of the program. What makes this
_be_ lesser evil, well if you can't avoid doing wrong to somebody or other,
it's better to do wrong to somebody who deserves it, because he has acted wrong.
We can assume that your friend is a good friend, a good member of your
community, and normally deserves your cooperation. By contrast, the developer of
proprietary program has acted to separate you and your community, has tried to
divine your community. So if you have to wrong to one or the other, do it to the
developer.
But being a lesser evil does not mean that it's good. It's never good to make
an agreement and then break it. Not even in a case like this one where the
agreement is inherently evil, and keeping it is worse than breaking it. Still
breaking it is not good. And if you give your friend a copy, what will she
have, she will have an unauthorized copy of a proprietary program, and that's a
bad thing, almost as bad as an authorized copy of a proprietary program. Nobody
is laughing except one person just smiled. Now I'm a bit surprised, and I'm
worried , may be what I'm saying is not clear.
So once you have fully understood this dilemma, what you really do. You should
make sure, you are never in the dilemma. How? I know of two ways, one way is
don't have any friends. The other way, my way is, don't use that software. If
you don't have this non-free software, then there is no danger that you'll fall
into that dilemma. So when someone offers me a program on the condition I'll
not share with you, I say, my conscience does not allow me to accept that
condition, so take you program away. I won't use it.
So I reject software without freedom too on moral grounds, and you should too. And we
should also reject the proper_ terms the the developer use to demonize the
practice of cooperation. Terms like "pirate", when they call the people who
share copies "pirates", what they really saying, they want us to assume that
helping your neighbor is morally equivalent of attacking a ship. Well, I don't
think that's true. Ethical speaking, it's as false as anything could be, because
attacking ships is very bad, but helping your neighbor is good. So I refuse to
call them pirates. When somebody asking me about piracy, I say attacking
ships is very bad. In other words, I refuse to fall into their trap, I refuse to
accept the use of a term "piracy" to refer to helping your neighbor. And when
people asking me what I think of music piracy or software piracy, I say, from
what I have read pirates don't attack by running computers, or by playing
instruments very badly, although that might work with enough time. Form what I
read they use arms, so their piracy is not software or music piracy. So now
you get the point, don't fall into the trap. Well that's the reason to have
freedom reason two, the freedom to help your neighbor, the freedom to
redistribute that copy of the program when you wish.
Essential on fundamental moral grounds, freedom zero, the freedom to run the
program as you wish is essential for a different reason, so you can control your
computing. There are proprietary programs whose licenses are restrict even the
use of authorized copies. And obviously, that's not having control of your
computing. There's one program for publishing web sites, whose license says you
are not allowed to publishing anything that criticizing the developer, imaging
how outrageous that is. So there no limits how nasty they can be, but the
license shouldn't restrict your use of the program at all, that's freedom zero.
And it's essential, but it's not enough. Because that just means you could
either do or not do, whatever the code of the program is already set up to do, so
the developer continue to deciding for you, and imposing his decision on you,
not through the license but through the code of the program. So in order to have
control of your computing, you need freedom one, which is the freedom to study the
source code and then change it to make the program do what you wish, this way
you decide, instead of let the developer decide it for you.
If you don't have freedom one, you can't even tell what the program is doing.
And as I have mentioned, often they have malicious features to spy on the user,
restrict the user, and backdoors to attack the user. And not just obscure, very
little know programs, small companies you never heard of. One proprietary program
in which we have found all three of this malicious feature types that you may
have heard of, it's called "Microsoft Windows". People have found spy feature in
"Microsoft Windows". People have found, of course this is obvious, features
design specifically to restrict what the user does with her own files in her own
machine. And there's backdoor, a backdoor that allows Microsoft to _forceable_
change the software with asking permission of the noumenal user of the machine.
So if you're foolish enough to allow "Microsoft Windows" to run in you computer,
you may think you own it, but really Microsoft has owned your computer.
Any malicious feature that is not in Windows today, Microsoft could forcibly
install tomorrow. Now Microsoft is not the only company that does this, another
malicious product which has all three of these kinds of malicious features is
the "Amazon's Window", well they call it "the kindo", we call it "the swindow". But
when they call it "the kindo", that is meant to explain the purpose of the
product is meant to burn your books. "Kindo" means to start a fire. So it's
design to burn your books. That products spy on the user, because the only
place you could buy a book is from Amazon, and if you buy from Amazon, you are
forced to identify yourself, so Amazon knows exactly what books you have read,
nobody should know that. And it also has digital restriction's management,
features designed to restrict you use of the book you bought to stop people from
doing things like lending book to their friends. They want to put an end to the
practice of lending book to your friends, an end to public libraries. They don't
want sell book or use book stores. And it has a backdoor, we found out about the
backdoor a few month ago. Amazon use it to remotely erase all copies of a
particular book, and this book is 1984, by George Orwell, the book that give us
the word "Orwellian", the book that's very important for everyone to read. So
the people have bought copies from Amazon discovered one day that they don't
have their copies any more they have been erased. Amazon just send the command
to all of these swindows and erase these books. So this shows how dangerous
non-free software can be, because you can't check what it does.
Now, not all of the developers of proprietary software put in malicious
features. Some do it, some don't. The point is we can't check, since we don't have
the source code. Without freedom one, we don't have the source code, we can't
check for malicious features. So we are totally at the mercy of developer. Some
developer will abuse this power, and some won't. The point is they have power,
and they shouldn't have power. Nobody have that power.
So we can divide all the programs without freedom one into two classes. There is
this class of programs we know of malicious features, and then there is programs
which we don't know of them. And some of these program has malicious features
that the public had not found out about it and other don't, and we can't tell
which is which. We can't identify the ones with malicious features.
But even so, I can make a statement about all of them, which is their developers
are human, so they make mistakes, the code of these programs has bugs, and the
user of that program with freedom one is just as helpless, facing a accidental
bug as facing a deliberate features. If you use a program without freedom one,
you are a prisoner of the software you use.
We, the developers of free software are human too, we also make mistakes, the
code of our free programs also has bugs. But if you run into a bug in our free
software code or anything in the code you don't like, you are free to change it.
Because we don't make you a prisoner. We can't be perfect, we can, we respect
you freedom.
So freedom one is essential, but it's not enough. Because that's the freedom to
personally study and change the source code, that's not enough, because
there are millions of users that don't know how to program, they don't know how
to exercise this freedom. They can't exercise it directly. But even for
programmer like me, freedom one is not enough, because there are so many
softwares
in the world. In fact, there are so many free softwares already in the world
that no one person who uses computers can possibly study the source code of
all the programs that she uses and master them all, and personally write all
the changes that she wants, because that's more work than any one person can do.
So the only way we can fully have control of our computing is to working
together, cooperating. And for that, we need freedom three, the freedom to
contribute to your community, the freedom to redistribute your modified
versions. This way, the change that many people want only has to be written once
by somebody whose willing to release his modified version and then we can all
have it. We don't have to write it each one of us, over and over again. for
ourselves. One can write write it and distribute the modified version to all of
us, and we just get it without any additional work.
Suppose a few people release a free program, and we like it, we use it. But we
want some additional features. Well somebody can start with this version and
implement part of this features and release his modified version, and someone
else can start with that implements some more and release her modified version,
and other people can start with that, and implement the rest, and release that,
and then we all switch to that, and we thank them for collaborating to make this
improvements. So freedom three makes it possible for us to collaborate in making
a program do what we really want. So freedom three is also essential.
[21:xx.x]
Now only a programmer, only someone with the skill that's necessary can directly
exercise freedom three, but other users can indirectly take advantage of freedom
one and three. For instance, suppose you use a program in your business, _you
part of how you make money is part of your operations, _you run this program.
Suppose you know this, if a program did something different, it would work
better for you, and you business would run more smoothly, and more efficiently,
and you'll make more money, then it would be worse for you to pay a programmer
to write that change for you, we're assuming you don't know how to program, you
business is probably not a software business, most of the business in the world
don't do software, but they use software, so this is the common case that I'm
talk about. So you know this you would like a certain change, with free
software, you can look for any programmer who wants to do the job for you,
because it's a free market. So you can pick a programmer who acts for a good
price, and who also has experience working on the software, and you could pick
whoever you like. Once you make a deal with that person, then you'll give him a
copy of the version you're using, exercising you freedom no.2, then he'll study
the source code, and implement your changes, exercising his freedom no.1 for
you. In this scenario, you're not a programmer, you don't know how to exercise
freedom no.1, but he does, and you're going to pay him to do it for you. Then
when his changes are working, he gives you a copy of his modified version,
exercising his freedom no.3 for you, then if it works, you pay him. And an
important part of free software business works this way.
Now this is impossible with proprietary software, because you generally don't have
the source code. In fact, only the developer has the source code, so the only
way you can get a change is to beg the developer, or pray to the developer,
"Oh, oh, mighty developer, please make this change for me". Some developers say,
"pay us, and we'll listen to your problem". And if you pay, the developer says,
"Thank you. in six months, there won't be an upgrade, by the upgrade, you'll see
if we have fixed your problem, and you'll see what new problems we have not solved for
you".
(24:55.1)
But with free software, anybody can go into this field, this business. Anyone
with the skill necessary can offer to make change for people. And therefore all
this organizations that use software say they need good support, they should
insist on free software, so that they can get their support from a free market,
which means in general they'll get better support with lesser money. And thus
all the users get the benefit of the four freedoms.
(25:43.1)
Every users can exercise freedom no.0 and 2, the freedom to run the program as
you wish, the freedom to redistribute exact copies. Because these don't require
programming, if you can use a program at all, you can take advantage of these
freedoms. Freedom one and three, the freedom to study and change the source code,
and then optional distribute copies of your modified version. These involve
programming, so any given person can exercise these more or less, depending on
how much he know to program. And there are many people who don't know how to
program, they can't directly exercise these freedoms. But when others,
programmers who exercise versions, and when they release their modified version,
all of us can install them or not, so we all get the benefit of living in a free
society where users have these four freedoms. And the combined result of these
freedoms is democracy. A free program develop democratically under the control
of its users. Because every users can participate however much he wishes. In
society's decisions about the future of this program which is simply the sum
total the decisions of various users make about what to do with this program. So
on one side we have individual freedom, social solidarity and democracy, on the
other we have dictatorship. The developer uses this program to gain power over
users, to subjugate them. The program is the instrument of the programmer's
power, and with this power the developer can bully them, exploit them and
mistreat them. Society must choose free software, and escape from proprietary
software. And so the goal of the free software movement is the liberation of
cyberspace and all of it's habitants.
(28:20.5)
I reach the conclusion around 1983, that software should free and I want to live
in freedom while using computers. How did I reach this conclusion? It was not a
stroke of genius. It was the result of my experience. During the 1970s, I
participated in a free software community, part of this community was IMIT where
I worked. In the lab I worked, the artificial intelligence lab, essentially all the
software we use was free software. We had our own operating system, the
incomparable time-sharing system, or ITS had been developed mostly by the people
in the lab. And when they hired me, my job was to make the system better, and
some programs had been developed in other places, and shared with us, we
improved them and shared them back. We shared our software with anybody who
wanted it. So I got to learn this way of live, when people share knowledge. We
developed software, we shared it. And we expected others to share. So I learned
this is a good way of life.
(30:01.1)
But then, I had a experience with proprietary software. Xerox gave IMIT a laser
printer. This was the first generation laser printer. It was actually a office
copier, a very fast, heavy duty office copier, that have been modified by adding
a laser to it. And it frequently got paper jam, and it was installed in a place
not near everyone's office, so the machine could stay jam for a long time, and
nobody would know this, And as we learn to expect, our reaction to this jam was
we wouldn't go to the printer so soon, we would wait an hour, so if a bunch of people
printed something, and they all waited an hour, that meant it would stay jam
for an hour, and then somebody would fix it, and it would print a few jobs and
then jam again, and it might wait another hour. So things got really bad.
(31:05.2)
Well I knew how to fix that, because I have fix the problem for a previous
printer. I added features to the software, one feature displayed a message on
your screen when your job was finished, so you can go immediately to pick it up,
another displayed a message on your screen when the printer got into trouble.
So you'll go immediately to fix it. Well I want to add these features, but I was
blocked. You see, for the old printer, the reason I could add these features was
it was controlled by a free software. But the new printer was controlled by
proprietary software on the special kind of computer that Xerox gave us. And I
couldn't change it, I couldn't add these features, all I can do is suffer,
along with everybody else in the lab who were suffering the same way.
(32:04.6)
And then I heard that somebody at CMU[Carnegie Mellon University] had a copy of
that source code. So eventually I was there, so I went to his office, and I say,
"Hi, I am a friend of IMIT, could I have a copy of the printer software source
code", and he says, "No, I promised not to give you a copy". And I was shocked,
I was so shocked by this refusal to cooperate in a usual way. Then I couldn't
express my anger, and do justice to it. All I can do is walk out of his office.
But because it rankle so much, I keep thinking about it. I thought about what
he's done and how his betrayal of the rest of community had hurt us. And I
thought the morality of what he's done. Because he didn't just promise not to
share with me, it wasn't personal. It was even worse. Because he has promised to
refuse his cooperation to everyone in the world. He had not just betrayed my lab
IMIT, he had betrayed the whole world. And when I realized that, I thought of "曹
操". But "曹操" only spoke of the idea of betraying the whole world, this person
had actually done it. And this is what crystallized my understanding of the evil
of proprietary software. Specifically in this case the evil of a non-disclosure
agreement, because that's what he had signed. He signed a agreement, so that he
got the source code, and the price of his getting it was to betray all the rest
of us. Well except most of you weren't born yes, so you weren't included, that
was around 1980s. But those of you were already born, you were included, you
were betrayed.
(34:37.6)
Anyway, a couple of years later, my community collapsed, it died. And the PDP10
computer which the incompatible time-sharing system was written for became
obsolete. And so I faced a prospect of spending the rest of my life using and
developing proprietary software. And I thought about that, and I concluded this
is ugly, this is a horrible way to live. I said no. I refuse to live that life.
I'm going to dedicate myself to winning freedom, to creating a new free software
share community.
(35:44.9)
So, in order to have a free software community, in order to use our computers in
freedom, the first thing we need is an operating system that's free software,
because computer won't run at all without a operating system. So, not only that,
I was an operating system developer. I was the exact right person to start a
project to develop an operating system. And that's what I decided to do. The job
had to be done, I had the necessary skills, and it looked like nobody would do
it, if I did not. So I concluded that it was my duty to do this, I was elected
by circumstance. As if you see somebody drowning, you know how to swim, there is
no one else around, and it's not Bush. Then you have a moral duty to save that
person. Well I've made too strong statements, perhaps there are other people
in other governments about whom I should not make the claim that you have a moral
duty to save them. But in any case, that's not important for me, because I
don't know how to swim. But in this case, the job to be done was not swimming,
was to developing an operating system, and that I knew how to do it. So I
decided I would develop a free software operating system, or die trying.
(37:59.0)
A old age that is, because at that time the free software movement I started had
no active enemies. Lots of people disagreed, but they just laughed and then pay
no more attention to us. They were sure we would never develop a free operating
system anyway. They didn't think they had to bother to try to stop us. And I
didn't know if we'll succeed. How could I be sure, what I knew was, that if we
didn't try, we were certain to fail. Freedom demanded this job. So I just do it,
I decided I'll develop a free operating system. I decided to recruit other
people to join in and help, so we can finish sooner. I decided to follow the
design of UNIX, so that could be a portable operating system, and it'll be able
to run on a computer five or ten or twenty years in the future. And I decided to
make it compatible with UNIX, that's using the same commands, so that the users
of UNIX would find it easy to switch.
(39:17.2)
And then I gave the name GNU as a joke. Because even though it was clear that if
I succeeded, this would be the most thing I would do in my life. No matter how
serious something is, you can still make a joke. And that's part of the hacker
spirit.
(39:42.7)
You see, in our community, in the 1970s, we called ourselves hackers. And what's
that meant and means, because we still call ourselves hackers, what it means was
we are programming because it's fascinating to use our intelligence, it's not
just a job, for us, programming is a way to be playfully clever. And playful
cleverness is what being a hacker is all about. And it doesn't have to be with
computers, if you enjoy playful cleverness, you can be playful clever in any
area of life. But it's true computers are very suitable for engaging in playful
cleverness. That gives you a lot of opportunities to do it.
(40:37.0)
Anyway, in the 1970s, system level programming is usually not portable. Every
program was written for a specific kind of computer and that's all it could run
on. So it was very common that you would want to use an existing program, but
you could run it, because it was written for some other kind of computer. And
the only solutions write another, so you would write you own program to do the
same job that you could run it on your computer. So everybody had to do this.
(41:16.2)
But in our community, we had a humorous tradition for this cases. You could give
you program a name which was a recursive acronym saying that your program is not
the other one, a humorous way of giving credit. So, for instance, there were many
fairly similar Tego text editors. And someone write one and called his program
TNT for "TNT is not Tego". That was the first recursive acronym. And then I
wrote the Emacs text editor, and there were thirty imitation Emacs afterwards.
Each one of it run it on a different kind of computer. And most of them were
called something-Emacs, which is obvious not fun. But there was also Fine, for
Fine Is Not Emacs, and Sine, for Sine Is Not Emacs, and Eine, for Eine Is Not
Emacs. And Mince, for Mince Is Not Complete Emacs, and version two of Eine was
called Zwei, for Zwei Was Eine Initially. Zwei is German for Two. So you could
have a lot of fun in recursive acronym.
(42:57.1)
And I decided to use a recursive acronym for something is not UNIX. And then
pondering for a name to use for a suitable recursive acronym, I discovered the
word GNU would work. GNU stands for GNU is Not UNIX.
[laughter]
(43:17.4)
And not only that, the world GNU is the most humor charged word in the English
language. Use for countless wordplays, because according to the dictionaries the
G is silent, and the word is pronounced [nju:]. So every time you want to write a
word NU, you could spell it GNU, and you have a joke. Perhaps not a very good
joke, but there are lots other. So that's the reason why I chose the name GNU,
it happens to the name of animal that lives in Africa. You can see drawing of
this animal on a lot of our things. Here, over here. So this is a picture of
GNU. But the reason that I chose it is not because I love this animal, it's
because it stands for GNU Is Not UNIX.
(44:28.0)
So when it is the name of our system, don't follow the dictionary. Because if
you talk about the new operating system, you'll get people confused. You see
we've worked on it for 25 years now, and we've been using it for 17 years, so
it's new any more, but it still is GNU. And it'll always be GNU, despite the
people who _ironically_ call it Linux. But how did that error get started, how it
was happened that millions of people who use the GNU system, and they think the
system is Linux. It's the confusion that started in 1991-92.
(45:15.9)
Here is what happened. During 80s, our task was to develop hundreds of
components that we need for a UNIX-like system. And in 1990s we had almost all of
the system, but one essential part is still missing. And that was the kernel.
The kernel was the system component that allocates computer's resources to all the
other programs you run. So in 1990s, the free software foundation hired somebody
to write the GNU kernel, and we decided to use advanced design, the bottom part
was micro-kernel, and on top of that we would develop a bunch of module servers
that will communicate by message-dispatching, and each server will do one
particular job. So this was an advance elegant design that we thought would make
the system more powerful. And for various reasons we thought it would be easier to
bootstrap it, and that we would get it done sooner. Well, we were wrong. Because
it took 6 years to get even a test version running, and it's still doesn't work
very well, so people don't use it.
(46:40.1)
But fortunately, we didn't have to wait for that. Because in 1991, Mr Torvalds,
a college student started to write his own kernel. And he got it to work at a
minimum level in less than a year. His kernel was called Linux, and initially
it was not free software, because initially its license was too restrictive.
(47:15.8)
So, in fact it did not allow commercial redistribution, therefore that meant a
large class of users, namely business, and individuals in their business
activities didn't have freedom two and three. So that's not free software. But
in 1992, Torvalds re-released Linux under the GNU GPL, making it free
software, because the GNU GPL is the one of the many free software licenses.
(48:00.4)
But you might ask what is a free software license? Why does a free program need
a license anyway? Well, under today's copyright law, anything that is written is
automatically copyright. And copyright law by default forbides modification,
coping, distribution. And in many counties even forbade running the program, so
by default, the program is not free. So how can we make a program free? We do it
through an explicit formal statement by copyright holders, giving the users the
four freedoms. These formal statement we call it the free software licenses, or
putting it more precisely, any such statement would be a license. If a license
give you the four freedoms, then it's a free software license. So the license
has to be written properly to give you the four freedoms. So there are many free
software licenses. There are something like fifty or sixty we know of, and may
be there may others, because anybody could theoretical write a free software
license as long as you does it right. Of course, if you going to do it, you
should get help from a lawyer, because otherwise you could make a mistake.
(49:38.7)
So the GNU General Public License or GNU GPL is a particular free software
license that I wrote to use it on the programs that we would develop for GNU,
and the GNU GPL is the most commonly used free software license, about two third
of all free software projects use the GNU GPL. And what special about GNU GPL is
that it's a copyleft license. Copyleft means that all copies of all versions of
the program must be free. You see, some free software licenses, for instance,
the _exerleven_ license, and the two different BSD licenses, they are very
lack. They let people turn the program into proprietary software. If I wrote a
program and release it under a lack license, somebody could get a copy from me, and
compile it, and gives you just the binary, putting on an end-user license
agreement that restricts you. And then you copy will not free software, he could
change the source code, and compile it, and provide you just the binary. And it
would be just impossible to get source code that correspond to that binary,
because only he would have it. Now if my goal have been success, I might say
it's good, more people would use my software, but that's just ego. My goal
wasn't to have more people to use my software, my goal was to give people
freedom.
(51:45.7)
And to achieve that goal, I had to make sure that a middle man could
not remove the freedom of your copy before you get it. So I developed this
technic of copyleft. Here is how copyleft works, the GNU GPL says, "You are free
to distribute that copies and modified versions, but you must make the source
code available, and you must distribute always under the same license, you can't
change the license, you can't add restrictions, and you can't take away
protections. So when you distribute the copy to someone else, you have to
respect his freedom, just as I respect your freedom. And so the freedom this way
goes with the free software, everywhere the code goes, the freedom goes also.
That's the idea of copyleft.
[applause]
(52:51.0)
So I noticed people who mistakenly believe that the free software is only the
software under GNU GPL, that's not true, there are other free licenses also.
There are copyleft free licenses, and there are non-copyleft free licenses. All
of them respect your freedom. But the copyleft license go even further, and they
actively defend freedom for every user.
[RMS drinking water]
(53:36.1)
So, when Torvalds re-release Linux under the GNU GPL, it became free software.
And the combination of the almost complete GNU system and the kernel Linux made
a complete free operating system. For the first time, it was possible to buy a
PC, and install a free operating system. And use it in freedom. So liberation of
Linux as free software was an important contribution for free software
community. But at the same time, the confusion started, and the people who put
Linux together with the bulk of the system got confused, they were focused so
much on Linux, they treated everything else as a minor _eron_. And they started
to call this combination a Linux system, talking _this_piece_ and ignoring most of
it. And that's not fair to us, because we started this work almost a decade
before Torvalds, we did a much bigger part of job, and we were the ones who had the goal
of doing the whole job, which is why it got done. So please give us a share of
the credit, please don't call the system Linux. Please call it GNU/Linux, so say
I'm going to set up a GNU/Linux server, I'm a GNU/Linux user, I'm going to start
a GNU/Linux user group. Please take this extra second to give us a share of the
credit.
[applause]
(55:21.2)
Now, one reason to do that is because we did this work, and you should give us
credit. But that's not really the most important thing. Credit is not the really
most important ethical issue in life. There are something much more important to
say here. And that is your freedom. You see, the name you call something, your
choice of the name doesn't directly change anything. But the name you use
determines what message you convey to other people, and that has influence on
their thought which can have an influence on their actions. So in this way, what
you say makes difference. Ever since twenty years ago, when I announced the GNU
project, the name GNU are associated with these ideas of freedom. By contrast,
the name Linux is not, because Linux is associated to Mr. Torvalds and with his
ideas, and he doesn't agree with our idea of freedom, he rejects them, he
doesn't think that we should give every user freedom, he just wants powerful
reliable software. Well, he has the rights to express his views, of course
people should be free to express his views, even if we disagree with them. But it's
not fair for him to get the benefit of the erroneous credit for our work in
order to spreed his views saying
we are wrong. That's not fair, and it's not good for your freedom either.
Because if people believe the system is Linux, they tend to follow his ideas, and that
means they don't value their own freedom, they won't join us in fighting for
freedom. And if there are few of us, we has less chance of victory, our freedom
is threatened these days. Twenty-five years ago, the only work we had to do was write
free software. Today we have powerful enemies, companies with a lot of money,
and the governments who support the purchase, like the US government and many
others. So we are going to do more than just write free software, we are pretty good at
that, we've written a lot of software. But now we also have to organize, we have
to get together to champion freedom, because our enemies are trying to make sure
that it's hard to use free software, they're trying to hold us back. And they
are trying to get the support of governments at all levels, of schools. And we
have to work, we have to make sure our governments and schools don't support
them. We have to make sure our governments and schools support freedom.
[applause]
(58:51.1)
So freedom is frequently threatened. And to keep it, we have to defend it. But
in order to defend our freedom, we have to value our freedom. And in order to
value our freedom, we have to know what it is. In our community, I'm sad to say
most of the uses have never even heard the idea. As we trying to bring people's
attention, these ideas and social solidarity that go with free software, we have
to overcome two big obstacles. One is the users of the GNU system mostly don't
know it's the GNU
system, they think it's Linux and that was started by Mr Torvalds in 1991, and they don't
think it has anything to do freedom. So we write these articles talking about
freedom, and when they see the articles they say, "Oh, that has nothing to do
with me, because that's about GNU, and I'm a Linux user, why should I care about
GNU. Now how ironic this is, if only they knew the system they call Linux if
mainly a GNU system. And that's the result of work, and we did it because we
care about our freedom, they might pay more attention, they might listen what we
were saying, and we might convince them to demand freedom for themselves. And
then they would be _join_ together_ with us to champion for freedom, and then we might
win. We need their help, and that means we need you to inform other people that this is
a GNU system, and it gives people freedom.
[applause]
( 1:00:52.6)
But the other obstacle is most of the users have never heard the term free
software, most of them hear and use a different term which stands for different
philosophy, different ideas entirely. And that term is "open source". Now I am
sure you'll be aware that I have not mention that term until this moment.
Because I support "free software" "自由软件", I don't support open source.
Because there are different ideas. What's the difference? Well, during the 1990s
as the GNU/Linux operating system gains popularity, the community had two
different camps, two different views, two different philosophies. There are
those of us who want freedom, say this software is good because it respects our
freedom. And when we say good, we mean good vs. evil. And there were the other camp
who says this software is good because it's reliable and efficient and powerful
and flexible and cheep, and when they say good, they mean good quality. And they
were looking at practical convenience values, and we were looking at ethical values.
Total different philosophies with different basic values _they_rest on. In
1998, the other camp chose the name "open source". So that's the big difference
between free software and "open source".
( 1:02:47.6)
The free software movement says, "We want freedom, we want social fidelity". The
"open source" camp says, "We want powerful reliable software". We say, "If a
program doesn't respect your freedom, that's wrong". They say, "If a program
does let you participate in the development, we were surprised if it was a good
job." They won't criticize anything on ethical level. The most they'll say is
they think that certain development model will lead to more powerful reliable
software. Well, may be they're right. If that's right, it's a nice bonus. If
freedom also gives us powerful and reliable, that's nice. I prefer powerful and
reliable software. But that's not the most important thing, there is something
more important than that, namely are freedom. So if you give me a choose between
in less powerful less reliable program that respects my freedom, and an totally
convenient proprietary program. I'm going to choose the free program. Because my
freedom is not negotiable.
[applause]
( 1:04:16.8)
Of course, what I really like to have is a program gives both advantages
together. I would like a powerful, reliable, convenient free software package.
And how are we going get that? If we start from the proprietary program, let's
propose the proprietary is already powerful, reliable and convenient, how are we
going to make it free? We can't. There is nothing we can do to make it free,
unless we would collect millions of dollars buy it from the company which I'm
sure we couldn't do. We can't make it free, There is nothing we do to make that
program free. But suppose we start from a free program which is not powerful,
reliable and convenient, all we need to do is technical work to make it
powerful, reliable and convenient, and we'll have everything we want. So the
result is this powerful, reliable proprietary program is a trap, if we make a
mistake of using that, we'll never get what we want the most, but if we start
with the free program, such as it is. And we put our work to make it better,
we'll get what we really want most. It's a matter of long-term thinking vs.
short-term thinking. And you'll find most of the time people who use proprietary
software is because of short-term thinking.
( 1:05:58.8)
Our society is full of messages from proprietary software developers that
encourage short-term thinking. They ask about where you want to go today and not
how you want to live in five years, ten years and twenty years.
[applause]
[RMS drinking]
( 1:06:25.1)
So these days we have to do more than just develop software. Because there are
enemies who are trying to ban free software for certain jobs. And they started
in US, but they are trying to do it in the whole world. For instance, one thing
you might want to with your computer is play a DVD. Well, DVDs have the video
encrypted and that format was originally secret. The reason they made it secret
was so they can design the DVD player to restrict you. And people figured out
the secret. And they released free software which decrypt the video from the
DVD. So then the video company, they got a lot of money, and they went to
congress, they pay the legislator to pass a law censoring that software, the US
practice of censorship of software, and censorship is of course discussing. So
we have to fight against a worldwide campaign to impose those laws on countries
around the world. And meanwhile they have developed another secret encryption
formats with the same purpose. They are trying to impose restrictions on how we
use our own copies of congruous works. And they are doing through proprietary
software that implements the restrictions. And because our communities are full
of clever people who could write free software to do the same job. The next
thing is they make it illegal. So we need to organize to fight this.
( 1:08:52.6)
Another thing that threaten our freedom to write free software is patent law. In
countries that allow software ideas to be patented. Any software developer is in
danger of being sued. Because when you write a program, you combine thousands of
different ideas together. Well if your country has a law that allow software
ideas to be patented, that means out of the thousands of ideas you combined, may
be hundreds of them are patented, which means hundreds of lawsuits. If you like
the idea that when you write a large program, you face a potential of hundreds of
lawsuits. Then you should support software patents. But if you don't like that
idea, then you should say that your country should not have software patents.
It's a foolish policy. It's only good for the mega corporations.
( 1:10:00.2)
You see, in many field a mega corporation typically own half of the patents. And
they cross-license each other. And they can force other companies to
cross-license with them. And the result is the mega corporations escape from
most of the problem. They've escape most of the harm done by the patents, and
that harm falls on anybody else who trying to get in the field. But in software
we can combine more different ideas into one product than any other field. The
reason is software is fundamentally easier than physical engineering because
it's just math. So whereas other people, if they want to put an additional idea
into a product, they may have to do a lot of testing, a lot of research and so
on. We just have to write the code.
( 1:11:01.5)
So given a easier field we can combine more ideas into one program, than
somebody else could put one chemical process, or one circuit, or one phiscal
structure. And as a result, patents cause a bigger problem in our field than the
any other fields. So we need to make sure that software development is not
obstructed by prohibitions. That's what we mainly need. As long as they don't
prohibit us from writing free software, we'll. But these days we have to
organize to make sure they don't prohibit it. In addition, we have to convince
social institutions to stop promoting proprietary software. For instance, we
need to convince our governments to move to free software. Government agencies
must use exclusive free software, because a government agency does its computing
for the public, it's not doing computing for its own pleasure. You know you
could do computing for your own pleasure, you don't have to justify it to anyone
else, but when a government agency does computing, that's being done for the
public. Therefore the government agency has a responsibility to do it right for
the public, so every government agency must maintain _solvering_ control over the
computing it does. If you use a proprietary program, and therefore you lose your
control of you computing, that's unfortunate for you. But if a government agency
uses a proprietary program and loses its computing, that's worse than
unfortunate, that's a failure to carry out its duty as part of the state. So all
government agency must move to free software. They must maintain control of
their computing, so they can assure it's been done right.
( 1:13:32.2)
But even more important, the schools must move to free software. Every school
must teach exclusively free software, and there are four reasons for this. The
most superficial reason is to save money. Schools don't have enough money. In
any country, the schools are limited by lack of money, so they must not waste
some of the limited money paying for permission to run proprietary software. Now
this motivation is obvious, even to people who don't understand free software,
even if they think it's "免费", they'll still understand this reason. Even
though they really don't know what there are talking about. But this is
superficial reason, and there are some proprietary software developers have a
habit of eliminating this reason by donating gratis copies of their non-free
software to schools. And why they are do that? They are trying to turn the
schools into instruments of subjugation. They want the schools to make society
depend on that developers products. Here is how it works. They provide these
gratis copies to the school, the school teaches the students to use them, and
the students become depended on these companies product. And then, they graduate
with the dependence, and after they graduated, this developer does not offer
them gratis copies, and they go to work for companies, the developer does not
offer this companies gratis copies. So in a fact, the school imposing the direct
students on the path of dependence, and then they impose with them the rest of
the society, imposing dependence on all of the society. And the developer hopes
the society will never escape from the dependence. It's just like what the
tobacco company used to, when handed out gratis packages of cigarettes.
[applause]
( 1:16:11.3)
The first dose is gratis, once you were depended, then you have to pay. Now I'm
sure the schools would refuse to hand out addictive drugs, even if the school
didn't have to pay for them. And in the same way, the school should refuse to
teach non-free software, because the school has a social mission. The mission of
the schools is to educate the next generation as good citizens of a strong,
capable, independent, cooperating and free society. And in computing, this means
teaching them to use free software.
( 1:17:03.4)
But there is a deeper reason. And that is for the education of the best
programmers. You see, some people are natural-born programmers, at the age of
ten to thirteen, they become fascinating with computers, and they want to learn
all about the computer and software. How does it do this? But when a student ask a
teacher, "How does the program do this?", if it is proprietary, the teacher can
only say, "I'm sorry, it's a secret, and we can find out". So education can't
begin. Proprietary software is the enemy of the spirit of education, and it
should not be tolerated in a school.
( 1:18:12.0)
But if a program is free, the teacher can explain as much as he knows, and then
say, "Here is the source code of the program, read it and you'll understand
everything". And our kid will read it all, because he is fascinating and yearn
to understand it, and the teacher can say, "If you come across any point, you
can't figure out, show it to me, and we'll figure it together". And in this way,
our natural-born programmers have an opportunities to learn something very
important, that is not clear, don't write it that way. You see, for a
natural-born programmer, how to program is obvious, how to program is different.
The way you learn good clear code, is by reading a lots of code and writing a
lots of code, only free software gives you the chance to read a lots of code
from really program people really use. In that way, you'll see what's clear and
what's not clear. And you can learn what good code is.
[applause]
( 1:19:28.2)
Furthermore, to write code for a large program, you have to start small. But
that doesn't mean small program. Because in a small program, you don't even see
the beginning of difficulties of a large program. So you have to start by
writing small changes in a existing large program. Only free software gives you
the chance to do that. To write a small change to improve an existing large
program. This is how I learned, I went to work at a lab where we have a free
software operating system, my job was to make it better, and my job was a system
hacker, it means somebody who works on a system. So I would read these various
programs and make a change to make it better, either fixing a bug or adding a
new feature. And then I would debug until people were happy, and then I would do
another change on another program, And I did it hundreds of times, and
eventually I learned to do it well. Today any school can offer the same
opportunity, but only if it is a free software school.
( 1:20:46.4)
But there is a even deeper reason for education in citizen ship, every school
must teach not just facts, not just skills, but above all how to be a good
citizen, how to help your neighbor, and that habit of helping your neighbor.
[applause]
( 1:21:12.2)
So every class must have this rule, "Students, if you bring software to class,
you can't keep it to yourself, you must share it with the rest of the students
and the teacher. Because a class is a place where we share our knowledge and
useful information. So if you bring some, you got to share it, and you got to
show the source code, so that people can learn how it works." But the school has
to set a good example, because people follow the example of the teacher, they
do more than listen to the words, so the teacher also must share software and
show the source code. The school must bring only free software to class. So how
is that going to happened? You are going to have to campaign for this to
happened.
( 1:22:20.8)
The biggest obstacle is social _inner_. So social _inner_ means society tends
to going to same direction it's already going. There are so many institutions
that use Windows and they don't want to change. And they keep pressure other
people to use Windows. Schools are teaching people Windows. Banks tell their
customers you have to use Windows. And in all around, you can find example of
this, so society is going down the path of dependence, it is subject to digital
colonization, this is a colonial system in which companies that develop
proprietary gain power over more users. So how do we reverse this? We have to
get together and say, "Escape from their power, don't be colonized". We have to
convince the institutions that surround us to support a society which is not a
_colonity_ of society. And how to do that is up to you.
( 1:24:38.5)
So I like to mention a couple of websites. For more information about the GNU
system and the free software movement and its philosophy, look at gnu.org.
For information about the free software foundation, look at fsf.org. In fsf.org
you can buy something, you can donate, you can find resources, our free software
directory lists 16000 useful free softwares, and you can find lists of hardware
that works well with free software. One of the problem we face today is that
there are many devices that require non-free software in order to function at
all. And the manufacture would tell us the specifications, and that stop us from
writing the free software that we need.
( 1:25:57.7)
And you can also look at the zeuux.org, which is the organization that put on
this event, and is the main Chinese organization for free software. So I'm going
to introduce to my another identity.
( 1:26:32.4)
[RMS putting on the dresses]
[la
I'm a saint of a _GNUers_ of the church of Emacs, I bless your computer, my
child. Emacs started out as a text editor, which became a way of life for many
users. Because it was an extensible text editor, and still is, and it was
extended so much that they could do all of their computing without leaving Emacs.
And then it became a church which belongs to GNU group.
which you might be amused to visit it.
Today in the church of Emacs, we have
So thank you.
( 1:30:27.9)