<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html>
  <head>
    <title>
      Wahlen
    </title>
    <!-- Start de-header -->
    <link rel="stylesheet" href="../styles/de.css" media="screen" type="text/css" />
    <link rel="stylesheet" href="../styles/de_print.css" media="print" type="text/css" />
    <link rel="alternate stylesheet" title="mit Navbar" href="../styles/de_navbar.css" media="screen" type="text/css" />
    <link rel="alternate stylesheet" title="mit Navbar4" href="../styles/de_navbar4.css" media="screen" type="text/css" />
    <link rel="alternate stylesheet" title="mit Navbar5" href="../styles/de_navbar5.css" media="screen" type="text/css" />
    <link rel="alternate stylesheet" title="ohne Navbar" media="screen" href="../styles/de_nonavbar.css" type="text/css" />
    <meta http-equiv="Content-Style-Type" content="text/css" />
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <style type="text/css">
      /*
      <![CDATA[*/         	<!--         	@import url("../styles/de_navbar6.css");         	-->      /*]]>*/
    </style>
    <!-- >
    Kommentare zur Seite
    $Id: wahlen.html,v 1.6 2007/07/29 17:47:25 andreasma Exp $
    < -->
    <!-- End de-header -->
  </head>
  <body>
    <table width="100%" summary="">
      <tr>
        <td align="left" valign="top">
          <div id="body_de">
            <h2>Richtlinien zu Wahlen im deutschsprachigen Projekt</h2>
	    <h3>Aufgabenverteilung im de-Projekt</h3>
	    <h4>Projektleiter (Co-Leads)</h4>
            <p>
              Das deutschsprachige Projekt wird von zwei gleichberechtigten Co-Leads geführt, die
sich die anfallenden Arbeiten teilen. Ihre Aufgaben bestehen zum einen aus administrativen
Tätigkeiten wie zum Beispiel die Mitgliederverwaltung und die Mailinglistenadministration.
Darüber hinaus sind die Co-Leads für die Koordination verschiedener im Projekt anfallenden
Arbeiten
verantwortlich und halten den Kontakt zu den anderen OpenOffice.org-Projekten. Eine ausführlichere
Beschreibung der Aufgaben gibt es in den allgemeinen Projektrichtlinien:<br />
<a
href="//dev_docs/guidelines.html">//dev_docs/
guidelines.html</a>
            </p>
	    <h4>Ansprechpartner</h4>
            <p>Für spezielle Aufgabenbereiche wie Marketing, Dokumentation oder PrOOo-Box werden im
de-Projekt zusätzlich Ansprechpartner gewählt, die diese Bereiche koordinieren und damit die
Co-Leads entlasten sollen.  Je nach Umfang des jeweiligen Aufgabenbereichs gibt es einen oder
mehrere Ansprechpartner. Im Bedarfsfall können neue Ansprechpartner-Posten eingerichtet werden und
vorhandene wegfallen.
            </p>
            <h3>Modalitäten der Co-Lead-Wahlen:</h3>
	    <h4>Wer darf wählen?</h4>
	    <p>Wahlberechtigt sind alle Projektmitglieder des deutschsprachigen Projekts, die
