Free Software. Freedom and Cooperation.

[Don Saklad]

read a transcript
http://www.gnu.org/events/rms-nyu-2001-transcript.txt

              Transcript of
      Richard M. Stallman's speech,
 "Free Software: Freedom and Cooperation"
New York University in New York, New York
              on 29 May 2001

URETSKY: I'm Mike Uretsky.  I'm over at the Stern
 School of Business.  I'm also one of the Co-Directors
 of the Center for Advanced Technology.  And, on behalf
 of all of us in the Computer Science Department, I
 want to welcome you here.  I want to say a few
 comments, before I turn it over to -- Ed, who is going
 to introduce the speaker.

The role of a University, is a place to foster debate,
 and to have interesting discussions.  And the role of
 a major university is to have particularly interesting
 discussions.  And this particular presentation, this
 seminar falls right into that mold.  I find the
 discussion of open source particularly interesting.
 In a sense, [Laughter]

STALLMAN: I do free software.  Open source is a
 different movement.  [Laughter] [Applause]

URETSKY: When I first started in the field in the
 '60's, basically software was free.  And we went in
 cycles.  It became free, and then software
 manufacturers, in the need to expand their markets,
 pushed it in other directions.  A lot of the
 developments that took place with the entry of PC
 moved in exactly the same kind of a cycle.

There's a very interesting French philosopher --
 Pierre Levy -- who talks about movement to this
 direction, and who talks about the move into
 cyberspace as not only relating to technology, but
 also relating to social restructuring, to political
 restructuring, through a change in the kinds of
 relationships that will improve the well-being of
 mankind.  And we're hoping that this debate is a
 movement in that direction; that this debate is
 something that cuts across a lot of the disciplines
 that normally act as solace within the University.
 We're looking forward to some very interesting
 discussions.  Ed?


SCHONBERG: I'm Ed Schonberg from the Computer Science
 Department at the Courant Institute.  Let me welcome
 you all to this event.  Introducers are usually, and
 particularly, a useless aspect of public
 presentations, but, in this case, actually, they serve
 a useful purpose as Mike easily demonstrated.  Because
 an introducer for instance, told him, by making
 inaccurate comments, can allow him to straighten out
 and correct and [Laughter] sharpen considerably the
 parameters of the debate.

So, let me make the briefest, possible introduction to
 somebody, who doesn't need one.  Richard is the
 perfect example of somebody who, by acting locally,
 started thinking globally from problems concerning the
 unavailability of source code for printer drivers at
 the AI Lab many years ago.  He has developed a
 coherent philosophy that has forced all of us to
 re-examine our ideas of how software is produced, of
 what intellectual property means, and what the
 software community actually represents.  Let me
 welcome, Richard Stallman.  [Applause]


STALLMAN: Can someone lend me a watch?  [Laughter]
 Thank you.  So, I'd like to thank Microsoft for
 providing me the opportunity to [Laughter] be on this
 platform.  For the past few weeks, I have felt like an
 author whose book was fortuitously banned somewhere.
 [Laughter] Except that all the articles about it are
 giving the wrong author's name, because Microsoft
 describes the GNU GPL as an open source license, and
 most of the press coverage followed suit.  Most
 people, of course just innocently don't realize that
 our work has nothing to do with open source; that, in
 fact, we did most of it before people even coined the
 term "open source".

We are in the Free Software Movement, and I'm going to
 speak about what the free software movement is about,
 what it means, what we have done, and because this is
 partly sponsored by a School of Business, I'll say
 some things more than I usually do about how free
 software relates to business, and some other areas of
 social life.

Now, some of you may not ever write computer programs,
 but perhaps you cook.  And if you cook, unless you're
 really great, you probably use recipes.  And, if you
 use recipes, you've probably had the experience of
 getting a copy of a recipe from a friend who's sharing
 it.  And you've probably also had the experience --
 unless you're a total neophyte -- of changing a
 recipe.  You know, it says certain things, but you
 don't have to do exactly that.  You can leave out some
 ingredients.  Add some mushrooms, 'cause you like
 mushrooms.  Put in less salt because your doctor said
 you should cut down on salt -- whatever.  You can even
 make bigger changes according to your skill.  And if
 you've made changes in a recipe, and you cook it for
 your friends and they like it, one of your friends
 might say "Hey, could I have the recipe?"  And then,
 what do you do?  You could write down your modified
 version of the recipe, and make a copy for your
 friend.  These are the natural things to do with
 functionally useful recipes of any kind.

Now a recipe is a lot like a computer program.  A
 computer program's a lot like a recipe.  A series of
 steps to be carried out to get some result that you
 want.  So it's just as natural to do those same things
 with computer programs.  Hand a copy to your friend.
 Make changes in it because the job it was written to
 do isn't exactly what you want.  It did a great job
 for somebody else, but your job is a different job.
 And, after you've changed it, that's likely to be
 useful for other people.  Maybe they have a job to do
 that's like the job you do.  So, they ask, hey can I
 have a copy?  Of course, if you're a nice person,
 you're going to give a copy.  That's the way to be a
 decent person.

So imagine what it would be like if recipes were
 packaged inside black boxes -- You couldn't see what
 ingredients they're using, let alone change them --
 And imagine, if you made a copy for a friend, they
 would call you a pirate, and try to put you in prison
 for years.  That world would create tremendous outrage
 from all the people who are used to sharing recipes.
 But that is exactly what the world of proprietary
 software is like.  A world in which common decency
 towards other people is prohibited or prevented.

Now, why did I notice this?  I noticed this because I
 had good fortune, in the 1970's, to be part of a
 community of programmers who shared software.  Now,
 this community could trace its ancestry, essentially
 back to the beginning of computing.  In the 1970's
 though, it was a bit rare for there to be a community
 where people shared software.  And, in fact, this was
 sort of an extreme case, because in the lab where I
 worked, the entire operating system was software
 developed by the people in our community, and we'd
 share any of it with anybody.  Anybody was welcome to
 come and take a look and take away a copy, and do
 whatever he wanted to do.  There were no copyright
 notices on these programs.  Cooperation was our way of
 life.  And we were secure in that way of life.  We
 didn't fight for it.  We didn't have to fight for it.
 We just lived that way.  And, as far as we knew, we
 would just keep on living that way.  So there was free
 software, but there was no free software movement.

