<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>2001 October 2</p>
<br><a href="ec29Sept.html"></a>
<h4>
  On Builds and Community Participation</h4>
<p>The statistics from two weeks ago are clear: over 62,000 downloads of the code, 
  a number that includes both binaries and source. The other figures, which measure 
  mail list subscribers and participation, are equally affirming. But why? Why 
  so many downloads? Why so much activity? Yes, the code is more usable than ever 
  before. And, yes, the community has become large enough that any growth is geometric, 
  meaning that we will expect to see big increases in downloads and participation. 
  But these causes don't seem fully to explain the effects.</p>
<p>The numbers, of course, need some interpretation. Some people may be downloading 
  more than once, for instance. But it seems overwhelmingly the case that OpenOffice.org 
  is now reaching a large number of endusers. Doubtless, one clear reason is because 
  OpenOffice.org is more usable now than ever before. Build 638 is solid and functional; 
  it works--and it is free. These are strong inducements. And, its immediate successor, 
  the current download, Build 638c, has fixed some bugs and is even better. What 
  is more, and totally unique to OpenOffice.org, Kevin Hendricks' and the Mac 
  group have put together a Linux PPC build (for Macintoshes), which will run 
  on <a href="http://www.yellowdoglinux.com">Yellow Dog Linux</a> and probably 
  other Linuxes for the Macintosh. Information on where to download this build 
  will be available on the <a href="http://porting.openoffice.org/linuxppc/ppclinks.html" target="_blank">Mirrors</a> 
  page.</p>
<p>Build 638c, which contains much of the same code as StarOffice 6.0 Beta, needs 
  hard testing beginning now, so that the <i><a href="/dev_docs/source/download.html">next</a></i> 
  build (641) can reasonably claim the status of being ready for daily use. (Build 
  641 will likely be a more finished version of StarOffice 6.0.) A point of distinction: 
  StarOffice 6.0 is Sun's product that uses code taken from OpenOffice.org source. 
  But OpenOffice.org code is not fully congruent with StarOffice; there are significant 
  differences, not the least of which is that OpenOffice.org code is Open Source 
  and therefore open by the community for improvement. (Recently, the issue of 
  naming the releases and clarifying the identity of the community was raised; 
  I urge readers to go to the page and review the <a href="//about_us/communitypage.html">proposal</a>.)</p>
<p>So, I encourage all members to download the build and file issues using IssueZilla 
  when you come across problems. Remember, that to file an issue you must first 
  be a registered user of OpenOffice.org. There'll be more announcements regarding 
  how to send in bug reports later on this week and the next, but users can learn 
  now how to use IssueZilla by going to the <a href="../project_issues.html">Bugs 
  and Issues page</a>. </p>
<p>Filing issues will enable the project's developers to improve the code; it 
  is also a way in which <i>all</i> users can participate--and the way, quite 
  honestly, in which we can bring those users who simply want to use the code 
  into the OpenOffice.org community. For the number of downloads far exceeds the 
  number of registered users (between four and five thousand) and mail-list subscribers 
  (around 3600). The suite clearly appeals to users who are not actual participants 
  in the community. This is to be expected; and it is a sign of our so-far success, 
  that OpenOffice.org has gone from primarily being &quot;pre-alpha&quot; to something 
  recognized as usable by tens of thousands of people outside the narrow circumference 
  of our community. But we need all those &quot;eyeballs&quot; (as Linus Torvalds 
  has described the regular user) to send in all the bugs they find and issues 
  they have with the software. Otherwise, despite our growing popularity and increased 
  visibility, the code will not develop as quickly.</p>
<p>And--get this--OpenOffice.org has done virtually no marketing, conducted no 
  expensive advertising campaigns, hired no strategists to get the word out. But 
  Microsoft has, and it is my guess that in addition to offering a product that 
  works beautifully, we are also offering something--a product and attitude and 
  community--that is also beautiful. Not harshly suspicious of its clientele, 
  not burdensome. Rather an environment that is friendly and by and large supportive 
  of people's ideas and work (however sometimes contentious!): a community. </p>
<p>So, if you have not already registered with OpenOffice.org, please <a href="//servlets/Join" target="_blank">do 
  so</a>. We need your help in perfecting the coming build, which will not only 
  be ready for every-day use, but may also function as a beta for Sun's Star Office. 
  And if you want things included in future builds of OpenOffice.org, there is 
  no better way to express your desires than to join the projects building the 
  code.</p>
<p>Along these, lines, our popularity prompts some evaluation of our current structure 
  and relation to the enduser. To this end, we now have a <a href="http://whiteboard.openoffice.org/marketing/" target="_blank">marketing 
  project</a> in the <a href="http://whiteboard.openoffice.org/" target="_blank">Whiteboard</a> 
  (where community-sponsored projects are located), and a recently created <a href="http://ui.openoffice.org/" target="_blank">User 
  Interface</a> project. I urge members to visit the project, which was created 
  and is managed by Oliver Specht, and to join in, if they can.</p>
<p>Both projects point to the recognition among community members that OpenOffice.org 
  is maturing. Given that our anniversary is fewer than two weeks away, the timing 
  is apt. We will be able to announce to the world that we have succeeded in ways 
  that decisively trounce any skepticism about Open Source development projects 
  and about the ability to build an office software suite that doesn't just try 
  to copy what Microsoft's Office does but rather builds something new: code and 
  community that works together</p>
<p>&nbsp;
<p><a href="index.html">Previous articles</a>
</body>
</html>