mindestens den Status "Observer" oder höher haben.</p>
<h4>Wie wird man Projektmitglied und erhält den Status "Observer"?</h4>
<p>Der Begriff "Projektmitglied" kann weit gefasst werden. Im Grunde ist bereits jeder
Projektmitglied, der in beliebiger Form an den Zielen des OpenOffice.org-Projektes mitwirkt. Im
Sinne der Wahlberechtigung ist man Projektmitglied, wenn man sich unter<br /><br />
<a href="//servlets/Join">//servlets/Join</a><br
/><br />
auf den Projekt-Webseiten angemeldet hat.<br />
Anschließend kann man sich im de-Projekt anmelden und dort unter<br /><br />
<a
href="http://de.openoffice.org/servlets/ProjectMembershipRequest">http://de.openoffice.org/servlets/
ProjectMembershipRequest</a><br /><br />
den Status "Observer" beantragen.<br />
An diese Rolle sind keine Verpflichtungen gebunden, es wird lediglich darum gebeten, eine kurze
Vorstellungsmail an die Mailingliste <a
href="mailto:dev@de.openoffice.org">dev@de.openoffice.org</a> zu schicken. Ist diese eingegangen,
wird die Observer-Rolle durch einen der Co-Leads zugeteilt.
</p>
<h4>Wahlbetreuer</h4>
<p>Üblicherweise betreuen der amtierende und der scheidende Co-Lead gemeinsam die durchzuführende
Wahl. Ist dies nicht möglich, werden eine oder zwei weitere Personen als Wahlbetreuer bestimmt. Dies
geschieht formlos in Abstimmung mit den Projektmitgliedern über die de-dev-Mailingliste.</p>
<h4>Wer kann gewählt werden?</h4>
<p>Es kann jeder Co-Lead werden, der bereits einige Zeit das Projekt als aktiver Mitwirkender
begleitet und sich die Aufgabe nicht nur inhaltlich sondern auch in Hinblick auf den zu erwartenden
Zeitaufwand zutraut.</p>
<h4>Zeitlicher Ablauf der Wahl</h4>
<h5>Kandidatenvorschläge</h5>
<p>Nachdem bekannt geworden ist, dass ein neuer Co-Lead gewählt werden muss, können
Projektmitglieder auf der de-dev-Mailingliste Kandidatenvorschläge machen. Die Kandidaten sollten
vorher informiert werden und ihre Zustimmung geben. Es ist erlaubt, sich selbst als Kandidat
vorzuschlagen. Für das Einreichen von Kandidatenvorschlägen soll mindestens ein Zeitraum von 1
Woche
zur Verfügung stehen.</p>
<h5>Zustimmung / Vorstellung der Kandidaten</h5>
<p>Innerhalb einer weiteren Woche haben die Kandidaten Zeit, auf der de-dev-Mailingliste ihrer
Kandidatur zuzustimmen. Mit der Zustimmung nimmt der Kandidat gleichzeitig die möglicherweise
erfolgreiche Wahl an.</p>
<p>Darüber hinaus können die Kandidaten sich vorstellen und beschreiben, wie sie ihre Tätigkeit
als
Co-Lead gestalten möchten. Diese Vorstellung ist freiwillig, jedoch kann eine aussagekräftige
Vorstellung den Wahlausgang entscheidend beeinflussen und ist daher unbedingt empfehlenswert.</p>
<h5>Wahlzeitraum</h5>
<p>Für die Wahl ist ein Zeitraum von 2 Wochen vorgesehen. Nach Aufruf der Wahlbetreuer dürfen die
Wahlberechtigten ihre Stimme abgeben. Die beiden Wahlbetreuer geben ihre Stimme zuerst ab, bevor die
Wahl für die restlichen Wahlberechtigten freigegeben wird.</p>
<h4>Wie wird gewählt?</h4>
<p>Die Wahl erfolgt in nicht öffentlicher Abstimmung per E-Mail an die beiden Wahlbetreuer. In
dieser Mail sollte ein aussagekräftiger Betreff, z. B. "Wahl Co-Lead" verwendet werden. Im Text
soll
der Kandidat genannt werden, dem die Stimme gegeben werden soll. Zudem ist die Angabe des
OOo-Benutzernamens erforderlich, anhand dessen die Wahlberechtigung geprüft wird. Idealerweise geben
die Wahlbetreuer eine Mailvorlage (in Form eines Links) vor, die für die Abstimmung entsprechend
vorbereitet wurde.</p>
<p>Jeder Observer (oder höher) hat genau eine Stimme. </p>
<h4>Gültige Stimmen</h4>
<p>Abgegebene Stimmen sind nur gültig, wenn sie im Wahlzeitraum an beide Wahlbetreuer eingegangen
sind und aus der E-Mail der Wunschkandidat eindeutig hervorgeht. Zudem muss die Stimme von einem
Observer (oder höher) abgegeben worden sein. Dies wird anhand des in der Wahlmail angegebenen
OOoBenutzernamens überprüft.</p>
<p>Als Sicherheit, dass die Stimme eingegangen und gültig ist, wird an die Mailadresse
&lt;OOoBenutzernamer&gt; @openoffice.org eine Bestätigungsmail geschickt. Diese enthält die Nennung des
gewählten Kandidaten sowie eine Kennziffer. Diese Kennziffer wird später zusammen mit der Stimme
veröffentlicht. Daran kann jeder überprüfen, ob seine Stimme korrekt in die Wahl eingeflossen
ist,
ohne dass die zugehörigen Namen öffentlich gemacht werden.</p>
<h4>Wahlbeteiligung</h4>
<p>Bei Co-Lead-Wahlen ist eine Mindestwahlbeteiligung erforderlich. Diese liegt bei 15 % der
Wahlberechtigen abgerundet auf die nächst kleinere ganze Zahl. Wird die erforderliche Anzahl an
gültigen Stimmen bis zum Ablauf des Wahlzeitraums nicht erreicht, können die Wahlbetreuer die Wahl
um eine Woche verlängern. Wird die Beteiligung auch nach einer Verlängerungswoche nicht erreicht,
muss eine zweite Wahl angesetzt werden, die dann unabhängig von der Anzahl der abgegebenen
gültigen
Stimmen gültig ist.</p>
<h4>Wahlergebnis</h4>
<p>Die Wahl gewonnen hat der Kandidat, auf den die meisten Stimmen gefallen sind. Dabei muss er
mit mindestens einer Stimme Vorsprung gewonnen haben.</p>
<p>Im Falle eines Gleichstands von zwei oder mehr Kandidaten wird ein weiterer Wahlgang
durchgeführt, bei dem nur noch die Kandidaten antreten, auf die im ersten Wahlgang die meisten
Stimmen gefallen sind. Der zweite Wahlgang wird zeitnah nach dem ersten durchgeführt. Der Zeitraum
der Stimmabgabe im zweiten Wahlgang sollte eine Woche nicht überschreiten.</p>
<h4>Ergebnisbekanntgabe</h4>
<p>Das Wahlergebnis wird auf der de-dev-Mailingliste nach Ablauf des Wahlzeitraums bekannt
gegeben. Die Kandidaten werden vorab über das Ergebnis informiert.</p>
<p>An einer öffentlichen Stelle (de-Webseite) wird das detaillierte Ergebnis dokumentiert. Dort
werden keine Wählernamen genannt, sondern lediglich die Kombinationen Kennziffer und Stimme
aufgelistet. Zudem werden die auf die jeweiligen Kandidaten fallenden Stimmen absolut und prozentual
angegeben.</p>
<p>Die Abstimmungsmails und sonstige Wahlunterlagen sind von den Wahlbetreuern stets vertraulich
zu behandeln. In begründeten Fällen können innerhalb von 2 Wochen nach Ergebnisbekanntgabe zwei
weitere Personen bestimmt werden, die die abgegebenen Stimmen erneut auszählen und auf ihre
Gültigkeit überprüfen.</p>
<h4>Wahlverfahren bei nur einem Kandidaten</h4>
<p>Das Wahlverfahren ist auch dann anzuwenden, wenn nur ein Kandidat aufgestellt wurde. Dann
sind bei der nicht öffentlichen Abstimmung auch negative Stimmen zugelassen, die mit "0"
(Enthaltung) oder "-1" (Gegenstimme) gekennzeichnet werden sollen. Für die
Auszählung sind Enthaltungen und Gegenstimmen als gleichwertig anzusehen.</p>
<p>In diesem Fall gilt eine Wahl als gewonnen, wenn der Kandidat von den abgegebenen gültigen
Stimmen mehr als 50% positive Stimmen erhält.</p>
<p>Erhält dieser die Mindestanzahl der positiven Stimmen nicht, muss eine neue Wahl angesetzt
werden.</p>
<h4>Dauer der Amtsausübung / Abwahl eines Co-Leads</h4>
<p>Der Co-Lead wird auf unbestimmte Zeit gewählt. Er kann zu jeder Zeit von seinem Posten
zurücktreten oder gleich bei Antritt seines Postens den Ablauf selbst bestimmen.</p>
<p>In begründeten Fällen können ein Co-Lead oder beide Co-Leads zum Rücktritt aufgefordert
werden. Ist der Co-Lead dazu nicht bereit, kann er in einer nicht öffentlichen Wahl abgewählt
werden. Bei dieser nicht öffentlichen Wahl müssen zwei neutrale Wahlbetreuer bestimmt werden, die
nicht Co-Leads sind. Ein Co-Lead gilt als abgewählt, wenn mehr als 50 % der abgegebenen gültigen
Stimmen dies befürworten. Ansonsten gelten die gleichen Wahlmodalitäten wie bei der Wahl des
Co-Leads. Dies gilt insbesondere für die Mindestwahlbeteiligung sowie für die anonymisierte
Veröffentlichung der Ergebnisse.</p>
<p>Ist der Co-Lead abgewählt, wird entsprechend des normalen Verfahrens ein neuer Co-Lead
gewählt. Hierbei darf auch der eben abgewählte wieder aufgestellt werden.</p>
<h4>Abweichendes Wahlverfahren</h4>
<p>In begründeten Ausnahmefällen kann mit Antrag an die Co-Leads von der hier geschilderten
Vorgehensweise in Abstimmung mit den Projektmitgliedern abgewichen werden.</p>
<p>Eine abweichende Vorgehensweise ist auf der de-dev-Mailingliste vorzustellen und zu diskutieren.
Die Zustimmung zu einer Ausnahmeregelung erfolgt dann mit Hilfe einer einfachen Abstimmung mit
+1/-1, die öffentlich auf der Liste geführt wird. Eine Ausnahmeregelung ist nur jeweils für die
aktuelle Wahl anzuwenden.</p>