But then, our community was destroyed by a series of
 calamities that happened to it.  Ultimately it was
 wiped out.  Ultimately, the PDP-10 computer which we
 used for all our work was discontinued.  And you know,
 our system -- the Incompatible Timesharing System --
 was written starting in the '60's, so it was written
 in assembler language.  That's what you used to write
 an operating system in the '60's.  So, of course,
 assembler language is for one particular computer
 architecture; if that gets discontinued, all your work
 turns into dust -- it's useless.  And that's what
 happened to us.  The 20 years or so of work of our
 community turned into dust.

But before this happened, I had an experience that
 prepared me, helped me see what to do, helped prepare
 me to see what to do when this happened, because at
 certain point, Xerox gave the artificial intelligence
 lab, where I worked, a laser printer, and this was a
 really handsome gift, because it was the first time
 anybody outside Xerox had a laser printer.  It was
 very fast, printed a page a second, very fine in many
 respects, but it was unreliable, because it was really
 a high-speed office copier that had been modified into
 a printer.  And you know, copiers jam, but there's
 somebody there to fix them.  The printer jammed and
 nobody saw.  So it stayed jammed for a long time.

Well, we had an idea for how to deal with this problem.
 Change it so that whenever the printer gets a jam, the
 machine that runs the printer can tell our timesharing
 machine, and tell the users who are waiting for
 printouts, or something like that, you know, tell
 them, go fix the printer.  Because if they only knew
 it was jammed, of course, if you're waiting for a
 printout, and you know that the printer is jammed, you
 don't want to sit and wait forever, you're going to go
 fix it.

But, at that point, we were completely stymied, because
 the software that ran that printer was not free
 software -- it had come with the printer, and it was
 just a binary.  We couldn't have the source code --
 Xerox wouldn't let us have the source code.  So,
 despite our skill as programmers -- after all, we had
 written our own timesharing system -- we were
 completely helpless to add this feature to the printer
 software.

And we just had to suffer with waiting -- it would take
 an hour or two to get your printout because the
 machine would be jammed most of the time.  And only
 once in a while -- you'd wait an hour figuring "I know
 it's going to be jammed, I'll wait an hour and go
 collect my printout," and then you'd see that it had
 been jammed the whole time, and in fact, nobody else
 had fixed it.  So you'd fix it and you'd go wait
 another half hour.  Then, you'd come back, and you'd
 see it jammed again -- before it got to your output.
 It would print three minutes and be jammed thirty
 minutes.  Frustration up the whazzoo...  But the thing
 that made it worse was knowing that we could have
 fixed it, but somebody else, for his own selfishness,
 was blocking us, obstructing us from improving the
 software.  So, of course, we felt some resentment.

And then I heard that somebody at Carnegie Mellon
 University had a copy of that software.  So I was
 visiting there later, so I went to his office and I
 said, "Hi, I'm from MIT, could I have a copy of the
 printer source code?"  And he said "No, I promised not
 to give you a copy." [Laughter] I was stunned.  I was
 so -- I was angry, and I had no idea how I could do
 justice to it.  All I could think of was to turn
 around on my heel, and walk out of his room.  Maybe I
 slammed the door.  [Laughter] And I thought about it
 later on, because I realized that I was seeing not
 just an isolated jerk, but a social phenomenon that
 was important and affected a lot of people.

This was -- for me -- I was lucky, I only got a taste
 of it, but other people had to live in this all the
 time.  So I thought about it at length.  See, he had
 promised to refuse to cooperate with us -- his
 colleagues at MIT.  He had betrayed us.  But he didn't
 just do it to us.  Chances are he did it to you too.
 And I think, mostly likely, he did it to you
 too. [Laughter] And he probably did it to you as well.
 He probably did it to most of the people here in this
 room -- except a few maybe who weren't born yet in
 1980.  Because he had promised to refuse to cooperate
 with just about the entire population of the Planet
 Earth.  He had signed a non-disclosure agreement.

Now, this was my first, direct encounter with a
 non-disclosure agreement, and it taught me an
 important lesson -- a lesson that's important because
 most programmers never learn it.  You see, this was my
 first encounter with a non-disclosure agreement, and I
 was the victim.  I, and my whole lab, were the
 victims.  And the lesson it taught me was that
 non-disclosure agreements have victims.  They're not
 innocent.  They're not harmless.  Most programmers
 first encounter a non-disclosure agreement when
 they're invited to sign one.  And there's always some
 temptation -- some goody they're going to get if they
 sign.  So, they make up excuses.  They say, "well,
 he's never going to get a copy no matter what, so why
 shouldn't I join the conspiracy to deprive him?"  They
 say "this is the way it's always done.  Who am I to go
 against it?"  They say "if I don't sign this, someone
 else will."  Various excuses to gag their consciences.

But, when somebody invited me to sign a non-disclosure
 agreement, my conscience was already sensitized.  It
 remembered how angry I had been, when somebody
 promised not to help me and my whole lab solve our
 problem.  And I couldn't turn around and do the exact
 same thing to somebody else who had never done me any
 harm.  You know, if somebody asked me to promise not
 to share some useful information with a hated enemy, I
 would have said yes.  You know?  If somebody's done
 something bad, he deserves it.  But, strangers -- they
 haven't done me any harm.  How could they deserve that
 kind of mistreatment?  You can't let yourself start
 treating just anybody and everybody badly.  Then you
 become a predator on society.  So I said, thank you
 very much for offering me this nice software package.
 But I can't accept it in good conscience, on the
 conditions you are demanding, so I will do without it.
 Thank you so much.  And so, I have never knowingly
 signed a non-disclosure agreement for generally useful
 technical information, such as software.

Now, there are other kinds of information which raise
 different ethical issues.  For instance, there's
 personal information.  You know, if you wanted to talk
 with me about what was happening between you and your
 boyfriend, and you asked me not to tell anybody -- you
 know, I could keep -- I could agree to keep that a
 secret for you, because that's not generally useful
 technical information.

At least, it's probably not generally
 useful. [Laughter] There is a small chance -- and it's
 a possibility though -- that you might reveal to me
 some marvelous new sex technique, [Laughter] and I
 would then feel a moral duty [Laughter] to pass it
 onto the rest of humanity, so that everyone could get
 the benefit of it.  So, I'd have to put a proviso in
 that promise -- you know.  If it's just details about
 who wants this, and who's angry at whom, and things
 like that -- soap opera -- that I can keep private for
 you, but something that humanity could tremendously
 benefit from knowing, I mustn't withhold.  You see,
 the purpose of science and technology is to develop
 useful information for humanity to help people live
 their lives better.  If we promise to withhold that
 information -- if we keep it secret -- then we are
 betraying the mission of our field.  And this, I
 decided I shouldn't do.

