<html><head>
<meta HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8">
</head>
<body>
<h2>Newsletter #6</h2>
<p><em>2002-07-03</em></p>
<br>
<h4>New Projects</h4>
<p>
Everyone knows OpenOffice.org is large.  But here is a figure that gives a sense of the magnitude of this Open Source project. Since the successful launch of 1.0, OpenOffice.org has gained several tens of thousands of members; we now number well over 50,000. These are people from all over the world who have registered with the project. By doings so, they have expressed interest in furthering the product and project and, implicitly, in advancing Open Source.
</p>

<p>
Partly because of the immense growth promoted by the launch of OpenOffice.org 1.0, the last couple of months have seen changes in some of the non-technical projects. First, the Documentation Project was unanimously promoted from the Whiteboard/Incubator category to the Accepted Projects category. Congratulations, Scott Carr, who leads Documentation Project (<a href="http://documentation.openoffice.org/">http://documentation.openoffice.org/</a>)!
</p>

<p>
(For those new to OpenOffice.org, some background: There are three main categories: <a href="/projects/">Accepted Projects</a> is the primary category; it includes most of the technical projects as well as Marketing. <a href="http://whiteboard.openoffice.org/">Incubator/Whiteboard</a> houses community-sponsored, experimental projects, and Native-Lang contains the native-language projects, such as <a href="http://fr.openoffice.org/">Francophone</a>, <a href="http://de.openoffice.org/">Germanophone</a>, etc. The leads of both Native-Lang and Incubator/Whiteboard are represented in Accepted Projects. Voting is accorded to those projects in the Accepted Projects category. A longer description of this organization can be found in the "<a href="//about.html">About Us</a>" page.) 
</p>

<p>
Second, Guy Capra, who initiated the <a href="http://lang.openoffice.org/">Native-Lang project</a> in spring of last year, was voted in by the native-lang leads to take on the role of co-lead. Native-lang is quite important: It provides a space for users coming from almost any language group to communicate with each other, provide assistance, and inform each other about OpenOffice.org and Open Source. Native-lang is more than translating documents. Members also create documents, maintain download areas, and, perhaps most importantly, inform their local communities of OpenOffice.org. 
</p>

<p>
The number of native-lang projects is growing. As readers of the discuss list must be familiar, there have been several efforts to initiate new native-lang projects. The most recent of these have included Portuguese-Brazil (pt-br), and Portuguese-Portugal (pt-pt); the two are actually quite different languages, and Greek (el). More are on the way, and are in various stages of development. Discussions relating to native-lang projects take place in <a href="mailto:dev@lang.openoffice.org">dev@lang.openoffice.org</a>; all are welcome.
</p>

<p>
Third, Martijn Dekkers, whom everyone knows both from his insightful and trenchant posts to, among others, <a href="mailto:users@openoffice.apache.org">users@openoffice.apache.org</a>, <a href="mailto:dev@website.openoffice.org">dev@website.openoffice.org</a>, and from OooDocs (http://www.ooodocs.org), OpenOffice.org's complementary site, was voted in co-lead of the <a href="http://website.openoffice.org/">Website project</a>. (This actually happened a couple of months ago, and I regret how long it has taken me to announce it.)  What does the Website project do? It is the project determining, within limits, the architecture, navigation, and appearance of OpenOffice.org. The overall project, of course, is composed of linked virtual hosts, e.g., dba.openoffice.org, api.openoffice.org, and so on. Website controls the "www" area, which is where you will find general files not related to technical projects. It needs a clearer ordering system, to be sure, but that is not the only reason why Martijn, Miljenko Williams and others are embarked on re-structuring and redesigning the architecture of the "www" area.

</p>

<p>
If OpenOffice.org was born a developer-centric project, it is now very much also an end-user destination. The architecture of the site must accommodate both interests. Certainly, the site must be easily navigable by the millions (yes, millions) of interested persons who visit the project each week, from all over the world. They come from all language backgrounds and cultures; they need to find things efficiently. The website project is now trying to create an architecture and look that will make it easy (and even enjoyable) for all users to find the materials they want. If you would like to contribute--especially if you have talent and skill coding--please join us in <a href="mailto:dev@website.openoffice.org">dev@website.openoffice.org</a>. You can subscribe by going to the Website project homepage, <a href="http://website.openoffice.org/">http://website.openoffice.org/</a>.</p>

<p>Finally, Michael Bemmer has <a href="//servlets/ReadMsg?msgId=344373&amp;listName=discuss">proposed</a> a new project, the QA Project, to be located in the Incubator/Whiteboard category. There is considerable interest in this project, which will coordinate much bug-fixing. If you would like to join it please send a message to <a href="mailto:users@openoffice.apache.org">users@openoffice.apache.org</a>. As Michael emphasized in his message, this project is important: OpenOffice.org needs efficient, community-supported QA. The message of all these projects: You do not need to be a developer to make a difference.</p>
</body>
</html>

