<!doctype html>
<!--
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
    this work for additional information regarding copyright ownership.
    The ASF licenses this file to You under the Apache License, Version 2.0
    (the "License"); you may not use this file except in compliance with
    the License.  You may obtain a copy of the License at

         https://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
-->
<html lang="en" prefix="og: https://ogp.me/ns#">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
<title>Mitarbeit</title>
    <!-- Below Meta Tags Generated via https://www.opengraph.xyz -->
    <!-- If you don't care about social media then remove this section -->
    <!-- Values are set in pelicanconf.py -->
    <!-- HTML Meta Tags -->
    <meta name="description" content="The official developer website of the Apache OpenOffice open source project, home of OpenOffice Writer, Calc, Impress, Draw and Base.">
    <meta name="keywords" content="OpenOffice, Open Office, Apache OpenOffice, Apache Open Office, OpenOffice.org, Developer, Project, Website, Official, Writer, Calc, Impress, Draw, Base, ODF, Open Document Format">
    <!-- Facebook Meta Tags -->
    <meta property="og:url" content="https://openoffice.apache.org">
    <meta property="og:type" content="website">
    <meta property="og:title" content="Apache OpenOffice">
    <meta property="og:description" content="The official developer website of the Apache OpenOffice open source project, home of OpenOffice Writer, Calc, Impress, Draw and Base.">
    <meta property="og:image" content="https://openoffice.apache.org/images/AOO4_website_logo.png">
    <!-- Twitter Meta Tags -->
    <meta name="twitter:card" content="summary_large_image">
    <meta property="twitter:domain" content="openoffice.apache.org">
    <meta property="twitter:url" content="https://openoffice.apache.org">
    <meta name="twitter:title" content="Apache OpenOffice">
    <meta name="twitter:description" content="The official developer website of the Apache OpenOffice open source project, home of OpenOffice Writer, Calc, Impress, Draw and Base.">
    <meta name="twitter:image" content="https://openoffice.apache.org/images/AOO4_website_logo.png">
    <!-- Above Meta Tags Generated via https://www.opengraph.xyz -->
<link rel="shortcut icon" href="/favicon.ico" type="image/x-icon" />
<link rel="icon" href="/favicon.ico" type="image/x-icon" />
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>

<body id="index" class="home">
  <div id="banner">
      <div id="bannerleft"><a alt="Apache OpenOffice" href="/">
          <img id="logo" alt="Apache OpenOffice" src="/images/AOO4_website_logo.png" height="60" width="161"/></a></div>
      <div id="bannercenter">The Free and Open Productivity Suite</div>
  </div>
  <div id="clear"></div>
  <nav class="navbar navbar-expand-sm navbar-dark bg-primary">