But, meanwhile my community had collapsed, and that was
 collapsing, and that left me in a bad situation.  You
 see, the whole Incompatible Timesharing System was
 obsolete, because the PDP-10 was obsolete, and so,
 there was no way that I could continue working as an
 operating system developer the way that I had been
 doing it.  That depended on being part of the
 community using the community software, and improving
 it.  That no longer was a possibility, and that gave
 me a moral dilemma.  What was I going to do?  Because
 the most obvious possibility meant to go against that
 decision I had made.  The most obvious possibility was
 to adapt myself to the change in the world.  To accept
 that things were different, and that I'd just have to
 give up those principles, and start signing
 non-disclosure agreements for proprietary operating
 systems, and most likely writing proprietary software
 as well.  But I realized that that way I could have
 fun coding, and I could make money -- especially if I
 did it, other than at MIT -- but, at the end, I'd have
 to look back at my career and say "I've spent my life
 building walls to divide people," and I would have
 been ashamed of my life.

So I looked for another alternative, and there was an
 obvious one.  I could leave the software field, and do
 something else.  Now I had no other special noteworthy
 skills, but I'm sure I could have become a
 waiter. [Laughter] Not at a fancy restaurant, they
 wouldn't hire me, [Laughter] but I could be a waiter
 somewhere.  And many programmers, they say to me "the
 people who hire programmers demand this, this and this
 -- If I don't do those things, I'll starve."  It's
 literally the word they use.  Well, you know, as a
 waiter, you're not going to starve. [Laughter] So,
 really they're in no danger.  But -- and this is
 important, you see -- because sometimes you can
 justify doing something that hurts other people by
 saying "otherwise something worse is going to happen
 to me."  You know, if you were really going to starve,
 you'd be justified in writing proprietary
 software. [Laughter] If somebody's pointing a gun at
 you, then I would say it's forgivable. [Laughter] But,
 I had found a way that I could survive without doing
 something unethical, so that excuse was not available.
 So, I realized though that being a waiter would be no
 fun for me, and it would be wasting my skills as an
 operating system developer.  It would avoid misusing
 my skills.  Developing proprietary software would be
 misusing my skills.  Encouraging other people to live
 in the world of proprietary software would be misusing
 my skills.  So it's better to waste them than misuse
 them, but it's still not really good.

So for those reasons, I decided to look for some other
 alternative.  What can an operating system developer
 do that would actually improve the situation, make the
 world a better place?  And I realized that an
 operating system developer was exactly what was
 needed.  The problem, the dilemma, existed for me and
 for everyone else because all of the available
 operating systems for modern computers were
 proprietary.  The free operating systems were for old,
 obsolete computers, right?  So for the modern
 computers -- if you wanted to get a modern computer
 and use it, you were forced into a proprietary
 operating system.  So if an operating system developer
 wrote another operating system -- and then said,
 everybody come and share this, you're welcome to this
 -- that would give everybody a way out of the dilemma,
 another alternative.  So I realized that there was
 something I could do that would solve the problem.  I
 have just the right skills to be able to do it.  And
 it was the most useful thing I could possibly imagine
 that I'd be able to do with my life.  And it was a
 problem that no one else was trying to solve.  It was
 just sort of sitting there, getting worse, and nobody
 was there but me.  So I felt "I'm elected.  I have to
 work on this.  If not me, who?"  So, I decided I would
 develop a free operating system -- or die trying.  Of
 old age of course. [Laughter]

So, of course I had to decide what kind of operating
 system it should be -- there are some technical design
 decisions to be made.  I decided to make the system
 compatible with UNIX for a number of reasons.  First
 of all, I had just seen one operating system that I
 really loved, become obsolete because it was written
 for one particular kind of computer.  I didn't want
 that to happen again.  We needed to have a portable
 system.  Well, UNIX was a portable system.  So if I
 followed the design of UNIX, I had a pretty good
 chance that I could make a system that would also be
 portable and workable.  And furthermore, why[[24:44?]]
 be compatible with it in the details.  The reason is,
 users hate incompatible changes.  If I had just
 designed the system in my favorite way -- which I
 would have loved doing, I'm sure -- I would have
 produced something that was incompatible.  You know,
 the details would be different.  So, if I wrote the
 system -- then the users would have said to me "well,
 this is very nice, but it's incompatible.  It will be
 too much work to switch.  We can't afford that much
 trouble just to use your system instead of UNIX, so
 we'll stay with UNIX" they would have said.

Now, if I wanted to actually create a community where
 there would be people in it -- people using this free
 system, and enjoying the benefits of liberty and
 cooperation -- I had to make a system people would
 use, a system that they would find easy to switch to,
 that would not have an obstacle making it fail at the
 very beginning.  Now, making the system upward
 compatible with UNIX actually made all the immediate
 design decisions, because UNIX consists of many
 pieces, and they communicate through interfaces that
 are more or less documented.  So if you want to be
 compatible with UNIX, you have to replace each piece,
 one by one, with a compatible piece.  So, the
 remaining design decisions are inside one piece, and
 they could be made later by whoever decides to write
 that piece; they didn't have to be made at the outset.
 
So, all we had to do to start work was find a name for
 the system.  Now, we hackers always look for a funny
 or naughty name for a program, because thinking of
 people being amused by the name is half the fun of
 writing the program. [Laughter] And we had a tradition
 of recursive acronyms to say that the program that
 you're writing is similar to some existing program.
 You can give it a recursive acronym name which says --
 this one's not the other.  So, for instance, there
 were many Tico text editors in the '60's and '70's,
 and they were generally called something or other
 Tico.  Then one clever hacker called his Tint, for
 Tint Is Not Tico -- the first recursive acronym.  In
 1975, I developed the first Emacs text editor, and
 there were many imitations of Emacs, and a lot of them
 were called something or other Emacs, but one was
 called Fine -- for Fine Is Not Emacs, and there was
 Sine -- for Sine Is Not Emacs, and IINA for Ina Is Not
 Emacs, and MINCE for Mince Is Not Complete
 Emacs. [Laughter] That was a stripped down imitation.
 And, then, IINA was almost completely rewritten, and
 the new version was called ZWII[[27:42?]].  For, ZWII
 Was IINA Initially.  [Laughter]

