<html><head>
<meta HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8">
</head>
<body>
<h2> Community Articles: Opinions, Interviews, Analyses</h2>
<p><a href="//lspintro.html" target="_blank">-Louis Su&aacute;rez-Potts</a></p>
 
<p>7 June 2001<br>
  <br>
</p> 
 
 <h4>Interview: Richard M. Stallman</h4>
 
 
<P>Richard M. Stallman is the most forceful and famous practitioner/theorist of 
  <a href="http://www.salon.com/tech/fsp/glossary/index.html" target="_blank">free 
  software</a>, a termed he coined. "Free" here means free as in "free speech," 
  not free as in "free beer." Stallman's most famous intervention in the "free 
  software" movement has surely been the GNU General Public License (<a href="http://www.gnu.org/philosophy/license-list.html" target="_blank">GPL</a>), 
  which Stallman created around 1985 as a general license that could be applied 
  to any program. The license codifies the concept of "<a href="http://www.gnu.org/gnu/thegnuproject.html" target="_blank">copyleft</a>," 
  the "central idea" of which Stallman has described as giving "everyone permission 
  to run the program, copy the program, modify the program, and distribute modified 
  versions, but not permission to add restrictions of their own. Thus, the crucial 
  freedoms that define 'free software' are guaranteed to everyone who has a copy; 
  they become inalienable rights" (Stallman, "The GNU Operating System and the 
  Free Software Movement," in DiBona, <i><a href="http://www.oreilly.com/catalog/opensources/" target="_blank">Open 
  Sources: Voices from the Open Source Revolution</a></i>) 