<button class="navbar-toggler" type="button"
        data-toggle="collapse" data-target="#navbarSupportedContent"
        aria-controls="navbarSupportedContent" aria-expanded="false"
        aria-label="Toggle navigation">
  <span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="navbarSupportedContent">
  <ul class="navbar-nav mr-auto">
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="generalDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">General</a>
      <ul class="dropdown-menu" aria-labelledby="generalDropdown">
	<li><a class="dropdown-item" href="/index.html">About</a></li>
	<li><a class="dropdown-item" href="/downloads.html">Downloads</a></li>
	<li><a class="dropdown-item" href="/license.html">License</a></li>
	<li><a class="dropdown-item" href="/trademarks.html">Trademarks</a></li>
	<li><a class="dropdown-item" href="/press.html">Press</a></li>
	<li><a class="dropdown-item" href="https://www.openoffice.org/">OpenOffice.org</a></li>
      </ul>
    </li>
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="communityDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">Community</a>
      <ul class="dropdown-menu" aria-labelledby="communityDropdown">
	<li><a class="dropdown-item" href="/get-involved.html">Get Involved</a></li>
	<li><a class="dropdown-item" href="/orientation/index.html">Orientation</a></li>
	<li><a class="dropdown-item" href="/mailing-lists.html">Mailing Lists</a></li>
	<li><a class="dropdown-item" href="/social.html">Social Networking</a></li>
	<li><a class="dropdown-item" href="/events.html">Events</a></li>
	<li><a class="dropdown-item" href="https://www.openoffice.org/support/">Support</a></li>
	<li><a class="dropdown-item" href="/native-lang.html">Native Language</a></li>
	<li><a class="dropdown-item" href="https://cwiki.apache.org/confluence/display/OOOUSERS/">Planning Wiki</a></li>
	<li><a class="dropdown-item" href="/people.html">People</a></li>
	<li><a class="dropdown-item" href="/community-faqs.html">Community FAQs</a></li>
      </ul>
    </li>
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="developmentDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">Development</a>
      <ul class="dropdown-menu" aria-labelledby="developmentDropdown">
	<li><a class="dropdown-item" href="/source.html">Source Code</a></li>
	<li><a class="dropdown-item" href="/bug-tracking.html">Bug Tracking</a></li>
	<li><a class="dropdown-item" href="/qa.html">Quality Assurance</a></li>
	<li><a class="dropdown-item" href="/translate.html">Translation</a></li>
	<li><a class="dropdown-item" href="/website-local.html">Website</a></li>
	<li><a class="dropdown-item" href="/security.html">Security Reports</a></li>
	<li><a class="dropdown-item" href="/contributing-code.html">Contributing Code</a></li>
	<li><a class="dropdown-item" href="/developer-faqs.html">Developer FAQs</a></li>
      </ul>
    </li>
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="projectDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">Project</a>
      <ul class="dropdown-menu" aria-labelledby="projectDropdown">
	<li><a class="dropdown-item" href="https://blogs.apache.org/OOo/">Project Blog</a></li>
	<li><a class="dropdown-item" href="/pmc-faqs.html">PMC FAQs</a></li>
      </ul>
    </li>
  </ul>
  <div class="navbar-nav" style="padding-top: 0.5rem;">
    <div class="nav-item dropdown dropdown-menu-right active">
      <a class="nav-link dropdown-toggle" href="#"
         role="button" data-toggle="dropdown" aria-haspopup="true"
         aria-expanded="false"><img src="https://www.apache.org/foundation/press/kit/feather.svg"
				    width="32" height="32" class="d-inline-block align-top"
				    alt="Apache Feather">The ASF</a>
      <div class="dropdown-menu dropdown-menu-right">
	<a class="dropdown-item" href="https://www.apache.org/">Website</a>
	<a class="dropdown-item" href="https://www.apache.org/licenses/">License</a>
	<a class="dropdown-item" href="https://www.apache.org/security/">Security</a>
	<a class="dropdown-item" href="https://www.apache.org/events/current-event">Events</a>
	<a class="dropdown-item" href="https://www.openoffice.org/donations.html">Donations</a>
	<a class="dropdown-item" href="https://www.apache.org/foundation/sponsorship.html">Sponsorship</a>
	<a class="dropdown-item" href="https://www.apache.org/foundation/thanks.html">Thanks</a>
      </div>
    </div>
  </div>
</div>  </nav>
  <div id="contenta">
    <br/>
    <h2 id="werde-teil-des-apache-openoffice-projekts">Werde Teil des Apache OpenOffice Projekts!<a class="headerlink" href="#werde-teil-des-apache-openoffice-projekts" title="Permalink">&para;</a></h2>