So I looked for a recursive acronym for Something is
 not UNIX.  And I tried all 26 letters, and discovered
 that none of them was a word.  [Laughter] Hmm, try
 another way.  I made a contraction.  That way I could
 have a three-letter acronym, for Something's not UNIX.
 And I tried letters, and I came across the word "GNU"
 -- the word "GNU" is the funniest word in the English
 language. [Laughter] That was it.  Of course, the
 reason it's funny is that according to the dictionary,
 it's pronounced "new".  You see?  And so that's why
 people use it for a lot of word play.  Let me tell
 you, this is the name of an animal that lives in
 Africa.  And the African pronunciation had a click
 sound in it. [Laughter] Maybe still does.  And so, the
 European colonists, when they got there, they didn't
 bother learning to say this click sound.  So they just
 left it out, and they wrote a "G" which meant "there's
 another sound that's supposed to be here which we are
 not pronouncing."  [Laughter] So, tonight I'm leaving
 for South Africa, and I have begged them.  I hope
 they're going to find somebody who can teach me to
 pronounce click sounds. [Laughter] So that I'll know
 how to pronounce GNU the correct way, when it's the
 animal.

But, when it's the name of our system, the correct
 pronunciation is "guh-NEW" -- pronounce the hard "G".
 If you talk about the "new" operating system, you'll
 get people very confused, because we've been working
 on it for 17 years now, so it is not new any
 more. [Laughter] But it still is, and always will be
 GNU -- no matter how many people call it Linux by
 mistake. [Laughter]

So, in January 1984, I quit my job at MIT to start
 writing pieces of GNU.  They were nice enough to let
 me keep using their facilities though.  And, at the
 time, I thought we would write all these pieces, and
 make an entire GNU system, and then we'd say "come and
 get it" and people would start to use it.  That's not
 what happened.  The first pieces I wrote were just
 equally good replacements, with fewer bugs for some
 pieces of UNIX, but they weren't tremendously
 exciting.  Nobody particularly wanted to get them and
 install them.  But, then, in September 1984, I started
 writing GNU Emacs -- which was my second
 implementation of Emacs -- and by early 1985, it was
 working.  I could use it for all my editing, which was
 a big relief, because I had no intention of learning
 to use VI, the UNIX editor. [Laughter] So, until that
 time, I did my editing on some other machine, and
 saved the files through the network, so that I could
 test them.  But when GNU Emacs was running well enough
 for me to use it, it was also -- other people wanted
 to use it too.

So I had to work out the details of distribution.  Of
 course, I put a copy in the anonymous FTP directory,
 and that was fine for people who were on the net; they
 could then just pull over a tar file, but a lot of
 programmers then even were not on the Net in 1985.
 They were sending me emails saying "How can I get a
 copy?"  I had to decide what I would answer them.
 Well, I could have said, I want to spend my time
 writing more GNU software, not writing tapes, so
 please find a friend who's on the Internet, and who is
 willing to download it and put it on a tape for you.
 And I'm sure people would have found some friends,
 sooner or later, you know.  They would have got
 copies.  But I had no job.  In fact, I've never had a
 job since quitting MIT in January 1984.  So, I was
 looking for some way I could make money through my
 work on free software, and therefore I started a free
 software business.  I announced "send me $150 dollars,
 and I'll mail you a tape of Emacs."  And the orders
 began dribbling in.  By the middle of the year they
 were trickling in.

I was getting 8 to 10 orders a month.  And, if
 necessary, I could have lived on just that, because
 I've always lived cheaply; I live like a student,
 basically.  And I like that, because it means that
 money is not telling me what to do.  I can do what I
 think is important for me to do.  It freed me to do
 what seemed worth doing.  So, make a real effort to
 avoid getting sucked into all the expensive lifestyle
 habits of typical Americans.  Because if you do that,
 then people with the money will dictate what you do
 with your life.  You won't be able to do what's really
 important to you.

So, that was fine, but people used to ask me "What do
 you mean it's free software if it costs $150 dollars?"
 [Laughter] Well, the reason they asked this was that
 they were confused by the multiple meanings of the
 English word "free".  One meaning refers to price, and
 another meaning refers to freedom.  When I speak of
 free software, I'm referring to freedom, not price.
 So think of free speech, not free beer. [Laughter]
 Now, I wouldn't have dedicated so many years of my
 life to making sure programmers got less money.
 That's not my goal.  I'm a programmer and I don't mind
 getting money myself.  I won't dedicate my whole life
 to getting it, but I don't mind getting it.  And I'm
 not -- and therefore, ethics is the same for everyone.
 I'm not against some other programmer getting money
 either.  I don't want prices to be low.  That's not
 the issue at all.  The issue is freedom.  Freedom for
 everyone who's using software, whether that person be
 a programmer or not.

So at this point I should give you the definition of
 free software.  I better get to some real details, you
 see, because just saying "I believe in freedom" is
 vacuous.  There's so many different freedoms you could
 believe in, and they conflict with each other, so the
 real political question is "Which are the important
 freedoms, the freedoms that we must make sure
 everybody has?"  And now, I will give my answer to
 that question for the particular area of using
 software.

A program is free software for you, a particular user,
 if you have the following freedoms: First, Freedom
 Zero is the freedom to run the program for any
 purpose, any way you like.  Freedom One is the Freedom
 to help yourself by changing the program to suit your
 needs.  Freedom Two is the freedom to help your
 neighbor by distributing copies of the program.  And
 Freedom Three is the freedom to help build your
 community by publishing an improved version so others
 can get the benefit of your work.  If you have all of
 these freedoms, the program is free software, for you
 -- and that's crucial, that's why I phrase it that
 way.  I'll explain why later, when I talk about the
 GNU General Public License, but right now I'm
 explaining what free software means, which is a more
 basic question.