<P> Every free-software license since probably owes its existence to Stallman's 
  vision, including those licenses by which OpenOffice.org code is governed. Stallman's 
  work is of course resolutely practical. A short list of his coding accomplishments 
  would include Emacs as well as most of the components of the GNU/Linux system, 
  which he either wrote or helped write. In 1990, Stallman received a <a href="http://www.macfound.org/programs/fel/fel_overview.htm" target="_blank">McArthur 
  Foundation</a> fellowship; he has used the funds given him to further his free 
  software work. (See Moody, <i><a href="http://www.amazon.com/exec/obidos/ASIN/0738203335/o/qid%3D992034308/sr%3D2-1/ref%3Daps_sr_b_1_1/107-7127906-0194109" target="_blank">Rebel 
  Code</a></i> for a good account of Stallman's mission.) 
<P> The opportunity for this interview arose when I saw Stallman lecture at Sun's 
  Cupertino campus in May. At that time, I requested an email interview with Stallman. 
  He assented, and shortly after, I submitted the series of questions below, to 
  which he responded, often at length. However, my efforts for a follow-up failed, 
  so this interview is only the first pass. As a consequence, I was unable to 
  extend (and challenge) some interesting avenues; I have also provided as much 
  context as possible for Stallman's politics in the links. It goes without saying 
  that Stallman's views are his own and do not necessarily represent mine or those 
  of OpenOffice.org. 
<P> For more information, readers are encouraged to visit the <a href="http://www.gnu.org" target="_blank">GNU website</a>, as well as <a href="http://www.stallman.org" target="_blank">Stallman's personal site</a>. 

<P> <i>I would like, in this interview, to focus on your current work, and on the problematic of what kind of society we should like to live in. Your focus  now--and for at least the last seventeen years--has been on working to make  the social arrangements for using software more ethical.</i>

<P><i>But, [briefly,] what do you mean by the notion of a what I call here a more ethical society?</i>

<P>We need to encourage the spirit of cooperation, by respecting other people's freedom to cooperate and not advancing schemes to divide and dominate them.
<br>
<br>

<P> <i>This takes us to a point that is quite important and that I am hoping you can clarify for our readers. The term you prefer for your ethic is "free software," where the word "free" means freedom from constraints and not free to take.  But the term that more and more people are using is "Open Source," a term of quite recent vintage (1998), and, from your perspective, filled with significant problems. Of the two, free software is a term that implies an ethic of living and holds out the promise of a more just society; the other, "open source," does not.</i>

<P><i>Is that a fair statement? Would you address that issue, and clarify the distinctions for our readers?</i>

<p>That is exactly right.  Someone once said it this way:  open source is a development methodology; free software is a political philosophy (or a social movement).

<P>The <a href="http://www.opensource.org/docs/definition.html" target="_blank">open source movement</a> focuses on convincing business that it can profit by respecting the users' freedom to share and change software. We in the <a href="http://www.fsf.org/" target="_blank">free software movement</a> appreciate those efforts, but we believe that there is a more important issue at stake: all programmers [owe] an ethical obligation to respect those freedoms for other people. Profit is not wrong in itself, but it can't justify mistreating other people.
<br>
<br>

<P><i>Along these lines, there has been considerable confusion over how to name your idea of an ethical society. Mistakenly, many would assert that you are suggesting a <a href="http://www.marxists.org/archive/marx/works/1840/prin-com.htm" target="_blank">communism</a>.</i>

<P>Anyone who criticizes certain business practices can expect to be called "communist" from time to time.  This is a way of changing the subject and evading the issue.  If people believe the charges, they don't listen to what the critics really say.  (It is much easier to attack communism than to attack the views of the free software movement.) 
<br>
<br>

<P><i> Pekka Himanen, in his recent work, the <a href="http://www.amazon.com/exec/obidos/ASIN/0375505660/o/qid%3D992035595/sr%3D2-1/ref%3Daps_sr_b_1_1/107-7127906-0194109" target="_blank">Hacker Ethic</a>, has rightly countered these claims. I would go further: that what you suggest is close to what political theorists such as <a href="http://www.gwu.edu/~ccps/etzioni/index.html" target="_blank">Amitai Etzioni</a> would describe as a communitarianism (see, for instance, <a href="http://www.gwu.edu/~icps/about.html" target="_blank">http://www.gwu.edu/~icps/about.html</a>). And communitariannism is by no means hostile to the market economy that most people associate with capitalism. Quite the opposite. Would you speak to what could be called the politics of your ethical system?</i>

<P>There is a place in life for business, but business should not be allowed dominate everyone's life.  The original idea of democracy was to give the many a way to check the power of the wealthy few.

<P> Today business (and its owners) has far too much political power, and this undermines democracy in the US and abroad.  Candidates face an effective veto by business (see <a href="http://www.billionairesforbushorgore.com" target="_blank">http://www.billionairesforbushorgore.org</a>), so they dare not disobey its orders.

<P> The power to make laws is being transferred from elected legislatures to nondemocratic bodies such as the <a href=" http://www.foreignpolicy-infocus.org/briefs/vol2/v2n14wto.html" target="_blank">World Trade Organization</a>, which was designed to subordinate public health, environmental protection, labor standards, and the general standard of living to the <a href="http://www.citizen.org/pctrade/gattwto/gatthome.html" target="_blank">interests of business</a>.  Under <a href="http://www.tradewatch.org/nafta/reports/5years.htm" target="_blank">NAFTA [North American Free Trade Associtation]</a>, a Canadian company which was convicted in Mississippi of anticompetitive practices is <a href="http://www.citizen.org/pctrade/nafta/cases/Loewen.htm" target="_blank">suing </a>for Federal compensation for its lost business due to the conviction.  They claim that NAFTA takes away states' right to make laws against anticompetitive practices.

<P> But business is not satisfied yet.  The proposed <a href="http://www.ftaa-alca.org/" target="_blank">FTAA [Free Trade Area of the Americas]</a>would require all governments to privatize their [public facilities] such as schools, water supply, record keeping, even social security.  This is what Bush wants <a href="http://www.fasttrack.org/" target="_blank">"fast track"</a> authority to push through.

<P> Peaceful protestors against the FTAA in Quebec were violently <a href="http://www.web.amnesty.org/web/news.nsf/WebAll/A781217116BC45BB80256A3F005AA069?OpenDocument" target="_blank">attacked</a> by police, who then blamed the fighting on the protestors.  One protestor standing on the street was shot in the throat with a plastic bullet at a range of 20 feet.  He is maimed for life, and seeks to press charges of attempted murder--if the cops will reveal who shot him.

<P> One protest organizer was attacked on the street by a gang that got out of a van, knocked him down, and beat him up.  When his friends came to the rescue, the gang revealed itself as undercover police and took him away.

<P>Whatever democracy survives the globalization treaties is likely to be crushed by the efforts to suppress <a href="http://www.stopftaa.org/" target="_blank">opposition to them</a>.
<br>
<br>

<P> <i>The most immediate criticism of your insistence on ethics would be that the ethic of free software is fine, but not relevant to the real world of business.</i>
<br>
<br>

<P>With over half the world's Web sites running on GNU/Linux and <a href="http://www.apache.org" target="_blank">Apache</a>, that is evidently just FUD.  You should not give such falsehoods credibility by appearing to take them seriously yourself. 
<br>
<br>

<P><i>I think it is worse to leave implicit lies unanswered than to address them directly. The thrust of my argument was that Microsoft, for instance, would and does claim that free software does not make money and rather loses money. They argue it's a bad idea all around. I don't think that Microsoft is to be ignored, just as the WTO should not be ignored.  But: my question was to suggest a rebuttal this self-evident FUD, not to credit the errors of others.</i>

<P> <i>So, I'll rephrase my question: Microsoft has <a href="http://www.microsoft.com/presspass/exec/craig/05-03sharedsource.asp" target="_blank">attacked </a>the GPL as business foolishness that is also bad for "America"  (whatever that means). They don't care about community ethics. How do you then counter their FUD, or for that matter, the FUD of those who share Microsoft's views?</i>

<p><i>Stallman did not respond to this query for clarification, but as it happened, 
  a <a href="http://www.gnu.org/events/rms-nyu-2001-transcript.txt" target="_blank">speech</a> 
  he recently presented at New York University responded to Microsoft's propaganda. 
  The Free Software Foundation has presented a <a href="http://www.gnu.org/press/2001-05-04-GPL.html" target="_blank">defense</a>, 
  of free software, as well.</i> <br>
<br>
<p><i>[To return to the interview....]</i>
<P><i>On a more individual level, how would you address the criticism of the person who would like to follow your ethical standards but feels she cannot because she wants also to make money from her intellectual work?</i>

<P>This hypothetical person appears to believe that developing free software is incompatible with being paid.  If so, she is misinformed--hundreds of people are now paid to develop free software. Some of them work for Sun.  She is challenging us to solve a problem that doesn't really exist.

<P>But what if she can't get one of these free software jobs?  That could happen--not everybody can get them today.  But it doesn't excuse developing proprietary software.  A desire for profit is not wrong in itself, but it isn't the sort of urgent overriding cause that could excuse mistreating others.  Proprietary software divides the users and keeps them helpless, and that is wrong.  Nobody should do that.

<P> So what should she do instead?  Anything else.  She could get a job in another field.  But she doesn't have to go that far--most software development is custom software, not meant to be published either as free software or as proprietary software.  In most cases, she can do that without raising an ethical issue.  It isn't heroism, but it isn't villainy either. 
<br>
<br>

<P><i>But copyright can be thought of as an author's friend.</i>

<P>In the age of the printing press, that was true: <a href="http://www.intellectual-property.gov.uk/std/resources/copyright/history.htm" target="_blank">copyright</a> was an industrial restriction on publishers, requiring them to pay the author of a book. It did not restrict the readers, because the actions it restricted were things only a publisher could do. 

<P> But this is not true any more.  Now copyright is a restriction on the public, for the sake of the publishers, who give the authors a small handout to buy their support against the public. 
<br>
<br>

<P><i>In the current situation, then, who benefits most from copyright?</i>

<P>The publishers. 
<br>
<br>

<P><i>Were I freelancing again, I would not want to release my works without the minimal security of payment for my labor copyright affords.</i>

<P>You could do that without copyright. It is part of your business dealings with the magazine you are writing for.

<P> But please note that I don't say copyright should be entirely abolished.  You can disagree with what I said, but it makes no sense to attack me for things I did not say.  What I said in my speech was that software which is published should be free.

<P><I>For a more detailed accounting of Stallman's views regarding copyright as extended to fields outside of software, readers are urged to go to the <a href="http://www.gnu.org" target="_blank">GNU web site</a>, and to Stallman's <a href="http://www.stallman.org/" target="_blank">personal site </a>. In particular, readers might want to look at "<a href="http://media-in-transition.mit.edu/forums/copyright/index_transcript.html" target="_blank">Copyright and Globalization in the Age of Computer Networks</a>" presented at the Massachusetts Institute of Technology in Cambridge, Massachusetts on 19 April 2001. Discussing his views on copyright as extended to non-software fields, Stallman mentioned, in the interview, "Those are ideas that I came to after some years of working on free software.  People asked me the question, 'How do these ideas extend to other kinds of information,' so in the 90s I started thinking about the question.  This speech gives my thought on the question."</i>
<br>
<br> 

<P> On another point: recently, Argentina became the first country to consider requiring all government offices to use free software (see, for instance, <a href="http://www.wired.com/news/business/0,1367,43529,00.html" target="_blank">http://www.wired.com/news/business/0,1367,43529,00.html</a>).

<P>I think the regulation is still being discussed--not adopted yet.
<br>
<br>

<P> <i>As far as I know, that is still the case.... However, whether the legislation has been implemented or not, the news is still encouraging, as at least free software is being considered seriously as a legitimate option. What does this (and other news) suggest regarding your future efforts? That is, are you going to pitch the cause more strongly to developing nations?</i>

<P>Yes. I am on my way to South Africa in two weeks [from the time of this writing, mid-May], and a Free Software Foundation is being started in India.  There is also great interest in Brazil. 
<br>
<br>

<P> <i>A last point. The so-called "Open Source" movement is by and large devoid of humor. Not so the "Free Software" movement. You, in your lectures and in your song, provide a gratifying humorousness. I'd like to finish by asking, What do you accomplish by this?</i>

<P>I accomplish mirth.  That's the hacker spirit--Ha Ha, Only Serious.
<br>
<br>

<p><a href="./editors.html">Previous Articles  </a></p> </body>
</html>