<h3>Modalitäten der Ansprechpartner-Wahlen:</h3>
<h4>Wer darf wählen?</h4>
<p>Wahlberechtigt ist jeder, der den Aufruf der Wahl auf der de-dev-Mailingliste liest und zum
Zeitpunkt der Wahl dort eingeschrieben ist.</p>
<h4>Wahlbetreuer</h4>
<p>Üblicherweise betreuen beide amtierende Co-Leads gemeinsam mit dem scheidenden
Ansprechpartner die durchzuführende Wahl. Da die Wahl öffentlich auf der de-dev-Mailingliste
geführt
wird, beschränken sich die Aufgaben vornehmlich um die Sicherstellung, dass die Wahl korrekt
durchgeführt wird, um die Bekanntgabe der Wahlmodalitäten und der abschließenden Auszählung
und
Zusammenfassung des Wahlergebnisses.</p>
<h4>Wer kann gewählt werden?</h4>
<p>Es kann jeder Ansprechpartner im de-Projekt werden, der bereits einige Zeit das Projekt als
aktiver Mitwirkender begleitet und sich die Aufgabe nicht nur inhaltlich sondern auch in Hinblick
auf den zu erwartenden Zeitaufwand zutraut.</p>
<h4>Zeitlicher Ablauf der Wahl</h4>
<h5>Kandidatenvorschläge</h5>
<p>Nachdem bekannt geworden ist, dass ein neuer Ansprechpartner gewählt werden muss, können
Projektmitglieder auf der de-dev-Mailingliste Kandidatenvorschläge machen. Die Kandidaten sollten
vorher informiert werden und ihre Zustimmung geben. Es ist erlaubt, sich selbst als Kandidat
vorzuschlagen. Für das Einreichen von Kandidatenvorschlägen soll mindestens ein Zeitraum von 3
Tagen
zur Verfügung stehen.</p>
<h5>Zustimmung / Vorstellung der Kandidaten</h5>
<p>Innerhalb weiterer 3 Tage haben die Kandidaten Zeit, auf der de-dev-Mailingliste ihrer
Kandidatur zuzustimmen. Mit der Zustimmung nimmt der Kandidat gleichzeitig die möglicherweise
erfolgreiche Wahl an.</p>
<p>Darüber hinaus können die Kandidaten sich vorstellen und beschreiben, wie sie ihre Tätigkeit
als Ansprechpartner gestalten möchten. Diese Vorstellung ist freiwillig, jedoch kann eine
aussagekräftige Vorstellung den Wahlausgang entscheidend beeinflussen und ist daher unbedingt
empfehlenswert.</p>
<h5>Wahlzeitraum</h5>
<p>Für die Wahl ist ein Zeitraum von 1 Woche vorgesehen. Nach Aufruf der Wahlbetreuer dürfen die
Projektmitglieder ihre Stimme abgeben.</p>
<h5>Wie wird gewählt?</h5>
<p>Die Wahl erfolgt öffentlicher Abstimmung per eMail an die de-dev-Mailingliste. Dazu muss
lediglich eine Antwort auf die Mail des Wahlaufrufs verfasst werden, in der die Stimme für den
Wunschkandidaten mit +1 gekennzeichnet wird. Zweitstimmen gibt es bei der Wahl eines
Ansprechpartners nicht.</p>
<h5>Gültige Stimmen</h5>
<p>Abgegebene Stimmen sind gültig, wenn sie im Wahlzeitraum eingegangen sind und aus der Mail
der Wunschkandidat eindeutig hervorgeht.</p>
<h5>Wahlbeteiligung</h5>
<p>Bei Ansprechpartner-Wahlen ist keine Mindestwahlbeteiligung erforderlich.</p>
<h5>Wahlergebnis</h5>
<p>Die Wahl gewonnen hat der Kandidat, auf den die meisten Stimmen gefallen sind. Dabei muss er
mit mindestens einer Stimme Vorsprung gewonnen haben. Bei Gleichstand zweier Kandidaten werden beide
gemeinsam Ansprechpartner. Eine spätere Neuwahl erfolgt erst dann, wenn die Anzahl der
Ansprechpartner wieder unter die ursprüngliche Anzahl gesunken ist.</p>
<h5>Ergebnisbekanntgabe</h5>
<p>Das Wahlergebnis kann auf der de-dev-Mailingliste jederzeit direkt nachverfolgt werden. Nach
Abschluss der Wahl zählen die Wahlbetreuer die Stimmen nochmals aus und veröffentlichen das Ergebnis
auf der de-dev-Mailingliste.</p>
<h5>Wahlverfahren bei nur einem Kandidaten</h5>
<p>Das Wahlverfahren ist auch dann anzuwenden, wenn nur ein Kandidat aufgestellt wurde. Dann
sind bei der öffentlichen Abstimmung auch negative Stimmen zugelassen, die mit ?0? (Enthaltung) oder
?-1? (Gegenstimme) gekennzeichnet werden sollen. Für die Auszählung sind Enthaltungen und
Gegenstimmen als gleichwertig anzusehen.</p>
<p>In diesem Fall gilt eine Wahl als gewonnen, wenn der Kandidat von den abgegebenen gültigen
Stimmen mehr als 50% positive Stimmen erhält.</p>
<p>Erhält dieser die Mindestanzahl der positiven Stimmen nicht, muss eine neue Wahl angesetzt
werden.</p>
<h5>Dauer der Amtsausübung / Abwahl eines Ansprechpartners</h5>
<p>Der Ansprechpartner wird auf unbestimmte Zeit gewählt. Er kann zu jeder Zeit von seinem
Posten zurücktreten oder gleich bei Antritt seines Postens den Ablauf selbst bestimmen.In
begründeten Fällen kann ein Ansprechpartner zum Rücktritt aufgefordert werden. Ist der
Ansprechpartner dazu nicht bereit, kann er in einer nicht öffentlichen Wahl abgewählt werden.
Für
diese nicht öffentliche Wahl finden die Modalitäten der Co-Lead-Abwahl Anwendung.  Ein
Ansprechpartner gilt als abgewählt, wenn mehr als 50 % der abgegebenen gültigen Stimmen dies
befürworten. Ansonsten gelten die gleichen Wahlmodalitäten wie bei der Wahl des Co-Leads. Dies
gilt
insbesondere für die Mindestwahlbeteiligung, für die Wahlberechtigung, sowie für die
anonymisierte
Veröffentlichung der Ergebnisse.</p>
<p>Ist der Ansprechpartner abgewählt, wird entsprechend des normalen Verfahrens ein neuer
Ansprechpartner gewählt. Hierbei darf auch der eben abgewählte wieder aufgestellt werden.</p>
<h5>Einrichtung oder Abschaffung von Ansprechpartner-Posten</h5>
<p>Veränderte Gegebenheiten im de-Projekt können es erforderlich machen, dass ein neuer
Ansprechpartner-Posten geschaffen wird. Ein solcher Vorschlag ist öffentlich zu äußern bzw. direkt
an die Co-Leads zu richten. Die Entscheidung darüber wird in gleicher Weise in öffentlicher
Abstimmung über die de-dev-Mailingliste gefällt, wie bei der Wahl des Ansprechpartners selbst.
Gleiches gilt bei begründetem Antrag auf Abschaffung eines Ansprechpartner-Postens.</p>
<h5>Abweichendes Wahlverfahren</h5>
<p>In begründeten Ausnahmefällen kann mit Antrag an die Co-Leads von der hier geschilderten
Vorgehensweise in Abstimmung mit den Projektmitgliedern abgewichen werden.</p>
<p>Eine abweichende Vorgehensweise ist auf der de-dev-Mailingliste vorzustellen und zu
diskutieren. Die Zustimmung zu einer Ausnahmeregelung erfolgt dann mit Hilfe einer einfachen
Abstimmung mit +1/-1, die öffentlich auf der Liste geführt wird. Eine Ausnahmeregelung ist nur
jeweils für die aktuelle Wahl anzuwenden.</p>
<h3>Schlussbemerkung</h3>
<p>Die hier aufgeführten Bestimmungen sind das Ergebnis einer Diskussion, welche im Oktober 2006
auf der Mailingsliste dev@de.openoffice.org geführt wurde und mit einer öffentlichen Abstimmung
bestätigt wurde.</p>
<p>Erweisen sich einzelne Bestimmungen dieser Richtlinie als nicht durchführbar, dann sollen die
de-Projektmitglieder gemeinsam eine Regel ausarbeiten, die dem Ziel der nicht durchführbaren
Bestimmung am nächsten kommt. Diese neue Regel wird auf der de-dev-Mailingliste diskutiert und mit
einer öffentlichen Abstimmung beschlossen. Anschließend wird sie in einer überarbeiteten Fassung
dieser Richtlinie aufgenommen. Dass gleiche gilt, wenn diese Richtlinie bestimmte Fragen nicht
regelt.</p>
<p>Die de-Community ist jederzeit angehalten, so zu handeln, wie es dem Sinn und der Zielsetzung
des de-Projekts entspricht. Kann innerhalb der de-Community über wesentliche Punkte keine
Einigkeit
erzielt werden, muss dem Community Council der Sachverhalt vorgetragen werden. Dies gilt
insbesondere beim Verdacht auf Wahlmanipulation. Das Community Council entscheidet dann über die
weitere Vorgehensweise.</p>
<p>Für weitere Fragen zu den Modalitäten steht <a
href="mailto:jrahemipour@openoffice.org">Jaqueline Rahemipour</a> zur Verfügung.</p>
          </div>
        </td>
        <td valign="top" height="100%">
          <!-- Start Navbar -->
	<!-- >
	Kommentare zur Navbar Informationen f&uuml;r Mitglieder im de.OpenOffice.org Projekt
	Makemapversion:
	$Id: makemap.pl,v 1.6 2006/02/12 22:32:45 mkirchner Exp :
	navbar_Dev ,V 0.5.5 Mittwoch, 22. Februar 2006 10:15:48 _MLM
	< -->