So, Freedom Zero's pretty obvious.  If you're not even
 allowed to run the program anyway you like, it is a
 pretty damn restrictive program.  But as it happens,
 most programs will at least give you Freedom Zero.
 And Freedom Zero follows, legally, as a consequence of
 Freedoms One, Two, and Three -- that's the way that
 Copyright Law works.  So, the freedoms that
 distinguish free software from typical software are
 Freedoms One, Two, and Three, so I'll say more about
 them and why they are important.  Freedom One is the
 freedom to help yourself by changing the software to
 suit your needs.  This could mean fixing bugs.  It
 could mean adding new features.  It could mean porting
 it to a different computer system.  It could mean
 translating all the error messages into Navajo.  Any
 change you want to make, you should be free to make.

Now, it's obvious that professional programmers can
 make use of this freedom very effectively, but not
 just them.  Anybody of reasonable intelligence can
 learn a little programming.  You know, there are hard
 jobs, and there are easy jobs, and most people are not
 going to learn enough to do hard jobs.  But lots of
 people can learn enough to do easy jobs, just the way,
 you know, 50 years ago, lots and lots of American men
 learned to repair cars, which is what enabled the
 U.S. to have a motorized Army in World War II and win.
 So, very important, having lots of people tinkering.
 And if you are a people person, and you really don't
 want to learn technology at all -- that probably means
 that you have a lot of friends, and you're good at
 getting them to owe you favors. [Laughter] Some of
 them are probably programmers.  So, you can ask one of
 your programmer friends "Would you please change this
 for me?  Add this feature?"  So, lots of people can
 benefit from it.

Now, if you don't have this freedom, it causes
 practical, material harm to society.  It makes you a
 prisoner of your software.  I explained what that was
 like with regard to the laser printer.  You know, it
 worked badly for us, and we couldn't fix it, because
 we were prisoners of our software.  But it also
 affects people's morale.  You know if the computer is
 constantly frustrating to use, and people are using
 it, their lives are going to be frustrating, and if
 they're using it in their jobs, their jobs are going
 to be frustrating; they're going to hate their jobs.
 And you know, people protect themselves from
 frustration by deciding not to care.  So, you end up
 with people whose attitude is "Well, I showed up for
 work today.  That's all I have to do.  If I can't make
 progress, that's not my problem, that's the boss's
 problem."  And when this happens, it's bad for those
 people, and it's bad for society as a whole.  That's
 Freedom One, the Freedom to help yourself.

Freedom Two is the Freedom to help your neighbor, by
 distributing copies of the program.  Now, for beings
 that can think and learn, sharing useful knowledge is
 a fundamental act of friendship.  When these beings
 use computers, this act of friendship takes the form
 of sharing software.  Friends share with each other.
 Friends help each other.  This is the nature of
 friendship.  And, in fact, this spirit of good will --
 the spirit of helping your neighbor, voluntarily -- is
 society's most important resource.  It makes the
 difference between a livable society and a dog-eat-dog
 jungle.  Its importance has been recognized by the
 world's major religions for thousands of years, and
 they explicitly try to encourage this attitude.

When I was going to kindergarten, the teachers were
 trying to teach us this attitude -- the spirit of
 sharing -- by having us do it.  They figured if we did
 it, we'd learn.  So they said "If you bring candy to
 school, you can't keep it all for yourself, you have
 to share some with the other kids."  Teaching us --
 the society was set up to teach this spirit of
 cooperation.  And why do you have to do that?  Because
 people are not totally cooperative.  That's one part
 of human nature, and there are other parts of human
 nature.  There are lots of parts of human nature.  So,
 if you want a better society, you've got to work to
 encourage the spirit of sharing.  You know, it'll
 never get to be 100%.  That's understandable.  People
 have to take care of themselves too.  But, if we make
 it somewhat bigger, we're all better off.

Nowadays, according to the U.S. Government, teachers
 are supposed to do the exact opposite.  Oh, Johnny,
 you brought software to school.  Well, don't share it.
 Oh no.  Sharing is wrong.  Sharing means you're a
 pirate.  What do they mean when they say "pirate"?
 They're saying that helping your neighbor is the moral
 equivalent of attacking a ship. [Laughter] What would
 Buddha or Jesus say about that?  Now, take your
 favorite religious leader.  I don't know -- maybe
 Manson would have said something different.
 [Laughter] Who knows what L. Ron Hubbard would say.
 But, ...

QUESTION: [Inaudible]

STALLMAN: Of course, he's dead.  But they don't admit
 that.  What?


QUESTION: So are the others, also dead.  [Laughter]
 [Inaudible] Charles Manson's also dead.  [Laughter]
 They're dead, Jesus's dead, Buddha's dead...


STALLMAN: Yes, that's true.  [Laughter] So I guess, in
 that regard, L. Ron Hubbard is no worse than the
 others.  [Laughter] Anyway -- [Inaudible]

QUESTION: L. Ron always used free software -- it freed
him from Zanu.

[Laughter]

STALLMAN: Anyway -- so, I think this is actually the
 most important reason why software should be free.  We
 can't afford to pollute society's most important
 resource.  It's true that it's not a physical resource
 like clean air, and clean water.  It's a psycho-social
 resource, but it's just as real for all that, and it
 makes a tremendous difference to our lives.  You see,
 the actions we take influence the thoughts of other
 people.  When we go around telling people "don't share
 with each other" -- if they listen to us -- we've had
 an effect on society, and it's not a good one.  That's
 Freedom Two, the freedom to help your neighbor.

Oh, and by the way, if you don't have that freedom --
 it doesn't just cause this harm to society's
 psycho-social resource -- it also causes waste --
 practical, material harm.  If the program has an
 owner, and the owner arranges a state of affairs where
 each user has to pay in order to be able to use it,
 some people are going to say "Nevermind, I'll do
 without it."  And that's waste, deliberately inflicted
 waste.  And the interesting thing about software, of
 course, is that fewer users doesn't mean you have to
 make less stuff.  You know, if fewer people buy cars,
 you can make fewer cars.  There's a saving there.
 There are resources to be allocated, or not allocated,
 into making cars.  So that you can say that having a
 price on a car is a good thing.  It prevents people
 from diverting lots of wasted resources into making
 cars that aren't really needed.  But, if each
 additional car used no resources, it wouldn't be doing
 any good saving the making of these cars.  Well, for
 physical objects, of course, like cars, it is always
 going to take resources to make an additional one of
 them.  Each additional exemplar.

