<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <title>Contribuer</title>


  <meta http-equiv="content-type" content="text/html; charset=UTF-8">

</head>


<body>
<h1>Pourquoi participer ?</h1>
<p>
OpenOffice.org est un projet à code ouvert (<i>open source</i>). 
Un tel projet est tr&egrave;s li&eacute; &agrave;
l'ensemble de ses membres. Ce sont eux qui, par leur nombre, apportent
le dynamisme et la cr&eacute;ativit&eacute; n&eacute;cessaires &agrave; l'avanc&eacute;e du produit. Ces
membres, b&eacute;n&eacute;voles pour la plupart, entreprises et particuliers,
veillent &agrave; la r&eacute;alisation d'un produit qui r&eacute;ponde au plus pr&egrave;s &agrave; la
demande des utilisateurs. </p>
<p>
Bien s&ucirc;r il y a des d&eacute;veloppeurs qui contribuent &agrave; l'&eacute;criture d'un code
de qualit&eacute;, base d'un format de fichiers standard, mais il y a
&eacute;galement beaucoup d'autres contibuteurs qui écrivent de la documentation, qui
testent les nouvelles versions et qui rapportent les bogues, qui aident d'autres utilisateurs à 
résoudre leur problème... Tout un
ensemble de t&acirc;ches qui participe &agrave; faire du projet <b>OpenOffice.org</b>, la suite
bureautique libre et gratuite qui est devenu en quelques années la v&eacute;ritable alternative 
&agrave; l'ensemble des logiciels bureautiques du march&eacute;.</p>

      <br>
<p>
Cette suite compos&eacute;e des outils standards&nbsp; bureautiques se
d&eacute;compose en de nombreux projets, structur&eacute;s, hi&eacute;rarchis&eacute;s, proches de
ceux que l'on peut trouver dans d'autres projets à code ouvert.</p>
<p>
Le projet francophone ne repr&eacute;sente qu'une toute petite partie de la
communaut&eacute;. Il est cependant fragile et nécessite en permanence de nouveaux apports. Nous 
serons donc heureux de vous accueillir et de vous faire d&eacute;couvrir les multiples facettes 
de cette communaut&eacute; dans laquelle
vous pouvez vous investir &agrave; diff&eacute;rents niveaux soit en fonction du temps
dont vous disposez, soit par vos comp&eacute;tences. Si le d&eacute;veloppement de lignes
de code demande une validation parfois complexe de l'ensemble de la
communaut&eacute;, il reste de très nombreux domaines qui réclame votre contribution directe 
(documentation, tutoriel, assurance qualit&eacute;, graphisme...).</p>

      <br>
<p>
Pour en savoir plus sur la mani&egrave;re dont est organis&eacute;e notre projet, nous
vous invitons &agrave; lire ce lien qui explique <a href="about-explanations.html">comment est 
structuré le projet <b>OpenOffice.org</b></a>
</p>
<p>
Maintenant que vous savez tout (ou presque) sur ce projet, 
n'h&eacute;sitez pas &agrave; consulter l'<a href="Contribuer/index_contrib.htm">index
des diff&eacute;rentes contributions possibles</a>.</p>

<p>      
Nous esp&eacute;rons vous souhaiter tr&egrave;s prochainement la bienvenue dans l'un
de nos projets !</p>
</body>
</html>