<ul id="navbar_de">
    <li><div align="center">de-links</div></li>
    <li> <a href="../index.html" title=" "> Hauptseite </a></li>
    <li> <a href="../map_all.html" title=" "> Sitemap </a></li>
    <li> <a href="../neuhier.html" title="Informationen zu OpenOffice.org, dem Softwareprodukt"> Produkt-Info </a></li>
    <li> <a href="../kontakt.html" title="Informationen zu OpenOffice.org, der Community"> Projekt-Info </a></li>
    <li> <a href="../downloads/quick.html" title="Software und mehr"> Download </a></li>
    <li> <a href="../doc/index.html" title="Installationsbeschreibungen und mehr Schriftliches"> Dokumentationen </a></li>
    <li> <a href="../doc/faq/index.html" title="FAQ- H&auml;ufig gestellte Fragen"> FAQ </a></li>
    <li> <a href="../probleme.html" title="Wo Hilfe nahe ist"> Support </a></li>
    <li> <a href="../doc/howto/index.html" title="Knappe Anleitungen f&uuml;r die erste Benutzung"> Erste Schritte </a></li>
    <li> <a href="../marketing/marketing.html" title="Materialien und mehr"> Marketing </a></li>
    <li> <a href="../presse/about-presskit.html" title="Pressemitteilungen, Interviews und andere Informationen"> Presse </a></li>
    <li>Mithelfen
      <ul>
      <li> <a href="index.html" title="Die Startseite f&uuml;r neue Mitarbeiter"> F&uuml;r Mithelfer </a></li>
      <li> <a href="../doc/faq/mitarbeiter/index.html" title="Das Wissensarchiv f&uuml;r Neulinge und Fortgeschrittene"> Mitarbeiter-FAQ </a></li>
      <li> <a href="ansprechpartner.html" title="Ansprechpartner &uuml;bernehmen die Verantwortung f&uuml;r einen Teil des Gesamtprojekts."> Ansprechpartner </a></li>
      <li> Das Team </li>
      <li> <a href="pre_submission_de.html" title="Einsenden einer Fehlermeldung oder eines Verbesserungsvorschlags"> Fehlerbericht </a></li>
      <li> <a href="aufgabenliste.html" title="Aufgaben, die Helfer suchen."> Aufgabenliste </a></li>
      <li> <a href="todo.html" title="Eine Sammlung von Aufgaben, die zur Zeit dringend sind"> Aktuelle TODO-Liste </a></li>
      <li> <a href="../about-ooo/about-mailinglist.html" title="Die wichtigste Kommunikationsform im deOOo Projekt"> Mailinglisten </a></li>
      <li> <a href="../about-ooo/about-irc.html" title="F&uuml;r Konferenzen der Entwickler, kein Support!"> IRC </a></li>
      <li> <a href="issuezilla_einfuehrung.html" title="Der Hintergrund des Issuezilla knapp dargestellt"> Issuezilla Einf&uuml;hrung </a></li>
      <li> <a href="qa/index.html" title="Informationen zur Qualit&auml;tskontrolle der deutschen Lokalisationen von OOo"> Qualit&auml;tskontrolle </a></li>
      <li> <a href="../about-ooo/about_unterstuetzung.html" title="Finanzielle Zuwendungen und Serverkapazit&auml;ten"> Zuwendungen </a></li>
      <li> <a href="credits.html" title="F&uuml;r besondere Hilfe dankt das Projekt ..."> Danksagung </a></li>
      </ul>
    </li>
</ul>
          <!-- End Navbar -->
        </td>
      </tr>
    </table>

<p>
	<a href="http://validator.w3.org/check?uri=referer"><img
	    src="http://www.w3.org/Icons/valid-xhtml10-blue"
	    alt="Valid XHTML 1.0 Transitional" height="31" width="88" /></a>
</p>
  </body>
</html>