But for software that's not true.  Anybody can make
 another copy.  And it's almost trivial to do it.  It
 takes no resources, except a tiny bit of electricity.
 So there's nothing we can save; no resource we're
 going to allocate better by putting this financial
 disincentive on the use of the software.  You often
 find people taking economic -- the consequences of
 economic reasoning, based on premises that don't apply
 to software, and trying to transplant them from other
 areas of life where the premises may apply, and the
 conclusions may be valid.  They just take the
 conclusions and assume that they're valid for software
 too -- when the argument is based on nothing in the
 case of software.  The premises don't work in that
 case.  It is very important to examine how you reach
 the conclusion, and what premises it depends on, to
 see where it might be valid.  So, thats Freedom Two,
 the freedom to help your neighbor.

Freedom Three is the freedom to help build your
 community by publishing an improved version of the
 software.  People used to say to me, if the software's
 free, then nobody will get paid to work on it, so why
 should anybody work on it?  Well, of course, they were
 confusing the two meanings of free, so their reasoning
 was based on a misunderstanding.  But, in any case,
 that was their theory.  Today, we can compare that
 theory with empirical fact, and we find that hundreds
 of people are being paid to write free software, and
 over 100,000 are doing it as volunteers.  We get lots
 of people working on free software, for various
 different motives.

When I first released GNU Emacs -- the first piece of
 the GNU system that people actually wanted to use --
 and when it started having users, after a while, I got
 a message saying "I think I saw a bug in the source
 code, and here's a fix."  And I got another message
 "Here's code to add a new feature."  And another bug
 fix.  And another new feature.  And another, and
 another, and another -- until they were pouring in on
 me so fast that just making use of all this help I was
 getting was a big job.  Microsoft doesn't have this
 problem. [Laughter]

Eventually, people noted this phenomenon.  You see, in
 the 1980's a lot of us thought that maybe free
 software wouldn't be as good as the non-free software,
 because we wouldn't have as much money to pay people.
 And, of course, people like me who value freedom and
 community said "Well, we'll use the free software
 anyway."  It's worth making a little sacrifice in some
 mere technical convenience to have freedom.  But what
 people began to note, around 1990 was that our
 software was actually better.  It was more powerful,
 and more reliable than the proprietary alternatives.

In the early '90's, somebody found a way to do a
 scientific measurement of reliability of software.
 Here's what he did.  He took several sets of
 comparable programs that did the same jobs -- the
 exact same jobs -- in different systems.  Because
 there were certain basic UNIX-like utilities.  And the
 jobs that they did, we know, was all, more or less,
 imitating the same thing, or they were following the
 POSIX spec, so they were all the same in terms of what
 jobs they did -- but they were maintained by different
 people, written separately.  The code was different.
 So they said, OK, we'll take these programs and run
 them with random data, and measure how often they
 crash, or hang.  So they measured it, and the most
 reliable set of programs was the GNU programs.  All
 the commercial alternatives which were proprietary
 software were less reliable.  So he published this and
 he told all the developers, and a few years later, he
 did the same experiment with the newest versions, and
 he got the same result.  The GNU versions were the
 most reliable.  People -- you know there are cancer
 clinics in 911 operations that use the GNU system,
 because it's so reliable, and reliability is very
 important to them.

Anyway, there's even a group of people who focus on
 this particular benefit as the reason they give -- the
 main reason they give -- why users should be permitted
 to do these various things, and to have these
 freedoms.  If you've been listening to me, you've
 noticed -- you've seen that I -- speaking for the free
 software movement -- I talk about issues of ethics,
 and what kind of a society we want to live in; what
 makes for a good society -- as well as practical
 material benefits.  They're both important.  That's
 the free software movement.

That other group of people -- which is called the "open
 source" movement -- they only cite the practical
 benefits.  They deny that this is an issue of
 principle.  They deny that people are entitled to the
 freedom to share with their neighbor, and to see what
 the program's doing, and change it if they don't like
 it.  They say, however, that it's a useful thing to
 let people do that.  So they go to companies and say
 to them "You know, you might make more money if you
 let people do this."  So, what you can see is that to
 some extent, they lead people in a similar direction,
 but for totally different -- for fundamentally
 different, philosophical reasons.  Because on the
 deepest issue of all, you know, on the ethical
 question, the two movements disagree.  You know, in
 the free software movement we say "You're entitled to
 these freedoms.  People shouldn't stop you from doing
 these things."  In the "open source" movement they
 say, "Yes, they can stop you if you want, but we'll
 try to convince them to deign to let you to do these
 things."  Well, they have contributed -- they have
 convinced a certain number of businesses to release
 substantial pieces of software as free software in our
 community.  So they -- the open source movement has
 contributed substantially to our community.  And so,
 we work together on practical projects.  But,
 philosophically, there's a tremendous disagreement.

Unfortunately, the open source movement is the one that
 gets the support of business the most, and so most
 articles about our work describe it as open source,
 and a lot of people just innocently think that we're
 all part of the open source movement.  So that's why
 I'm mentioning this distinction.  I want you to be
 aware that the free software movement, which brought
 our community into existence and developed the free
 operating system, is still here -- and that we still
 stand for this ethical philosophy.  I want you to know
 about this, so that you won't mislead someone else
 unknowingly.

But also, so that you can think about where you stand.
 You know, which movement you support is up to you.
 You might agree with the free software movements and
 my views.  You might agree with the open source
 movement.  You might disagree with them both.  You
 decide where you stand on these political issues.  But
 if you agree with the free software movement -- if you
 see that there's an issue here that the people whose
 lives are controlled and directed by this decision
 deserve a say in it -- then I hope you'll say that you
 agree with the free software movement, and one way you
 can do that is by using the term free software, and
 just helping people know we exist.

So, Freedom Three is very important both practically
 and psycho-socially.  If you don't have this freedom,
 it causes practical material harm, because this
 community development doesn't happen, and we don't
 make powerful, reliable software.  But it also causes
 psycho-social harm which affects the spirit of
 scientific cooperation -- the idea that we're working
 together to advance human knowledge.  You see,
 progress in science crucially depends on people being
 able to work together.  And nowadays though, you often
 find each little group of scientists acting like it's
 a war with each other gang of scientists and
 engineers.  And if they don't share with each other,
 they're all held back.

So, those are the three freedoms that distinguish free
 software from typical software.  Freedom One is the
 freedom to help yourself -- making changes to suit
 your own needs.  Freedom Two is the freedom to help
 your neighbor by distributing copies.  And Freedom
 Three is the freedom to help build your community by
 making changes and publishing them for other people to
 use.  If you have all of these freedoms, the program
 is free software for you.  Now, why do I define it
 that way in terms of a particular user?  Is it free
 software for you?  Is it free software for you?  Is it
 free software for you?  Yes?

