<html><head>
<meta HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8">
</head>
<body>

<h2>Editor's Column</h2>
<p>-<a href="../lspintro.html">Louis Suarez-Potts</a></p>

<p>19 December 2000</p>
<h4>Sun's Open Door</h4>
<p>I begin this, my first column for OpenOffice.org, with a direct question: Can 
  OpenOffice.org be called subversive? The question, of course, stems from <a href="http://www.tuxedo.org/~esr/">Eric 
  Raymond</a>'s famous assertion in<i> <i><a href="http://www.tuxedo.org/~esr/writings/cathedral-bazaar/cathedral-bazaar/">The 
  Cathedral & the Bazaar</a></i> </i>that "Linux is subversive." "Subversive," 
  in that Linux, and by extension the open-source movement, has created a collaborative, 
  global network of hackers, developers, and idealists whose software is proving 
  to be better--and certainly more efficiently produced--than anything that has 
  come before. </p>
<p>Sun's OpenOffice.org, however, differs from Linux, or for that matter, from 
  open-source efforts such as Mozilla or Apple's Darwin, in the nature and character 
  of the project's source code. And it is also much larger than Linux or Mozilla. 
  For these reasons, it is seemingly hard to cast OpenOffice.org into the same 
  role as Linux, which we can easily imagine as a kind of David fighting a lumbering 
  Goliath. Bruce Perens, for instance, was initially quite <a href="http://www.perens.com/Articles/StarOffice.html">skeptical</a> 
  of Sun's motives. But when he learned that Sun was releasing the nine million 
  lines of source code for StarOffice[tm] under the <a href="../license.html">GNU 
  General Public License</a> (Sun also uses the <a href="../license.html">Sun 
  Industry Standards Source License</a>, or SISSL), Perens publicly retracted 
  his objections. Sun, in short, is fully committed to the open-source movement. 
  To answer the question I raised above then, Yes, OpenOffice.org can and should 
  be thought of as subversive, at least in the sense that Eric Raymond meant. 
</p>
<p>But the hugeness and importance of the OpenOffice.org software permanently 
  alters the nature of that subversion. In fact, OpenOffice.org's size and Sun's 
  entry into the open-source movement marks a sea change in software development. 
  It demonstrates that open source has come of age, and is now a plausible (if 
  not yet automatic) option for very large software projects. And if we succeed, 
  as I'm sure we will, it would go a great distance to forcing any sponsoring 
  body to consider open source.</p>
<p>All the same, the move to open source is difficult for corporations to make. 
  It's also fascinating to see in progress. In my next Editor's Column, I look 
  at the problematic 613 build and trace the way the community addressed (and 
  continues to address) those problems. </p>
</body>
</html>

