<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html><head>
	<title>Informationen f&uuml;r Mitwirkende</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="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>
	
<!-- End de-header -->	
<!-- >
	Kommentare zur Seite
	$Id: index.html,v 2.47 2008/12/09 21:15:39 volkerme Exp $
	< -->
</head>
<body>


<table width="100%" summary="">

 <tr>
 <td width="83%" align="left" valign="top">
<div id="body_de">
 <h2>Informationen f&uuml;r Mitwirkende</h2>
 <p>Auf diesen Seiten haben wir Informationen für diejenigen zusammengestellt, die sich am de.OpenOffice.org-Projekt beteiligen wollen. Wir erkl&auml;ren, mit welchen Werkzeugen (Mailinglisten, IssueTracker, CVS, Wiki) die Online-Zusammenarbeit erm&ouml;glicht wird. Au&szlig;erdem stellen sich einige Teammitglieder in einer Liste n&auml;her vor.</p>
<p>
Übrigens: Wir duzen uns hier ganz zwanglos, egal, ob wir uns schon lange kennen oder jemand ganz neu zum Team hinzust&ouml;&szlig;t.
</p>
 <p>Hier wird nur eine kurze &Uuml;bersicht f&uuml;r den Einstieg ins Projekt geboten. Wesentlich detailliertere
 	Informationen findest du in den
 	<a href="../doc/faq/mitarbeiter/index.html">Mitarbeiter-FAQ</a>.</p>

 <p><a href="../index.html">In den allgemeinen Bereich zur&uuml;ckkehren</a></p>
	<h2>Aufgaben finden bei de.OpenOffice.org</h2>

	<p>
		Was kann ich denn tun? Welche Aufgaben stehen an?
		Wer weist mir einen Job zu?
		Diese und &auml;hnliche Fragen werden oft gestellt, diese Seite m&ouml;chte in die Mitarbeit und deren Organisation einf&uuml;hren.
	</p>

	<p>
		OpenSource-Projekte haben keinen Boss, der Aufgaben zuweist.
		OpenSource-Projekte organisieren sich weitgehendst selbst.
		Auf den ersten Blick wirkt dieses Vorgehen chaotisch - auf den zweiten &uuml;brigens auch, aber OpenSource-Projekte arbeiten trotz alledem ziemlich effizient.
	</p>

	
	<h3>Pers&ouml;nliche Voraussetzungen</h3>

	<p>
		Um das gr&ouml;&szlig;te Hindernis gleich von vorne herein auszuschlie&szlig;en:
		Um bei OpenOffice.org mitmachen zu k&ouml;nnen, brauchst du keine Programmierkenntnisse,
		obwohl es manchmal Aufgaben gibt, an denen sie n&uuml;tzlich sind oder sogar unabdingbar sind.
		du bist auch nicht gezwungen, mit einem bestimmten Betriebssystem zu arbeiten,
		OpenOffice.org l&auml;uft auf vielen Plattformen.
	</p>

	<p>
		Die wichtigste Voraussetzung ist der Spa&szlig;, den du bei der Mitarbeit hast und die F&auml;higkeit,
		Dich selbst zu motivieren, am Problem oder der Aufgabe dran zu bleiben,
		denn es wird dir niemand eine Gratifikation bezahlen oder zus&auml;tzliche Urlaubstage gew&auml;hren.
		du wirst aber sehen, dass sich die Anerkennung durch die Gruppe einstellt
		und du an Erfahrungen gewinnst.
	</p>

	<p>
		Und nat&uuml;rlich solltest du Interesse an OpenOffice.org selbst haben und wissen,
		was du damit machen oder erreichen willst. Je genauer du das definieren kannst,
		desto leichter wird es dir fallen, eine Aufgabe f&uuml;r dich zu finden,
		deren Erledigung dann allen anderen ebenfalls n&uuml;tzt.
		Hier sind deine ganz pers&ouml;nlichen F&auml;higkeiten und Ziele gefragt.
	</p>

	<p>
		Und zu guter Letzt werden dir Fremdsprachenkenntnisse helfen,
		das ganze Spektrum von OpenOffice.org zu erfahren. Das deutschsprachige
		OpenOffice.org-Projekt spricht selbstverst&auml;ndlich Deutsch und m&ouml;chte
		OpenOffice.org f&uuml;r deutsche Anwender benutzbar machen.
		Viele Projekte werden jedoch nur in Englisch abgewickelt.
		Englisch gut lesen zu k&ouml;nnen w&auml;re also schwer von Vorteil.
		Um so besser, sollte auch dein Schriftenglisch verst&auml;ndlich sein.
		Niemand wird sich an Fehlern st&ouml;ren, Italiener, Franzosen, Inder,
		Russen und Brasilianer sind auch nicht perfekt. Also - trau dich.
	</p>


	<h3>Technische Voraussetzungen</h3>

	<p>
		Du solltest nat&uuml;rlich &uuml;ber einen Computer und eine Internetverbindung verf&uuml;gen.
		Optimal w&auml;re eine Flatrate und ein schneller Internetzugang,
		dann ist auch ein gr&ouml;&szlig;erer Download m&ouml;glich oder eine l&auml;ngere Internetsitzung,
		doch auch mit einer Modemverbindung und einer Zeittakt-Internetverbindung kannst
		du bei OpenOffice.org mitmachen.
	</p>

	<p>
		Absolut wichtig ist ein leistungsf&auml;higes Mailprogramm, dessen fortgeschrittene
		Funktionen du beherrschst. Du solltest wissen, wie eine Mailingliste funktioniert,
		insbesondere mit deren Spielregeln (Stichwort Netiquette) vertraut sein.
		Wenn du dich hier noch nicht gut auskennst, sollte dich dies aber nicht vom
		Mitmischen abhalten. Schlie&szlig;lich kann man dies lernen.
	</p>


	<h3>Arbeitsweise von OpenOffice.org</h3>

	<p>
		OpenOffice.org ist in verschiedene Unterprojekte gegliedert. Unser deutschsprachiges Projekt ist eines davon.<br />
		Um einem einzelnen Projekt beitreten zu k&ouml;nnen, musst du dich als User
		<a href="/servlets/Join">registrieren</a>. Verwende m&ouml;glichst einen sprechenden Loginnamen.
		Das erleichtert sp&auml;ter die Arbeit im Team.<br />
		Auf der Startseite jedes Teilprojektes findest du oben rechts noch über der Hauptnavigationsleiste einen Link
		mit dem Titel <a href="/servlets/ProjectMembershipRequest">Register</a>.
		Nach Abschluss der Registrierung bist du dem Projekt beigetreten. Die Registrierung erlaubt dir zum Beispiel einen
		Fehlerbericht zu kommentieren oder aufzugeben.<br />
		<!--Nachdem ein Projekteigent&uuml;mer deinen Antrag best&auml;tigt hat, findest du den Eintrag in der
		<a href="/servlets/ProjectMemberList">Mitgliederliste</a>.<br />-->
		<!-- ( eine Anleitung dazu findest du <a href="">hier</a>)< -->
	</p>
	<p>
		Der Normalfall einer Mitarbeit bei OpenOffice.org ist das Abonnieren einer oder
		mehrerer Mailinglisten. &Uuml;ber die Mailinglisten werden nicht nur Probleme und deren
		L&ouml;sung diskutiert, sondern auch die Arbeit an den Projekten organisiert und das
		Team befragt, welche Arbeiten anstehen und wer sie &uuml;bernehmen kann oder will.
	</p>

	<p>
		Die Mailinglisten sind also ein wichtiger Aufgabenlieferant.
	</p>

	<p>
		Es empfiehlt sich, sowohl anwender- als auch projektspezifische Listen zu abonnieren.
		Das h&auml;ngt ganz von deinen Interessenschwerpunkten ab.
	</p>

	<p>
		Im Falle des deutschen OpenOffice.org-Projektes ist das die Anwenderliste
		<a href="http://de.openoffice.org/servlets/ProjectMailingListList">
		users@de.openoffice.org</a>. Die Koordination der Arbeit l&auml;uft &uuml;ber
		<a href="http://de.openoffice.org/servlets/ProjectMailingListList">
		dev@de.openoffice.org</a>.
	</p>

	<p>
		Zus&auml;tzlich existieren noch weitere Listen, die sich einzelnen Aufgabenbereichen widmen:
		Marketing, Business und ein paar andere.
	</p>

	<p>
		OpenOffice.org ist ein internationales Projekt und deckt noch viel mehr Aspekte
		des freien Office-Pakets ab. Eine durchsicht der Website nach einzelnen
		Arbeitsschwerpunkten ist dringend anzuraten. Einen ersten &Uuml;berblick erh&auml;ltst du &uuml;ber die
		<a href="/projects/index.html">Projekt&uuml;bersicht</a>. Jedes Projekt
		enth&auml;lt wiederum Unterprojekte und dazugeh&ouml;rige Mailinglisten.
		Je nach Wunsch der Benutzer unterhalten die Unterprojekte sowohl eine Userliste
		f&uuml;r Anwenderfragen als auch eine Devliste f&uuml;r Entwickler und andere Mitarbeiter.
	</p>

	<p>
		Weitere Hinweise und Anleitungen findest du in diesem Bereich in der
		rechten Navigationsleiste.
	</p>

	<p>
		Ursprungsautor: <!-- <a href="mailto:hfischer@openoffice.org">  --> Helga Fischer</a><br />
		<!-- Seitenbetreuer: <a href="mailto:hfischer@openoffice.org">Helga Fischer</a> -->
	</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> F&uuml;r Mithelfer </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> <a href="team.html" title="Alle Mithelfer"> Das Team </a></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ü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>
 <br />

<!--t
<div align="left">Diese Seite wird gepflegt von <a href="mailto:hfischer@openoffice.org?subject=Betrifft: Informationen für Mitwirkende">Helga Fischer</a></div>
-->
<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>