QUESTION: Can you explain a bit about the difference
 between Freedom Two and Three?  [inaudible]

STALLMAN: Well, they certainly relate, because if you
 don't have freedom to redistribute at all, you
 certainly don't have freedom to distribute a modified
 version, but they're different activities.
 
QUESTION: Oh.

STALLMAN: Freedom Two is, you know, read it -- you make
 an exact copy and hand it to your friends, so now your
 friend can use it.  Or maybe you make exact copies and
 you sell them to a bunch of people, and then they can
 use it.  Freedom Three is where you make improvements
 -- or at least you think they're improvements, and
 some other people may agree with you.  So that's the
 difference.  Oh, and by the way, one crucial point.
 Freedoms One and Three depend on your having access to
 the source code.  Because changing a binary-only
 program is extremely hard. [Laughter] Even trivial
 changes like using four digits for the
 date. [Laughter]... if you don't have source.  So, for
 compelling, practical reasons, access to the source
 code is a pre-condition, a requirement for free
 software.

So, why do I define it in terms of whether it's free
 software for *you*?  The reason is that sometimes the
 same program can be free software for some people, and
 non-free for others.  Now, that might seem like a
 paradoxical situation, s, let me give you an example
 to show you how it happens.  A very big example --
 maybe the biggest ever of this problem was the X
 window system which was developed at MIT and released
 under a license that made it free software.  If you
 got the MIT version with the MIT license, you had
 Freedoms One, Two, and Three.  It was free software
 for you.  But among those who got copies, were various
 computer manufacturers that distributed UNIX systems,
 and they made the necessary changes in X to run on
 their systems.  You know, probably just a few thousand
 lines out of the hundreds of thousands of lines of X.
 And, then they compiled it, and they put the binaries
 into their UNIX system and distributed it under the
 same non-disclosure agreement as the rest of the UNIX
 system.  And then, millions of people got these
 copies.  They had the X window system, but they had
 none of these freedoms.  It was not free software for
 them.

So, the paradox was that whether X was free software
 depended on where you made the measurement.  If you
 made the measurement coming out of the developer's
 group, you'd say "I observe all these freedoms.  It's
 free software."  If you made the measurements among
 the users you'd say "Hmm, most users don't have these
 freedoms.  It's not free software."  Well, the people
 who developed X didn't consider this a problem,
 because their goal was just popularity -- ego,
 essentially.  They wanted a big professional success.
 They wanted to feel "ah, lots of people are using our
 software."  And that was true.  Lots of people were
 using their software, but didn't have freedom.

Well, in the GNU project, if that same thing had
 happened to GNU software, it would have been a
 failure, because our goal wasn't just to be popular;
 our goal was to give people liberty, and to encourage
 cooperation, to permit people to cooperate.  Remember,
 never force anyone to cooperate with any other person,
 but make sure that everybody's allowed to cooperate;
 everyone has the freedom to do so, if he or she
 wishes.  If millions of people were running non-free
 versions of GNU, that wouldn't be success at all; the
 whole thing would have been perverted into nothing
 like the goal.

So, I looked for a way to stop that from happening.
 The method I came up with is called "copyleft".  It's
 called copyleft because it's sort of like taking
 copyright and flipping it over. [Laughter] Legally,
 copyleft works based on copyright.  We use the
 existing copyright law, but we use it to achieve a
 very different goal.  Here's what we do.  We say "This
 program is copyrighted."  And, of course, by default,
 that means it's prohibited to copy it, or distribute
 it, or modify it.  But then we say, "You're authorized
 to distribute copies of this.  You're authorized to
 modify it.  You're authorized to distribute modified
 versions, and extended versions.  Change it anyway you
 like."

But there is a condition.  And the condition, of course
 -- is the reason why we go to all this trouble -- so
 that we could put the condition in.  The condition
 says-- whenever you distribute anything that contains
 any piece of this program, that whole program must be
 distributed under these same terms -- no more and no
 less.  So, you can change the program and distribute a
 modified version.  But when you do, the people who get
 that from you must get the same freedom that you got
 from us.  And not just for the parts of it -- the
 excerpts that you copied from our program -- but also
 for the other parts of that program that they got from
 you.  The whole of that program has to be free
 software for them.

The freedoms to change and re-distribute this program
 become inalienable rights---a concept from the
 Declaration of Independence.  Rights that we make sure
 can't be taken away from you.  And, of course, the
 specific license that embodies the idea of copyleft is
 the GNU General Public License.  A controversial
 license -- because it actually has the strength to say
 no to people who would be parasites on our community.

There are lots of people who don't appreciate the
 ideals of freedom.  And we'd be very glad to take the
 work that we have done, and use it to get a head start
 in distributing a non-free program and tempting people
 to give up their freedom.  And the result would be --
 you know, if we let people do that -- that we would be
 developing these free programs, and we'd constantly
 have to compete with improved versions of our own
 programs.  That's no fun.  And, a lot of people also
 feel -- you know, I'm willing to volunteer my time to
 contribute to the community, but why should I
 volunteer my time to contribute to that company's --
 to improving that company's proprietary program?  You
 know, some people might not even think that that's
 evil - but they want to get paid if they're going to
 do that.  I, personally, would rather not do it at
 all.  But, both of these groups of people -- both the
 ones like me who say -- I don't want to help that
 non-free program to get a foothold in our community --
 and the ones that say, sure, I'd work for them, but
 then they better pay me -- both of us have a good
 reason to use the GNU General Public License.  Because
 that says to that company -- you can't just take my
 work, and distribute it without the freedom.  Whereas,
 the non-copyleft licenses -- like the X Windows
 license, do permit that.

So that is the big division between the two categories
 of free software -- license-wise.  There are the
 programs that are copylefted -- so that the license
 defends the freedom of the software for every user.
 And there are the non-copylefted programs for which
 non-free versions are allowed.  Somebody *can* take
 those programs and strip off the freedom.  You may get
 that program in a non-free version.  And that problem
 exists today.  There are still non-free versions of X
 Windows being used on our free operating systems.
 There is even hardware --- which is not really
 supported --- except by a non-free version of X
 Windows.  And that's a major problem in our community.
 Nonetheless, I wouldn't say that X Windows is a bad
 thing -- you know, I'd say that the developers did not
 do the best possible thing that they could have done.
 But they *did* release a lot of software that we could
 all use.