<p>Viele beschr&auml;nken sich darauf, eine kleine <a href="https://www.openoffice.org/donations.html">Spende</a> f&uuml;r Apache OpenOffice und die
Apache Software Foundation zu leisten, was wir &uuml;brigens sehr begr&uuml;&szlig;en, aber
manche Anwender wollen dar&uuml;ber hinaus mehr tun und ihre Zeit und ihr Wissen
in das Projekt einflie&szlig;en lassen.
Es gibt vielf&auml;ltige Gr&uuml;nde f&uuml;r Menschen, sich in ein Open Source-Projekt
wie OpenOffice einzubringen. Einige sind:</p>
<ul>
<li>dazu beizutragen, die &raquo;digitale Trennwand&laquo; durch die weltweite Zurverf&uuml;gungstellung hochwertiger, freier Produktivit&auml;tsplattformen zu &uuml;berwinden</li>
<li>die Vorz&uuml;ge von OpenOffice auch Deinem Land oder Deiner Region zug&auml;nglich zu machen</li>
<li>nachdem man selbst von Open Source profitiert hat, der Idee etwas zur&uuml;ckzugeben</li>
<li>selbst eine neu erlernte F&auml;higkeit in der Praxis umzusetzen</li>
<li>ein Res&uuml;mee oder Portfolio, an dem man gearbeitet hat, zu publizieren</li>
<li>einen Kunden oder ein junges Unternehmen, das mit OpenOffice arbeitet, zu unterst&uuml;tzen</li>
<li>sich einen Ruf auf dem Gebiet der Unternehmensberatung im Bereich OpenOffice zu verschaffen</li>
<li>neue Funktionalit&auml;ten in OpenOffice zu installieren, die man selbst schon lange vermisst hat</li>
<li>Spa&szlig; zu haben bei der Zusammenarbeit mit einem engmaschigen Team von Freiwilligen im Rahmen eines der &auml;ltesten und bekanntesten OpenSource-Projekten</li>
</ul>
<h2 id="ein-multidisziplinares-open-source-projekt">Ein multidisziplin&auml;res Open Source-Projekt<a class="headerlink" href="#ein-multidisziplinares-open-source-projekt" title="Permalink">&para;</a></h2>
<p>Du musst kein Programmierer sein, um zum Erfolg von Apache OpenOffice
beizutragen. Unser Projekt verlangt nach den vielf&auml;ltigsten F&auml;higkeiten und
ganz unterschiedlichen Ebenen der Beteiligung und der technischen
Expertise. Wenn Du mitmachen willst, gibt es auch f&uuml;r Dich eine Aufgabe
Deiner Wahl.</p>
<p>Wir suchen nach Menschen f&uuml;r:</p>
<ul>
<li>das Schreiben und Pflegen der Dokumentation</li>
<li>Hilfestellung f&uuml;r neue Benutzer</li>
<li>Testen der Software und Benachrichtigung &uuml;ber Softwarefehler</li>
<li>Behebung von solchen Fehlern</li>
<li>Entwicklung neuer Programmelemente</li>
<li>Design von Kunstprodukten und anderen Marketing-Materialien</li>
<li>&Uuml;bersetzung in verschiedene Sprachen</li>
<li>Pflege der Website und Entwicklung neuer Lernmaterialien</li>
<li>die Bewerbung von OpenOffice und die Darstellung seiner Vorz&uuml;ge</li>
<li>alles Andere, was getan werden muss</li>
</ul>
<p>All diese verschiedenen Beitr&auml;ge zusammengenommen tragen dazu bei, das
Projekt lebendig zu halten und die Community zu st&auml;rken. Wir begr&uuml;&szlig;en jede
Unterst&uuml;tzung und ermuntern zum Mitmachen. Wir sind auch bem&uuml;ht, die ersten
Schritte zu einer Beteiligung m&ouml;glichst zu vereinfachen.</p>
<h2 id="was-zu-tun-ist">Was zu tun ist:<a class="headerlink" href="#was-zu-tun-ist" title="Permalink">&para;</a></h2>
<p>OpenOffice ist ein gro&szlig;es, komplexes Open Source-Projekt. Es wurde &uuml;ber
viele Jahre als unabh&auml;ngiges Projekt entwickelt und gepflegt, und jetzt mit
unseren Erfahrungen im Rahmen von Apache zusammengef&uuml;hrt.</p>
<p>Wenn dir die Entwicklung von Open Source-Projekten in der Apache Software Foundation bereits
gel&auml;ufig ist, dann kannst Du gleich mitmachen. Du musst lediglich die
<a href="/mailing-lists.html">Mailing-Liste</a>
eines Projekts abonnieren und Dich dort vorstellen. Wir
helfen dir bei diesem ersten Schritt.</p>
<hr/>
<p><strong>Wenn Du speziell in der deutschsprachigen AOO-Community mitarbeiten m&ouml;chtest, dann wende Dich an die Mailingliste <a href="mailto:dev-de@openoffice.apache.org">dev-de@openoffice.apache.org</a>.</strong></p>
<p>Die Liste <a href="mailto:dev-de@openoffice.apache.org">dev-de@openoffice.apache.org</a> dient ausschlie&szlig;lich der projektinternen Kommunikation der deutschsprachigen AOO-Community, beispielsweise Aktivit&auml;ten wie:</p>
<ul>
<li>Koordination von &Uuml;bersetzungen</li>
<li>Messeauftritte organisieren</li>
<li>Stammtische planen</li>
</ul>
<p>Kurzhinweise:</p>
<ul>
<li>Abonnieren: sende eine E-Mail an <a href="mailto:dev-de-subscribe@openoffice.apache.org">dev-de-subscribe@openoffice.apache.org</a></li>
<li>Mail schreiben: nach best&auml;tigter Anmeldung schicke Deine Mails an <a href="mailto:dev-de@openoffice.apache.org">dev-de@openoffice.apache.org</a></li>
<li>Abmelden: sende eine E-Mail an <a href="mailto:dev-de-unsubscribe@openoffice.apache.org">dev-de-unsubscribe@openoffice.apache.org</a></li>
<li>Listenarchiv: <a href="https://mail-archives.apache.org/mod_mbox/openoffice-dev-de/">https://mail-archives.apache.org/mod_mbox/openoffice-dev-de/</a></li>
</ul>
<hr/>
<p>Wenn Du aber zum ersten Mal hier bist oder eine systematischere
Heranf&uuml;hrung w&uuml;nschst, dann haben wir f&uuml;r Dich ein Paket von Modulen f&uuml;r
die <a href="/orientation/index.html">Orientierung neuer Helfer</a> vorbereitet, das Dich durch die wichtigsten
Aspekte von Apache OpenOffice und unserer Arbeitsweise f&uuml;hrt.</p>
<p>Welchen Weg Du nimmst, bleibt Deine pers&ouml;nliche Entscheidung &ndash; beide Wege
bleiben dir jeder Zeit offen.</p>
<p>Wir haben auf der Seite <a href="https://cwiki.apache.org/confluence/display/OOOUSERS/Help+Wanted">&raquo;Hilfe gesucht&laquo;</a> im Wiki auch eine Liste von
konkreten Arbeitsaufgaben, die in Angriff genommen werden sollten.</p>
<p>Wenn Du Student bist und zum Projekt im Rahmen Deines Studiums beitragen
m&ouml;chtest, werfe einen Blick auf unsere Seite <a href="/students.html">&raquo;Empfehlungen f&uuml;r Studenten&laquo;</a>.</p>

  </div>

  <footer class="navbar-expand-lg navbar-light bg-light">
    <div class="footer" id="footer">
        <div class="container-fluid">
          Copyright &copy; 2011-2021 The Apache Software Foundation,
          Licensed under the
          <a href="https://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0.</a> | <a href="/contact.html">Contact Us</a> | <a href="/terms.html">Terms of Use</a> | <a href="/privacy.html">Privacy</a>
          <br/>
          Apache, OpenOffice, OpenOffice.org and the seagull logo are registered trademarks of The Apache Software Foundation.
          The Apache feather logo is a trademark of The Apache Software Foundation.
          Other names appearing on the site may be trademarks of their respective owners.
        </div><!-- #container-fluid -->
        <div class="row container-fluid">
          <div class="col-sm">
            <a href="https://www.apache.org/">
              <img src="https://www.apache.org/img/asf_logo.png" alt="The Apache Software Foundation" style="border: 0; margin-top: 2px" width="200" height="82">
            </a>
          </div>
          <div class="col-sm center-align">
            <a href="https://www.apache.org/foundation/contributing.html">
              <img src="https://www.apache.org/images/SupportApache-small.png" alt="Support The ASF" height="80" width="80">
            </a>
          </div>
          <div class="col-sm right-align">
            <a class="acevent" data-format="wide" data-mode="light" data-event="random"></a>
          </div>
        </div>
    </div>
  </footer>
  <!-- Start load of stylesheets (will need to upgrade periodically) -->
  <link rel="stylesheet"
	href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
	integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T"
	crossorigin="anonymous">
  <link rel="stylesheet"
	href="https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/3.0.1/github-markdown.min.css"
	crossorigin="anonymous">
  <link href="/theme/css/openoffice.css" rel="stylesheet" type="text/css">
  <!-- End stylesheets -->
  <!-- Start the loading of javascript frameworks (will need to upgrade periodically) -->
  <script src="https://www.apachecon.com/event-images/snippet.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.slim.min.js"
	  integrity="sha512-6ORWJX/LrnSjBzwefdNUyLCMTIsGoNP6NftMy2UAm1JBm6PRZCO1d7OHBStWpVFZLO+RerTvqX/Z9mBFfCJZ4A=="
	  crossorigin="anonymous"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"
	  integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1"
	  crossorigin="anonymous"></script>
  <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"
	  integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM"
	  crossorigin="anonymous"></script>
  <!-- End the loading of javascript frameworks -->

  <!-- Source: get-involved-de.md; Template: page; Url: get-involved-de.html -->
</body>
</html>