You know, there's a big difference between less than
 perfect, and evil.  There are many gradations of good
 and bad.  We have to resist the temptation to say ---
 if you didn't do the absolute best possible thing then
 you're no good.  You know, the people that developed X
 Windows made a big contribution to our community.
 But, there's something better that they could have
 done.  They could have copylefted parts of the
 program, and prevented those freedom-denying versions
 from being distributed by others.  Now, the fact that
 the GNU General Public License defends your freedom
 --- uses copyright law to defend your freedom --- is,
 of course, why Microsoft is attacking it today.  See,
 Microsoft would really like to be able to take all the
 code that we wrote and put it into proprietary
 programs.  Have somebody make some improvements, or
 even just incompatible changes is all they
 need. [Laughter]

You know, with Microsoft's marketing clout, they don't
 need to make it better to have their version supplant
 ours.  They just have to make it different and
 incompatible.  And then, put it on everybody's
 desktop.  So they really don't like the GNU GPL.
 Because the GNU GPL won't let them do that.  It
 doesn't allow embrace and extend.  It says, if you
 want to share our code in your programs, you can.
 But, you've got to share and share alike.  The changes
 that you make we have to be allowed to share.  So,
 it's a two-way cooperation, which is real cooperation.

Many companies --- even big companies like IBM and HP
 are willing to use our software on this basis.  IBM
 and HP contribute substantial improvements to GNU
 software.  And they develop other free software.  But,
 Microsoft doesn't want to do that, so they give it out
 that businesses just can't deal with the GPL.  Well,
 if businesses don't include IBM, and HP and SUN then
 maybe they're right. [Laughter]

More about that later.  I should finish the historical
 story.  You see, we set out in 1984 --- not just to
 write some free software --- but to do something much
 more coherent: to develop an operating system that was
 entirely free software.  So that meant we had to write
 piece after piece after piece.  Of course, we were
 always looking for shortcuts.  The job was so big that
 people said we'd never be able to finish.  And, I
 thought that there was at least a chance that we'd
 finish it but, obviously, it's worth looking for
 shortcuts.  So we kept looking around --- is there any
 program that somebody else has written that we could
 manage to adapt, to plug into here, and that way we
 won't have to write it from scratch?  For instance,
 the X-Window system --- it's true it wasn't
 copylefted, but it was free software --- so we could
 use it.

Now, I had wanted to put a Window system into GNU from
 Day One.  I wrote a couple of Window systems at MIT
 before I started GNU.  And so, even though Unix had no
 window system in 1984, I decided that GNU would have
 one.  But, we never ended up writing a GNU Window
 System, because X came along.  And I said, goody!  One
 big job we don't have to do.  We'll use X.  So I
 basically said, let's take X, and put it into the GNU
 system.  And we'll make the other parts of GNU, you
 know, work with X, when appropriate.  And we found
 other pieces of software that had been written by
 other people, like the Text Formatter TeX.  Some
 library code from Berkeley.  At that time there was
 Berkeley Unix --- but it was not free software.  This
 library code, initially, was from a different group at
 Berkeley, that did research on floating point.  And,
 so, we kept --- we fit in these pieces.

In October 1985, we founded the Free Software
 Foundation.  So please note, the GNU project came
 first.  The Free Software Foundation came after.
 About almost two years after the announcement of the
 project.  And the Free Software Foundation is a
 tax-exempt charity, that raises funds to promote the
 freedom to share and change software.  And in the
 1980's, one of the main things we did with our funds
 was to hire people to write parts of GNU.  And,
 essential programs, such as the Shell and the
 C-Library were written this way, as well as parts of
 other programs.  The tar program, which is absolutely
 essential -- although not exciting at all [Laughter]
 was written this way.  I believe GNU grep was written
 this way.  And so, we're approaching our goal.

By 1991, there was just one major piece missing, and
 that was the kernel.  Now, why did I put off the
 kernel?  Probably because it doesn't really matter
 what order you do the things in, at least,
 technically, it doesn't.  You've got to do them all
 anyway.  And, partly, because I'd hoped we'd be able
 to find a start at a kernel somewhere else.  And we
 did.  We found Mach, which had been developed at
 Carnegie Mellon.  And, it wasn't the whole kernel, it
 was the bottom half of the kernel.  So we had to write
 the top half, but I figured you know, things like the
 file system, the network code, and so on.  But running
 on top of Mach they're running essentially as user
 programs, which ought to make them easier to debug.
 You can debug with a real source-level debugger
 running at the same time.  And so, I thought, that
 way, we'd be able to get these, the higher level parts
 of the kernel, done in a short time.  It didn't work
 out that way.  These asynchronous, multi-threaded
 processes, sending messages to each other, turned out
 to be very hard to de-bug.  And the Mach-based system
 that we were using to bootstrap with, had a terrible
 debugging environment, and it was unreliable, and
 various problems.  It took us years and years to get
 the GNU kernel to work.

But, fortunately, our community did not have to wait
 for the GNU kernel.  Because in 1991, Linus Torvalds
 developed another free kernel called Linux.  And he
 used the old-fashioned monolithic design and it turns
 out that he got his working much faster than we got
 ours working.  So maybe that's one of the mistakes
 that I made: that design decision.  Anyway, at first,
 we didn't know about Linux, because he never contacted
 us to talk about it.  Although he did know about the
 GNU project.  But he announced it to other people, and
 other places on the Net.  And so, other people then,
 did the work of combining Linux with the rest of the
 GNU system to make a complete free operating system.
 Essentially, to make the GNU plus Linux combination.

But, they didn't realize that's what they were doing.
 You see, they said, we have a kernel --- let's look
 around and see what other pieces we can find to put
 together with the kernel.  So, they looked around --
 and low, and behold -- everything they needed was
 already available.  What good fortune, they said.
 [Laughter] It's all here.  We can find everything we
 need.  Let's just take all these different things and
 put it together, and have a system.  They didn't know
 that most of what they found was pieces of the GNU
 system.  So they didn't realize that they were fitting
 Linux into the gap and the GNU system.  They thought
 they were taking Linux and making a system out of
 Linux.  So they called it a Linux system.