ubuntu-packaging-guide 0.1 - en to de_DE translation catalogue (538 entries)

en: autopkgtest: Automatic testing for packages
de_DE: autopkgtest: Automatische Tests für Pakete

en: The `DEP 8 specification <DEP8_>`_ defines how automatic testing can very easily be integrated into packages. To integrate a test into a package, all you need to do is:
de_DE: Die `DEP 8 Spezifikation <DEP8_>`_ definiert wie automatisches Testen sehr einfach in Paketen eingebunden werden kann. Alles was es braucht um einen Test in einem Paket einzubinden:

en: add a file called ``debian/tests/control`` which specifies the requirements for the testbed,
de_DE: erstellen Sie eine Datei namens ``debian/tests/control``, die die Anforderungen für die Testumgebung festlegt,

en: add the tests in ``debian/tests/``.
de_DE: fügen Sie die Tests in ``debian/tests/`` ein.

en: Testbed requirements
de_DE: Anforderungen für die Testumgebung

en: In ``debian/tests/control`` you specify what to expect from the testbed. So for example you list all the required packages for the tests, if the testbed gets broken during the build or if ``root`` permissions are required. The `DEP 8 specification <DEP8_>`_ lists all available options.
de_DE: In ``debian/tests/control`` wird festgelegt, was die Testumgebung leisten muss. Zum Beispiel werden alle für den Test benötigten Pakete aufgeführt, ob die Testumgebung während der Erstellung verloren geht oder ob ``root`` Privilegien gebraucht werden. Die `DEP 8 Spezifikation <DEP8_>`_ listet alle möglichen Optionen auf.

en: Below we are having a look at the ``glib2.0`` source package. In a very simple case the file would look like this::
de_DE: Im Folgenden schauen wir uns das Quellpaket ``glib2.0`` an. Im einfachsten Fall sieht die Datei so aus::

en: For the test in ``debian/tests/build`` this would ensure that the packages ``libglib2.0-dev`` and ``build-essential`` are installed.
de_DE: Das stellt für den Test ``debian/tests/build`` sicher, dass die Pakete ``libglib2.0-dev`` und ``build-essential`` installiert sind.

en: You can use ``@`` in the ``Depends`` line to indicate that you want all the packages installed which are built by the source package in question.
de_DE: Sie können in der ``Depends``-Zeile ``@`` benutzen, um festzulegen, dass Sie alle Pakete installiert haben wollen, die aus dem jeweiligen Quellpaket erzeugt werden.

en: The actual tests
de_DE: Die eigentlichen Tests

en: The accompanying test for the example above might be:
de_DE: Der passende Test für das obige Beispiel könnte folgender sein:

en: Here a very simple piece of C code is written to a temporary directory. Then this is compiled with system libraries (using flags and library paths as provided by `pkg-config`). Then the compiled binary, which just exercises some parts of core glib functionality, is run.
de_DE: An dieser Stelle wird ein sehr einfaches Stück C-Code in ein temporäres Verzeichnis geschrieben. Dies wird mit den Systembibliotheken übersetzt (wobei die Flags und Bibliothekpfade benutzt werden, wie sie uns von `pkg-config` geliefert werden). Dann wird der resultierende Binär-Code ausgeführt, der grundlegende Funtionen in glib testet.

en: While this test is very small and simple, it covers quite a lot: that your -dev package has all necessary dependencies, that your package installs working pkg-config files, headers and libraries are put into the right place, or that the compiler and linker work. This helps to uncover critical issues early on.
de_DE: Während der Test selbst sehr klein und einfach ist, umfasst er doch eine Menge: Es wird sichergestellt, dass das -dev Paket alle nötigen Abhängigkeiten besitzt, dass von dem Paket funktionierende pkg-Konfigurationsdateien installiert werden, dass die Header und Bibliotheken richtig platziert werden, oder dass der Kompiler und Linker funktionieren. Das hilft dabei, kritische Fehler schon sehr früh aufzudecken.

en: Executing the test
de_DE: Den Test ausführen

en: While the test script can be easily executed on its own, it is strongly recommended to actually use ``autopkgtest`` from the ``autopkgtest`` package for verifying that your test works; otherwise, if it fails in the Ubuntu Continuous Integration (CI) system, it will not land in Ubuntu.  This also avoids cluttering your workstation with test packages or test configuration if the test does something more intrusive than the simple example above.
de_DE: Während das Testskript leicht selbst ausgeführt werden kann, wird dringend empfohlen, ``autopkgtest`` aus dem ``autopkgtest`` Paket zu verwenden. Somit kann überprüft werden, dass Ihr Test funktioniert. In anderen Fällen wird es der Test wenn er im Ubuntu Continuous Integration (CI) System fehlschlägt, nicht in Ubuntu landen. Dies verhindet eben so, dass Ihre Workstation mit Testpaketen oder Testkonfiguration zugemüllt wird, wenn der Test etwas weiteres als das einfache Beispiel oben macht.

en: The `README.running-tests <running_tests_local_>`_ (`online version <DEP8_>`_) documentation explains all available testbeds (schroot, LXD, QEMU, etc.) and the most common scenarios how to run your tests with ``autopkgtest``, e. g. with locally built binaries, locally modified tests, etc.
de_DE: Die `README.running-tests <running_tests_local_>`_ (`online version <DEP8_>`_) Dokumentation erklärt alle verfügbaren Testumgebund (schroot, LXE, QEMU etc.) und die üblichsten Szenarien um Ihre Tests mit ``autopkgtest`` laufen zu lassen. Beispielsweise mit lokal erstellten Binärdateien, lokal modifizierten Tests etc.

en: The Ubuntu CI system uses the QEMU runner and runs the tests from the packages in the archive, with ``-proposed`` enabled. To reproduce the exact same environment, first install the necessary packages::
de_DE: Das Ubuntu CI-System benutzt den QEMU-Runner und führt alle Tests der Pakete in des Archivs aus, welche ``-proposed`` aktiviert haben. Um genau die selbe Umgebung zu reproduzieren, müssen zuerst die nötigen Pakten installiert werden::

en: Now build a testbed with::
de_DE: Nun erstellen Sie eine Testumgebung mit::

en: (Please see its manpage and ``--help`` output for selecting different releases, architectures, output directory, or using proxies). This will build e. g. ``adt-trusty-amd64-cloud.img``.
de_DE: (Bitte beachten Sie die Manpage und die ``--help`` Ausgabe zur Auswahl von verschiedenen Veröffentlichungen, Architekturen, Ausgabeverzeichnis oder die Nutzung von Proxies). Dies baut beispielsweise `adt-trusty-amd64-cloud.img``.

en: Then run the tests of a source package like ``libpng`` in that QEMU image::
de_DE: Dann starte die Tests eines Quellpakets wie ``libpng`` in diesem QEMU-Abbild::

en: The Ubuntu CI system runs packages with only selected packages from ``-proposed`` available (the package which caused the test to be run); to enable that, run::
de_DE: Das Ubuntu CI System startet Pakete nur mit ausgewählten Paketen von ``-proposed`` die verfügbar sind (das Paket welches den Start des Tests auslöst);  um dies zu aktivieren starten Sie::

en: or to run with all packages from ``-proposed``::
de_DE: oder mit allen Paketen von ``-proposed`` laufen lassen::

en: The ``autopkgtest`` manpage has a lot more valuable information on other testing options.
de_DE: Die ``autopkgtest`` Manpage beinhaltet eine Menge an weiteren wertvollen Informationen über andere Testoptionen.

en: Further examples
de_DE: Weitere Beispiele

en: This list is not comprehensive, but might help you get a better idea of how automated tests are implemented and used in Ubuntu.
de_DE: Diese Liste ist nicht vollständig, aber wird Ihnen sicher einen guten Einblick geben wie automatisierte Testdurchläufe in Ubuntu implementiert und benutzt werden.

en: The `libxml2 tests <libxml2_>`_ are very similar. They also run a test-build of a simple piece of C code and execute it.
de_DE: Die `libxml2 Tests <libxml2_>`_ sind sehr ähnlich. Sie führen auch eine Testerstellung aus ein bisschen einfachem C-Code durch und führen sie aus.

en: The `gtk+3.0 tests <gtk3_>`_ also do a compile/link/run check in the "build" test. There is an additional "python3-gi" test which verifies that the GTK library can also be used through introspection.
de_DE: Die `gtk+3.0 tests <gtk3_>`_ leisten auch einen Kompilier/Link/Start-Check im "build" Test. Es gibt einen zusätzlichen "python3-gi" Test welcher sicherstellt, dass die GTK Bibliothek auch über Introspektion genutzt werden kann.

en: In the `ubiquity tests <ubiquity_>`_ the upstream test-suite is executed.
de_DE: In den `ubiquity Tests <ubiquity_>`_ wird die Upstream Testsammlung ausgeführt.

en: The `gvfs tests <gvfs_>`_ have comprehensive testing of their functionality and are very interesting because they emulate usage of CDs, Samba, DAV and other bits.
de_DE: Die `gvfs tests <gvfs_>`_ haben ausführliches Testen ihrer Funktionalität und sind sehr interessant, da die die Nutzung von CDs, Samba, DAV und anderen Teilen emulieren.

en: Ubuntu infrastructure
de_DE: Ubuntu Infrastruktur

en: Packages which have ``autopkgtest`` enabled will have their tests run whenever they get uploaded or any of their dependencies change. The output of `automatically run autopkgtest tests <jenkins_>`_ can be viewed on the web and is regularly updated.
de_DE: Pakete , die``autopkgtest`` aktiviert haben werden ihre Tests starten sobald sie hochgeladen werden oder eine ihrer Abhängigkeiten sich ändert. Die Ausgabe von `automatically run autopkgtest tests <jenkins_>`_ kann im Web eingesehen werden und wird stetig aktualisiert.

en: Debian also uses ``autopkgtest`` to run package tests, although currently only in schroots, so results may vary a bit. Results and logs can be seen on http://ci.debian.net. So please submit any test fixes or new tests to Debian as well.
de_DE: Debian benutzt ebenfalls ``autopkgtest`` für Pakettests wobei dies momentan nur in schroots erfolgt. Somit können die Ergebnisse ein wenig variieren. Ergebnisse und Logs können auf http://ci.debian.net eingesehen werden. Bitte senden Sie daher jegliche Testbehebungen oder neue Tests gleichzeitig an Debian.

en: Getting the test into Ubuntu
de_DE: Die Tests in Ubuntu bekommen

en: The process of submitting an autopkgtest for a package is largely similar to :doc:`fixing a bug in Ubuntu<./fixing-a-bug>`. Essentially you simply:
de_DE: Der Prozess, um einen autopkgtest in Ubuntu einzubringen ist größtenteils identisch mit :doc:`fixing a bug in Ubuntu<./fixing-a-bug>`. Im Prinzip muss man einfach:

en: run ``bzr branch ubuntu:<packagename>``,
de_DE: ``bzr branch ubuntu:<Paketname>`` ausführen,

en: edit ``debian/control`` to enable the tests,
de_DE: bearbeiten Sie ``debian/control`` um die Tests zu aktivitieren,

en: add the ``debian/tests`` directory,
de_DE: fügen Sie ein ``debian/tests``-Verzeichnis hinzu,

en: write the ``debian/tests/control`` based on the `DEP 8 Specification <dep8_>`_,
de_DE: bearbeite ``debian/tests/control`` basierend auf der `DEP 8 Spezifikation <dep8_>`_,

en: add your test case(s) to ``debian/tests``,
de_DE: fügen Sie Ihre(n) Test(s) zu ``debian/tests`` hinzu,

en: commit your changes, push them to Launchpad, propose a merge and get it reviewed just like any other improvement in a source package.
de_DE: die Änderungen committen, sie nach Launchpad hochladen, und einen Merge vorschlagen, sie dann überprüfen lassen, genau wie jede andere Änderung an einem Quellpaket auch.

en: What you can do
de_DE: Was Sie machen können

en: The Ubuntu Engineering team put together a `list of required test-cases <requiredtests_>`_, where packages which need tests are put into different categories. Here you can find examples of these tests and easily assign them to yourself.
de_DE: Das Ubuntu Engineering Team hat eine `Liste von benötigten Testfällen<requiredtests_>` zusammengestellt wo Pakete, die Tests benötigen in verschiedene Kategorien gestellt werden. Hier finden Sie Beispiele dieser Tests und können sie sich selbst zuweisen.

en: If you should run into any problems, you can join the `#ubuntu-quality IRC channel <qualityirc_>`_ to get in touch with developers who can help you.
de_DE: Sollten Probleme auftreten, kann man auf dem `#ubuntu-quality IRC Kanal <qualityirc_>`_ Kontakt zu Entwicklern herstellen, die helfen können.

en: Backporting software updates
de_DE: Zurückportieren von Software-Aktualisierungen

en: Sometimes you might want to make new functionality available in a stable release which is not connected to a critical bug fix. For these scenarios you have two options: either you `upload to a PPA <ppadoc_>`_ or prepare a backport.
de_DE: Manchmal möchten Sie eine neue Funktionalität in einer stabilen Veröffentlichung machen, die sich nicht auf eine kritische Fehlerbehebung bezieht. Für diese Fälle haben Sie zwei Optionen: Entweder Sie `laden in ein PPA hoch <ppadoc_>`_ oder bereiten einen Backport vor.

en: Personal Package Archive (PPA)
de_DE: Persönliches Paketarchiv (PPA)

en: Using a PPA has a number of benefits. It is fairly straight-forward, you don't need approval of anyone, but the downside of it is that your users will have to manually enable it. It is a non-standard software source.
de_DE: Ein PPA bringt viele Vorteile. Es ist leicht zu benutzen und Sie benötigen keinerlei Genehmigung oder Überprüfung anderer. Aber andererseits werden die Benutzer sie manuell einrichten müssen, da sie keine Standard-Paketquelle ist.

en: The `PPA documentation on Launchpad <ppadoc_>`_ is fairly comprehensive and should get you up and running in no time.
de_DE: Die `PPA Dokumentation auf Launchpad <ppadoc_>`_ ist sehr ausführlich und sollte Sie schnell zu Ergebnissen führen.

en: Official Ubuntu Backports
de_DE: Offizielle Ubuntu-Backports

en: The Backports Project is a means to provide new features to users. Because of the inherent stability risks in backporting packages, users do not get backported packages without some explicit action on their part. This generally makes backports an inappropriate avenue for fixing bugs. If a package in an Ubuntu release has a bug, it should be fixed either through the :doc:`Security Update or the Stable Release Update process<./security-and-stable-release-updates>`, as appropriate.
de_DE: Das Zurückportieren ist ein Mittel um den Nutzern neue Funktionen bereitzustellen. Wegen der Gefahr von Kompabilitätsproblemen erhalten Nutzer keine zurückportierten Pakete ohne ausdrückliche Maßnahmen ihrerseits. Das macht Zurückportieren grundsätzlich zu einer schlechten Wahl für Fehlerbehebungen. Wenn ein Paket in einer Ubuntu-Veröffentlichung einen Fehler aufweist, sollte er entweder durch :doc:`ein Sicherheitsupdate oder den "Stable-Release"-Updateprozess<./security-and-stable-release-updates>` angemessen behoben werden.

en: Once you determined you want a package to be backported to a stable release, you will need to test-build and test it on the given stable release. ``pbuilder-dist`` (in the ``ubuntu-dev-tools`` package) is a very handy tool to do this easily.
de_DE: Wenn Sie sich dazu entschlossen haben, ein Paket durch eine Backport in einen stabilen Release zu portieren, werden Sie zumindest einen Test-Build ausführen müssen und das Paket in demjenigen Release zu testen. ``pbuilder-dist`` (im ``ubuntu-dev-tools`` Paket) ist ein tolles Werkzeug um das problemlos zu tun.

en: To report the backport request and get it processed by the Backporters team, you can use the ``requestbackport`` tool (also in the ``ubuntu-dev-tools`` package). It will determine the intermediate releases that package needs to be backported to, list all reverse-dependencies, and file the backporting request.  Also will it include a testing checklist in the bug.
de_DE: Um eine Anfrage auf Zurückportierung zu stellen und sie vom Team bearbeitet zu bekommen, können Sie das Werkzeug ``requestbackport`` verwenden (auch in dem Paket ``ubuntu-dev-tools`` enthalten). Es wird feststellen welche dazwischenliegende Veröffentlichungen das Paket benötigt um zurückportiert werden zu können, listet alle zurückliegenden Abhängigkeiten auf und stellt eine offizielle Anfrage. Es wird außerdem dem Fehlerbericht eine Prüfliste für Tests anhängen.

en: Using Chroots
de_DE: Chroots benutzen

en: If you are running one version of Ubuntu but working on packages for another versions you can create the environment of the other version with a ``chroot``.
de_DE: Wenn Sie eine Version von Ubuntu benutzen, aber an Paketen für andere Versionen arbeiten, können Sie eine Umgebung dieser Version mit einer ``Chroot`` erzeugen.

en: A ``chroot`` allows you to have a full filesystem from another distribution which you can work in quite normally.  It avoids the overhead of running a full virtual machine.
de_DE: Eine ``Chroot`` erlaubt Ihnen ein Dateisystem einer anderen Distribution zu haben in dem man nahezu normal arbeiten kann. Dadurch vermeidet man den Overhead des Laufens einer vollen virtuellen Maschine.

en: Creating a Chroot
de_DE: Eine Chroot-Umgebung anlegen

en: Use the command ``debootstrap`` to create a new chroot::
de_DE: Benutzen Sie das Kommando ``debootstrap`` um eine neue Chroot zu erzeugen::

en: This will create a directory ``trusty`` and install a minimal trusty system into it.
de_DE: Dies erstellt ein Verzeichnis ``trusty`` und installiert darin ein minimales Trusty-System.

en: If your version of ``debootstrap`` does not know about Trusty you can try upgrading to the version in ``backports``.
de_DE: Wenn Ihre Version von ``debootstrap`` Trusty nicht kennt, können Sie versuchen die Version in ``backports`` zu upgraden.

en: You can then work inside the chroot::
de_DE: Sie können dann in der Chroot arbeiten::

en: Where you can install or remove any package you wish without affecting your main system.
de_DE: Wo Sie alle Pakete installieren oder löschen können ohne Ihr Hauptsystem zu berühren.

en: You might want to copy your GPG/ssh keys and Bazaar configuration into the chroot so you can access and sign packages directly::
de_DE: Vielleicht möchten Sie auch Ihre GPG/ssh-Schlüssel und Bazaarkonfiguration in das Chroot kopieren, um so einfacher auf Pakete zugreifen und sie signieren zu können::

en: To stop apt and other programs complaining about missing locales you can install your relevant language pack::
de_DE: Damit apt und andere Programme sich nicht mehr über fehlende Locales beschweren, kann man die relevanten Language Packs installieren::

en: If you want to run X programs you will need to bind the /tmp directory into the chroot, from outside the chroot run::
de_DE: Um X-Window Programme in der Chroot Umgebung nutzen zu können, muss das /tmp Verzeichnis in die Umgebung gebunden werden. Dies geht außerhalb des Chroot mit folgendem Kommando:

en: Some programs may need you to bind /dev or /proc.
de_DE: Für einige Programme kann es nötig sein die Verzeichnisse /dev und /proc in das Chroot zu binden.

en: For more information on chroots see our `Debootstrap Chroot wiki page <DebootstrapChroot_>`_.
de_DE: Für weitere Informationen über chroots schauen Sie unsere `Debootstrap Chroot Wikiseite <DebootstrapChroot_>`_. an.

en: Alternatives
de_DE: Alternativen

en: SBuild is a system similar to PBuilder for creating an environment to run test package builds in.  It closer matches that used by Launchpad for building packages but takes some more setup compared to PBuilder.  See `the Security Team Build Environment wiki page <SecurityEnv_>`_ for a full explanation.
de_DE: SBuild ist ein System ähnlich PBuilder um eine Umgebung zu erstellen in der Testpaket-Builds laufen gelassen werden können. Es ähnelt eher dem System welches von Launchpad genutzt wird um Pakete zu erstellen aber benötigt mehr Einrichtung als PBuilder.  Schauen Sie `die Security Team Build Environment Wikiseite <SecurityEnv_>`_ für eine vollständige Erklärung an.

en: Full virtual machines can be useful for packaging and testing programs.  TestDrive is a program to automate syncing and running daily ISO images, see `the TestDrive wiki page <TestDrive_>`_ for more information.
de_DE: Vollständige virtuelle Maschinen können zur Paketierung und Testen von Programmen nützlich sein. TestDrive ist ein Programm um die Synchronisation und starten von Daily ISO-Abbildern zu betreiben. Schauen Sie die `TestDrive Wikiseite <TestDrive_>`_ für weitere Informationen an.

en: You can also set up pbuilder to pause when it comes across a build failure.  Copy C10shell from /usr/share/doc/pbuilder/examples into a directory and use the ``--hookdir=`` argument to point to it.
de_DE: Sie können pbuilder auch so konfigurieren, dass er anhält, wenn er ein Problem findet. Kopieren Sie C10shell von /usr/share/doc/pbuilder/examples in ein Verzeichnis und benutzen Sie das ``--hookdir=`` Argument um darauf zu verweisen.

en: Amazon's `EC2 cloud computers <EC2_>`_ allow you to hire a computer paying a few US cents per hour, you can set up Ubuntu machines of any supported version and package on those.  This is useful when you want to compile many packages at the same time or to overcome bandwidth restraints.
de_DE: Amazons `EC2 Cloudrechner <EC2_>`_ ermöglichen es einen Rechner für ein paar US-Cents pro Stunde zu mieten. Man kann Ubuntu Rechner jeder unterstützten Version einrichten und auf diesen paketieren. Dies ist nützlich wenn man mehrere Pakete gleichzeitig paketieren möchte oder Bandbreiteneinschränkungen überwinden möchte.

en: Communication in Ubuntu Development
de_DE: Kommunikation in der Ubuntu-Entwicklung

en: In a project where thousands of lines of code are changed, lots of decisions are made and hundreds of people interact every day, it is important to communicate effectively.
de_DE: In einem Projekt, bei dem tausende Zeilen Quelltext geändert werden, viele Entscheidungen getroffen werden und hunderte Leute täglich zusammenspielen, ist es wichtig effizient zu kommunizieren.

en: Mailing lists
de_DE: Mailinglisten

en: Mailing lists are a very important tool if you want to communicate ideas to a broader team and make sure that you reach everybody, even across timezones.
de_DE: Mailinglisten sind ein sehr bedeutendes Werkzeug um Ideen an ein größeres Team zu kommunizieren und sicherzustellen, dass man jeden erreicht, auch über Zeitzonen hinweg.

en: In terms of development, these are the most important ones:
de_DE: Bezüglich der Entwicklung, sind dies die Wichtigsten:

en: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel-announce (announce-only, the most important development announcements go here)
de_DE: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel-announce (ausschließlich Ankündigungen, hier findet man nur die wichtigsten Ankündigungen bezüglich der Entwicklung)

en: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel (general Ubuntu development discussion)
de_DE: https://lists.ubuntu.com/mailman/listinfo/ubuntu-devel (allgemeine Diskussionen zur Ubuntu Entwicklung)

en: https://lists.ubuntu.com/mailman/listinfo/ubuntu-motu (MOTU Team discussion, get help with packaging)
de_DE: https://lists.ubuntu.com/mailman/listinfo/ubuntu-motu (MOTU Team Diskussion, eine gute Anlaufstelle für Hilfe bei der Paketierung)

en: IRC Channels
de_DE: IRC-Kanäle

en: For real-time discussions, please connect to irc.freenode.net and join one or any of these channels:
de_DE: Für Echtzeit-Diskussionen schauen Sie auf dem IRC Server irc.freenode.net in einem oder mehreren der folgenden Kanäle vorbei:

en: #ubuntu-devel (for general development discussion)
de_DE: #ubuntu-devel (für allgemeine Diskussion zur Entwicklung)

en: #ubuntu-motu (for MOTU team discussion and generally getting help)
de_DE: #ubuntu-motu (für MOTU Team Diskussionen und genereller Hilfe)

en: Basic Overview of the ``debian/`` Directory
de_DE: Allgemeine Übersicht über das ``debian/`` Verzeichnis

en: This article will briefly explain the different files important to the packaging of Ubuntu packages which are contained in the ``debian/`` directory. The most important of them are ``changelog``, ``control``, ``copyright``, and ``rules``. These are required for all packages. A number of additional files in the ``debian/`` may be used in order to customize and configure the behavior of the package. Some of these files are discussed in this article, but this is not meant to be a complete list.
de_DE: Dieser Artikel gibt eine kurze Übersicht über die verschiedenen Dateien im ``debian/`` Verzeichnis, welche für das Paketieren von Ubuntu Paketen wichtig sind. Die wichtigsten Dateien sind ``changelog``, ``control``, ``copyright`` und ``rules``. Diese Dateien werden für alle Pakete benötigt. Anhand weiterer Dateien im ``debian/`` Verzeichnis kann das Verhalten der Pakete angepasst und konfiguriert werden. Während einige dieser Dateien in diesem Artikel beschrieben werden, ist er nicht als vollständige Übersicht gedacht.

en: The changelog
de_DE: Das Änderungsprotokoll

en: This file is, as its name implies, a listing of the changes made in each version. It has a specific format that gives the package name, version, distribution, changes, and who made the changes at a given time. If you have a GPG key (see: :doc:`Getting set up<./getting-set-up/>`), make sure to use the same name and email address in ``changelog`` as you have in your key. The following is a template ``changelog``::
de_DE: Die Datei ist, wie sich schon am Namen erkennen lässt, eine Liste von Änderungen die in jeder Version gemacht wurden. Sie hat ein spezielles Format aus dem man Paketname, Version, Distribution, Änderungen, Autor und Zeitpunkt herauslesen kann. Falls Sie einen GPG-Schlüssel besitzen (siehe: :doc:`Erste Schritte<./getting-set-up/>`), stellen Sie sicher dass Sie den selben Alias und E-Mail Adresse im ``changelog`` verwenden wie in Ihrem Schlüssel. Das folgende ist eine ``changelog`` Vorlage::

en: The format (especially of the date) is important. The date should be in :rfc:`5322` format, which can be obtained by using the command ``date -R``. For convenience, the command ``dch`` may be used to edit changelog. It will update the date automatically.
de_DE: Das Format (besonders das Datumsformat) ist wichtig. Das Datum sollte im :rfc:`5322` Format sein, sodass es dann durch Eingabe von ``date -R`` abgerufen werden kann. Zur Erleichterung kann der Befehl ``dch``genutzt werden, um den Changelog zu editieren. Er wird das Datum automatisch aktualisieren.

en: Minor bullet points are indicated by a dash "-", while major points use an asterisk "*".
de_DE: Unterpunkte werden durch einen Strich "-" dargestellt, während Hauptpunkte durch einen Stern "*" gekennzeichnet werden.

en: If you are packaging from scratch, ``dch --create`` (``dch`` is in the ``devscripts`` package) will create a standard ``debian/changelog`` for you.
de_DE: Falls Sie ein neues Paket ohne Vorlage erstellen, können Sie mit ``dch --create`` (``dch`` befindet sich im ``devscripts`` Paket) Standard-Daten für ``debian/changelog`` anlegen.

en: Here is a sample ``changelog`` file for hello::
de_DE: Dies ist ein Beispiel für eine ``changelog`` Datei des hello Pakets::

en: Notice that the version has a ``-0ubuntu1`` appended to it, this is the distro revision, used so that the packaging can be updated (to fix bugs for example) with new uploads within the same source release version.
de_DE: Erwähnenswert ist, dass die Version ein ``-0ubuntu1`` Suffix angehängt hat, das die Distributions-Änderung wiederspiegelt. Sie wird benutzt damit das Paketieren in der gleichen Quellversion aktualisiert werden kann (z.B. für Fehlerbehebungen).

en: Ubuntu and Debian have slightly different package versioning schemes to avoid conflicting packages with the same source version. If a Debian package has been changed in Ubuntu, it has ``ubuntuX`` (where ``X`` is the Ubuntu revision number) appended to the end of the Debian version. So if the Debian hello ``2.6-1`` package was changed by Ubuntu, the version string would be ``2.6-1ubuntu1``. If a package for the application does not exist in Debian, then the Debian revision is ``0`` (e.g. ``2.6-0ubuntu1``).
de_DE: Ubuntu und Debian haben leicht unterschiedliche Versionsbezeichnungen um Konflikte mit demselben Quellpaket zu vermeiden. Wenn ein Debian-Paket unter Ubuntu geändert wurde, wird ein ``ubuntuX`` (wobei ``X`` für die Ubuntu-Revision steht) an das Ende der Debianversion angehängt. Also wenn das Debian-Paket hello ``2.6-1`` unter Ubuntu geändert wurde, würde die Versionsbezeichnung ``2.6-1ubuntu1`` sein. Falls ein Paket dieser Anwendung nicht für Debian existiert, dann ist die Debian-Revision ``0`` (z.B. ``2.6-0ubuntu1``).

en: For further information, see the `changelog section (Section 4.4) <policy-changelog_>`_ of the Debian Policy Manual.
de_DE: Für weitere Informationen, schauen Sie die `changelog section (Section 4.4) <policy-changelog_>`_ des Debian Policy Manual an.

en: The control file
de_DE: Die control Datei

en: The ``control`` file contains the information that the package manager (such as ``apt-get``, ``synaptic``, and ``adept``) uses, build-time dependencies, maintainer information, and much more.
de_DE: Die ``control`` Datei enthält Informationen, die der Paketmanager (also z.B. ``apt-get``, ``synaptic`` und ``adept``) verwendet, build-spezifische Abhängigkeiten, Betreuerinformationen und vieles andere.

en: For the Ubuntu ``hello`` package, the ``control`` file looks something like this:
de_DE: Für das Ubuntupaket ``hello``, sieht die Datei ``control`` folgendermaßen aus:

en: The first paragraph describes the source package including the list of packages required to build the package from source in the ``Build-Depends`` field. It also contains some meta-information such as the maintainer's name, the version of Debian Policy that the package complies with, the location of the packaging version control repository, and the upstream home page.
de_DE: Der erste Absatz beschreibt in dem Feld ``Build-Depends`` das Quellpaket inklusive aller benötigten Paketabhängigkeiten, die nötig sind um das Paket aus dem Quellcode zu bauen. Es enthält außerdem einige Metadaten wie den Namen des Verantwortlichen, die Version der Debian-Richtlinien, der Ort der Paketversionkontrolle und die Upstream-Homepage.

en: Note that in Ubuntu, we set the ``Maintainer`` field to a general address because anyone can change any package (this differs from Debian where changing packages is usually restricted to an individual or a team). Packages in Ubuntu should generally have the ``Maintainer`` field set to ``Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>``. If the Maintainer field is modified, the old value should be saved in the ``XSBC-Original-Maintainer`` field. This can be done automatically with the  ``update-maintainer`` script available in the ``ubuntu-dev-tools`` package. For further information, see the `Debian Maintainer Field spec <MaintField_>`_ on the Ubuntu wiki.
de_DE: Beachten Sie bitte, dass wir in Ubuntu das``Maintainer`` Feld auf eine allgemeine Adresse setzen, da jeder jedes Paket ändern kann (dies unterscheidet sich von Debian wo die Veränderung von Paketen auf eine Person oder ein Team beschränkt ist. Pakete in Ubuntu sollten allgemein das ``Maintainer`` Feld auf ``Ubuntu Developers <ubuntu-devel-discuss@lists.ubuntu.com>`` setzen. Wenn das Maintainer-Feld modifiziert wird, sollte das alte Wert im ``XSBC-Original-Maintainer`` Feld gespeichert werden. Dies kann automatisch mit dem ``update-maintainer`` Skript im ``ubuntu-dev-tools`` Paket erfolgen. Für weitere Informationen schauen Sie `Debian Maintainer Field spec <MaintField_>`_ im Ubuntu-Wiki an.

en: Each additional paragraph describes a binary package to be built.
de_DE: Jeder weitere Abschnitte beschreibt ein Binärpaket, welches gebaut wird.

en: For further information, see the `control file section (Chapter 5) <policy-control_>`_ of the Debian Policy Manual.
de_DE: Für weitere Informationen schauen Sie die `control file Section (Kapitel 5) <policy-control_>`_ des Debian Policy Manual an.

en: The copyright file
de_DE: Die Copyright-Datei

en: This file gives the copyright information for both the upstream source and the packaging. Ubuntu and `Debian Policy (Section 12.5) <policy-copyright_>`_ require that each package installs a verbatim copy of its copyright and license information to ``/usr/share/doc/$(package_name)/copyright``.
de_DE: Diese Datei zeigt die Copyright Informationen für sowohl die Upstream Quelle und die Paketierung an. Ubuntu und `Debian Policy (Sektion 12.5) <policy-copyright_>`_ verlangen, dass jedes Paket eine Originalkopie seiner Copyright and Lizenzinformation in ``/usr/share/doc/$(package_name)/copyright`` installiert.

en: Generally, copyright information is found in the ``COPYING`` file in the program's source directory. This file should include such information as the names of the author and the packager, the URL from which the source came, a Copyright line with the year and copyright holder, and the text of the copyright itself. An example template would be::
de_DE: Im allgemeinen findet man Urheberrechtsinformationen in der Datei ``COPYING`` in dem Quellverzeichnis des Programms. Diese Datei sollte Auskünfte über die Namen der Autoren und der Paketierer, die URL des ursprünglichen Programms, eine Zeile die das Jahr und den Inhaber der Urheberrechtsansprüche, und den Text des Urheberrechts an sich, geben. Ein Beispiel wäre::

en: This example follows the `Machine-readable debian/copyright <DEP5_>`_ format. You are encouraged to use this format as well.
de_DE: Dieses Beispiel folgt dem `Machine-lesbaren debian/copyright <DEP5_>`_ Format. Dabei wollen wir ermutigen, dieses Format ebenfalls zu benutzen.

en: The rules file
de_DE: Die rules Datei

en: The last file we need to look at is ``rules``. This does all the work for creating our package. It is a Makefile with targets to compile and install the application, then create the ``.deb`` file from the installed files. It also has a target to clean up all the build files so you end up with just a source package again.
de_DE: Die letzte Datei, die wir uns anschauen ist ``rules``. Hier geschieht alle Arbeit, um das Paket zu erzeugen. Es ist ein Makefile mit Targets, um die Anwendung zu kompilieren und zu installieren, dann die ``.deb`` Datei von den installierten Dateien zu erzeugen. Es enthält auch ein Target um "aufzuräumen", so dass das Quellpaket wieder auf dem ursprünglichen Stand ist.

en: Here is a simplified version of the rules file created by ``dh_make`` (which can be found in the ``dh-make`` package):
de_DE: Hier ist eine vereinfachte Version der rules Datei, die von ``dh_make`` erzeugt wurde (erhältlich im ``dh-make`` Paket):

en: Let us go through this file in some detail. What this does is pass every build target that ``debian/rules`` is called with as an argument to ``/usr/bin/dh``, which itself will call all the necessary ``dh_*`` commands.
de_DE: Lassen Sie uns durch diese Datei ein bisschen genauer durchgehen. Sie sorgt dafür, dass jedes Target, welches von ``debian/rules`` aufgerufen wird, als Argument an ``/usr/bin/dh`` weitergegeben wird, welches selbst wiederum alle nötigen ``dh_*``-Befehle aufrufen wird.

en: ``dh`` runs a sequence of debhelper commands. The supported sequences correspond to the targets of a ``debian/rules`` file: "build", "clean", "install", "binary-arch", "binary-indep", and "binary". In order to see what commands are run in each target, run::
de_DE: ``dh`` durchläuft eine Sequenz von debhelper Kommandos. Die unterstützen Sequenzen korrespondieren mit den Targets einer ``debian/rules``-Datei: "build", "clean", "install", "binary-arch", "binary-indep" und "binary". Um zu sehen, welche Kommandos als Teil welchen Targets durchlaufen werden, benutzen Sie::

en: Commands in the binary-indep sequence are passed the "-i" option to ensure they only work on binary independent packages, and commands in the binary-arch sequences are passed the "-a" option to ensure they only work on architecture dependent packages.
de_DE: Befehlen in der Sequenz binary-indep wird die Option "-i" mitgegeben um sicherzustellen, dass sie nur mit binär-unabhängigen Paketen funktionieren und Befehlen in der Sequenz binary-arch wird die Option "-a" mitgegeben um sicherzustellen, dass sie nur mit Architektur-unabhängigen Paketen funktionieren.

en: Each debhelper command will record when it's successfully run in ``debian/package.debhelper.log``. (Which dh_clean deletes.) So dh can tell which commands have already been run, for which packages, and skip running those commands again.
de_DE: Jeder debhelper Befehl wird aufgenommen wenn er erfolgreich in ``debian/package.debhelper.log`` ausgeführt wird. (Welcher dh_clean löscht.) So kann dh mitteilen welche Befehle bereits für welches Paket ausgeführt wurden und überspringt diejenigen, die nochmals ausgeführt werden sollen.

en: Each time ``dh`` is run, it examines the log, and finds the last logged command that is in the specified sequence. It then continues with the next command in the sequence. The ``--until``, ``--before``, ``--after``, and ``--remaining`` options can override this behavior.
de_DE: Jedes Mal wenn ``dh`` ausgeführt wird, untersucht es die Logdatei und findet den zuletzt verwendeten Befehl welcher in der gegebenen Sequenz enthalten ist. Es springt danach zum nächsten Befehl in der Sequenz. Die Optionen ``--until``, ``--before``, ``--after`` und ``--remaining`` können dieses Verhalten beeinflussen.

en: If ``debian/rules`` contains a target with a name like ``override_dh_command``, then when it gets to that command in the sequence, ``dh`` will run that target from the rules file, rather than running the actual command. The override target can then run the command with additional options, or run entirely different commands instead. (Note that to use this feature, you should Build-Depend on debhelper 7.0.50 or above.)
de_DE: Falls ``debian/rules`` ein Target mit einem Namen wie ``override_dh_command`` enthält, dann wird  ``dh``, sobald es an dem Befehl in der Sequenz angekommen ist, das Target von dieser Anweisungsdatei verwenden statt den eigentlichen Befehl auszuführen. Das neue Target kann dann den Befehl mit anderen Optionen ausführen oder komplett andere Befehle stattdessen ausführen. (Zu beachten ist, dass Sie für die Erstellung debhelper 7.0.50 oder höher verwenden sollten.)

en: Have a look at ``/usr/share/doc/debhelper/examples/`` and ``man dh`` for more examples. Also see `the rules section (Section 4.9) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianrules>`_ of the Debian Policy Manual.
de_DE: Werfen Sie einen Blick in ``/usr/share/doc/debhelper/examples/`` und ``man dh`` für weitere Beispiele. Außerdem ist `der Regelkatalog (Abschnitt 4.9) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianrules>`_ der Debian-Grundsatzanweisung hilfreich.

en: Additional Files
de_DE: Zusätzliche Dateien

en: The install file
de_DE: Die Datei install

en: The ``install`` file is used by ``dh_install`` to install files into the binary package. It has two standard use cases:
de_DE: Die Datei ``install`` wird von ``dh_install`` verwendet, um Dateien in das Binärpacket zu installieren. Es hat zwei gängige Einsatzmöglichkeiten:

en: To install files into your package that are not handled by the upstream build system.
de_DE: Um Dateien in Ihr Paket zu installieren, die nicht vom Upstream-Build-System installiert werden.

en: Splitting a single large source package into multiple binary packages.
de_DE: Aufteilen eines einzelnen großen Quellpaketes in mehrere Binärpakete.

en: In the first case, the ``install`` file should have one line per file installed, specifying both the file and the installation directory. For example, the following ``install`` file would install the script ``foo`` in the source package's root directory to ``usr/bin`` and a desktop file in the ``debian`` directory to ``usr/share/applications``::
de_DE: Im ersten Fall sollte die Datei ``install`` eine Zeile für jede installierte Datei enthalten, die sowohl das Datei- als auch Installationsverzeichnis festlegt. Zum Beispiel, die folgende ``install``-Datei würde das das Skript ``foo`` in das Stammverzeichnis des Quellpakets nach ``usr/bin`` und eine Desktop-Datei in das ``debian``-Verzeichnis nach ``usr/share/applications`` installieren::

en: When a source package is producing multiple binary packages ``dh`` will install the files into ``debian/tmp`` rather than directly into ``debian/<package>``. Files installed into ``debian/tmp`` can then be moved into separate binary packages using multiple ``$package_name.install`` files. This is often done to split large amounts of architecture independent data out of architecture dependent packages and into ``Architecture: all`` packages. In this case, only the name of the files (or directories) to be installed are needed without the installation directory. For example, ``foo.install`` containing only the architecture dependent files might look like::
de_DE: Wenn ein Quellpaket mehrere Binärpakete produziert, wird ``dh`` die Dateien in ``debian/tmp`` statt direkt in ``debian/<package>`` installieren. Dateien aus ``debian/tmp`` können dann in getrennte Binärpakete mithilfe mehrerer ``$package_name.install``-Dateien verschoben werden. Dies wird oft dazu benutzt um große Mengen architekturunabhängiger Daten aus architekturabhängigen Paketen herauszulösen und sie in ``Architecture: all``-Pakete zu integrieren. In diesem Fall werden nur der Name der zu installierenden Dateien (oder Ordner) benötigt und nicht das Installationsverzeichnis. Zum Beispiel könnte ``foo.install`` mit ausschließlich architekturabhängigen Dateien so ausschauen::

en: While ``foo-common.install`` containing only the architecture independent file might look like::
de_DE: Während ``foo-common.install`` mit der architekturunabhängigen Datei so ausschauen könnte::

en: This would create two binary packages, ``foo`` and ``foo-common``. Both would require their own paragraph in ``debian/control``.
de_DE: Dies würde zwei Binärpakete erzeugen, ``foo`` und ``foo-common``. Beide würden ihren eigenen Abschnitt in ``debian/control`` benötigen.

en: See ``man dh_install`` and the `install file section (Section 5.11) <http://www.debian.org/doc/manuals/maint-guide/dother.en.html#install>`_  of the Debian New Maintainers' Guide for additional details.
de_DE: Sehen Sie ``man dh_install`` und den `Abschnitt zur Installationsdatei (Abschnitt 5.11) <http://www.debian.org/doc/manuals/maint-guide/dother.en.html#install>`_  der Debian-Anleitung für neue Maintainers für zusätzliche Informationen.

en: The watch file
de_DE: Die Datei 'watch'

en: The ``debian/watch`` file allows us to check automatically for new upstream versions using the tool ``uscan`` found in the ``devscripts`` package. The first line of the watch file must be the format version (3, at the time of this writing), while the following lines contain any URLs to parse. For example::
de_DE: Die Datei ``debian/watch`` erlaubt uns automatisch mithilfe des Werkzeuges ``uscan`` in dem Paket ``devscripts`` zu überprüfen, ob neue Upstream-Versionen vorhanden sind. Die erste Zeile der "watch"-Datei muss die Format-Version bezeichnen (3, zum Zeipunkt dieser Textfassung), während die folgenden Zeilen die zu parsenden URLs enthalten. Zum Beispiel::

en: Running ``uscan`` in the root source directory will now compare the upstream version number in ``debian/changelog`` with the latest available upstream version. If a new upstream version is found, it will be automatically downloaded. For example::
de_DE: Der Befehl ``uscan`` im Wurzelverzeichnis des Quellcodes wird jetzt die Upstream-Versionsnummer in ``debian/changelog`` mit der neusten verfügbaren Upstream-Version vergleichen. Wenn eine neue Upstream-Version gefunden wurde, wird sie automatisch heruntergeladen. Zum Beispiel::

en: If your tarballs live on Launchpad, the ``debian/watch`` file is a little more complicated (see `Question 21146 <Q21146_>`_ and `Bug 231797 <Bug231797_>`_ for why this is).  In that case, use something like::
de_DE: Wenn Ihre Tarballs auf Launchpad leben, ist die ``debian/watch`` etwas komplizierter (siehe `Frage 21146 <Q21146_>`_ und `Bug 231797 <Bug231797_>`_ für die Gründe). Verwenden Sie in diesem Falle etwas wie:

en: For further information, see ``man uscan`` and the `watch file section (Section 4.11) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianwatch>`_ of the Debian Policy Manual.
de_DE: Für weitere Informationen, schauen Sie ``man uscan`` und die `watch file section (Section 4.11) <http://www.debian.org/doc/debian-policy/ch-source.html#s-debianwatch>`_ im Debian Policy Manual an.

en: For a list of packages where the ``watch`` file reports they are not in sync with upstream see `Ubuntu External Health Status <http://qa.ubuntuwire.org/uehs/no_updated.html>`_.
de_DE: Um eine Liste der Pakete zu sehen, deren ``watch`` Datei eine neuere Version Upstream berichtet, schauen Sie sich `Ubuntu External Health Status <http://qa.ubuntuwire.org/uehs/no_updated.html>`_ an.

en: The source/format file
de_DE: Die Datei source/format

en: This file indicates the format of the source package. It should contain a single line indicating the desired format:
de_DE: Diese Datei spezifiziert das Format des Quellpakets. Es soll eine einzige Zeile enthalten, die das gewünschte Format beschreibt.

en: ``3.0 (native)`` for Debian native packages (no upstream version)
de_DE: ``3.0 (native)`` für native Debian-Pakete (keine Upstreamversion)

en: ``3.0 (quilt)`` for packages with a separate upstream tarball
de_DE: ``3.0 (quilt)`` für Pakete mit einem separaten Upstream-Tarball

en: ``1.0`` for packages wishing to explicitly declare the default format
de_DE: ``1.0`` für Pakete, die explizit das Standard-Format wünschen

en: Currently, the package source format will default to 1.0 if this file does not exist. You can make this explicit in the source/format file. If you choose not to use this file to define the source format, Lintian will warn about the missing file. This warning is informational only and may be safely ignored.
de_DE: Momentan wird das Paket-Quellformat standardmäßig auf 1.0 gesetzt, sollte die Datei nicht existieren. Das kann man jedoch auch explizit in der source/format Datei angeben. Sollten Sie sich dagegen entscheiden, wird lintian eine Warnung wegen der fehlenden Datei ausgeben. Diese Warnung hat lediglich Informationscharakter und kann sicher ignoriert werden.

en: You are encouraged to use the newer 3.0 source format. It provides a number of new features:
de_DE: Entwickler werden ermutigt, das neuere 3.0 Quellformat zu verwenden. Es stellt eine Reihe von Features bereit:

en: Support for additional compression formats: bzip2, lzma and xz
de_DE: Unterstützung für zusätzliche Komprimierungsformate: bzip2, lzma, xz

en: Support for multiple upstream tarballs
de_DE: Ünterstützung für mehrere Upstream-Tarballs

en: Not necessary to repack the upstream tarball to strip the debian directory
de_DE: Nicht nötig den Upsteam-Tarball neu zu packen um das Debian-Verzeichnis zu löschen

en: Debian-specific changes are no longer stored in a single .diff.gz but in multiple patches compatible with quilt under ``debian/patches/``
de_DE: Debian-spezifische Änderung sind nicht länger in einem einzelnen .diff.gz sondern stattdessen in mehreren Patches kompatibel mit quilt unter ``debian/patches/``

en: https://wiki.debian.org/Projects/DebSrc3.0 summarizes additional information concerning the switch to the 3.0 source package formats.
de_DE: https://wiki.debian.org/Projects/DebSrc3.0 fasst weitere zusätzliche Informationen bezüglich der Umstellung auf die 3.0 Quellpaketformate zusammen.

en: See ``man dpkg-source`` and the `source/format section (Section 5.21) <policy-format_>`_  of  the Debian New Maintainers' Guide for additional details.
de_DE: Siehe ``man dpkg-source`` sowie `source/format section (Sektion 5.21)  <policy-format_>`_  des Debian New Maintainers' Guide für weitere Details.

en: Additional Resources
de_DE: Weiterführende Quellen

en: In addition to the links to the Debian Policy Manual in each section above, the Debian New Maintainers' Guide has more detailed descriptions of each file. `Chapter 4, "Required files under the debian directory" <RequiredFiles_>`_ further discusses the  control, changelog, copyright and rules files. `Chapter 5, "Other files under the debian directory" <OtherFiles_>`_ discusses additional files that may be used.
de_DE: Zusätzlich zu den Links im Debian Policy Manual in jeder übergeordneten Sektion bietet der Debian New Maintainers' Guide detailliertere Beschreibungen jeder Datei. `Chapter 4, "Required files under the debian directory" <RequiredFiles_>`_ beschreibt weiterhin die control, changelog, copyright und rules Dateien. `Chapter 5, "Other files under the debian directory" <OtherFiles_>`_ beschreibt zusätzliche Dateien, die verwendet werden können.

en: Fixing a bug in Ubuntu
de_DE: Einen Bug in Ubuntu beheben

en: Introduction
de_DE: Einleitung

en: If you followed the instructions to :doc:`get set up with Ubuntu Development<./getting-set-up>`, you should be all set and ready to go.
de_DE: Wenn Sie die Anweisungen in  :doc:`sich für Ubuntu-Entwicklung einrichten<./getting-set-up>` befolgt haben, sollten Sie bereit sein loszulegen.

en: As you can see in the image above, there is no surprises in the process of fixing bugs in Ubuntu: you found a problem, you get the code, work on the fix, test it, push your changes to Launchpad and ask for it to be reviewed and merged. In this guide we will go through all the necessary steps one by one.
de_DE: Wie man in der obigen Abbildung sehen kann, gibt es wenig Überraschungen im Prozess der Fehlerbehebung: man findet ein Problem, lädt den Quellcode herunter, arbeitet an einer Lösung, lädt die notwendigen Änderungen nach Launchpad und bittet um einen Merge. In diesem Handbuch werden wir alle nötigen Schritte nacheinander behandeln.

en: Finding the problem
de_DE: Das Problem finden

en: There are a lot of different ways to find things to work on. It might be a bug report you are encountering yourself (which gives you a good opportunity to test the fix), or a problem you noted elsewhere, maybe in a bug report.
de_DE: Es gibt viele verschiedene Wege Dinge zu finden an denen man arbeiten kann. Es kann ein Fehlerbericht sein, der einen selbst betrifft (was das Testen vereinfacht), oder ein Problem, das man woanders beobachtet hat, vielleicht auch in einem Fehlerbericht.

en: Take a look at `the bitesize bugs`_ in Launchpad, and that might give you an idea of something to work on. It might also interest you to look at the bugs `triaged`_ by the Ubuntu One Hundred Papercuts team.
de_DE: Schauen Sie die `the bitesize bugs`_ in Launchpad an, was Ihnen eine Vorstellung davon gibt woran man arbeiten kann. Es interessiert Sie vielleicht auch, sich die Bugs anzuschauen, die vom Ubuntu Hundred Papercuts Team `triaged`_ wurden.

en: Figuring out what to fix
de_DE: Herausfinden, was repariert werden muss

en: If you don't know the source package containing the code that has the problem, but you do know the path to the affected program on your system, you can discover the source package that you'll need to work on.
de_DE: Wenn Sie das Quellpaket, das den Fehler beinhaltet nicht kennen, aber der Pfad zu dem betroffenen Programm auf Ihrem System bekannt ist, dann können Sie das Quellpaket selbst ermitteln, an dem Sie arbeiten müssen.

en: Let's say you've found a bug in Bumprace, a racing game. The Bumprace application can be started by running ``/usr/bin/bumprace`` on the command line. To find the binary package containing this application, use this command::
de_DE: Nehmen wir an, dass Sie einen Bug in Bumprace, einem Rennspiel, gefunden haben. Die Bumprace Anwendung kann durch Aufruf von ``/usr/bin/bumprace`` auf der Kommandozeile gestartet werden. Um das Binärpaket zu finden, welches diese Anwendung enthält, verwenden Sie diesen Befehl::

en: This would print out::
de_DE: Dies gibt aus::

en: Note that the part preceding the colon is the binary package name. It's often the case that the source package and binary package will have different names. This is most common when a single source package is used to build multiple different binary packages. To find the source package for a particular binary package, type::
de_DE: Beachten Sie dass der Teil vor der Spalte das Binärpaketname ist. Oft ist es so, dass das Quellpaket und das Binärpaket unterschiedliche Namen haben werden. Dies passiert am häufigsten wenn ein einzelnes Quellpaket verwendet wird um verschiedene unterschiedliche Binärpakete bauen soll. Um das Quellpaket für ein bestimmtes Binärpaket zu finden, geben Sie folgendes ein::

en: ``apt-cache`` is part of the standard installation of Ubuntu.
de_DE: ``apt-cache`` ist Teil der Standardinstallation von Ubuntu.

en: Confirming the problem
de_DE: Das Problem bestätigen

en: Once you have figured out which package the problem is in, it's time to confirm that the problem exists.
de_DE: Sobald Sie herausgefunden haben, in welchem Paket sich das Problem befindet, wird es Zeit zu bestätigen, dass das Problem existiert.

en: Let's say the package ``bumprace`` does not have a homepage in its package description. As a first step you would check if the problem is not solved already. This is easy to check, either take a look at Software Center or run::
de_DE: Sagen wir das Paket ``bumprace`` nennt keine Homepage in seiner Paketbeschreibung. In einem ersten Schritt würde man prüfen, ob das Problem nicht vielleicht bereits behoben ist. Das ist leicht herauszufinden, entweder man schaut in Software Center oder führt folgendes aus::

en: The output should be similar to this::
de_DE: Die Ausgabe sollte etwa so aussehen::

en: A counter-example would be ``gedit``, which has a homepage set::
de_DE: Ein Gegenbeispiel wäre ``gedit``, welches eine Homepage gesetzt hat::

en: Sometimes you will find that a particular problem you are looking into is already fixed. To avoid wasting efforts and duplicating work it makes sense to first do some detective work.
de_DE: Manchmal stellt sich heraus, dass jemand das Problem, das Sie lösen wollten, schon bearbeitet hat. Um doppelte und nutzlose Arbeit zu verhindern, macht es Sinn zuerst ein wenig Detektivarbeit zu leisten.

en: Research bug situation
de_DE: Die Fehlersituation ansehen

en: First we should check if a bug for the problem exists in Ubuntu already. Maybe somebody is working on a fix already, or we can contribute to the solution somehow. For Ubuntu we have a quick look at https://bugs.launchpad.net/ubuntu/+source/bumprace and there is no open bug with our problem there.
de_DE: Zuerst sollte man überprüfen ob bereits ein Bericht über das Problem in Ubuntu zu finden ist. Vielleicht arbeitet bereits jemand an einer Fehlerbehebung oder wir können zu der Lösung beitragen. Für Ubuntu werfen wir einen kurzen Blick auf https://bugs.launchpad.net/ubuntu/+source/bumprace und es gibt dort keinen offenen Problembericht.

en: For Ubuntu the URL ``https://bugs.launchpad.net/ubuntu/+source/<package>`` should always take to the bug page of the source package in question.
de_DE: Für Ubuntu wird die URL ``https://bugs.launchpad.net/ubuntu/+source/<package>`` einen immer auf die Bug-Seite des jeweiligen Pakets führen.

en: For Debian, which is the major source for Ubuntu's packages, we have a look at http://bugs.debian.org/src:bumprace and can't find a bug report for our problem either.
de_DE: Für Debian, welches die Hauptquelle für Ubuntu's Pakete ist, schauen wir auf http://bugs.debian.org/src:bumprace und finden auch keinen bestehenden Fehlerbericht für unser Problem.

en: For Debian the URL ``http://bugs.debian.org/src:<package>`` should always take to the bug page of the source package in question.
de_DE: Für Debian wird die URL ``http://bugs.debian.org/src:<package>`` einen immer auf die Bug-Seite des jeweiligen Pakets führen.

en: The problem we are working on is special as it only concerns the packaging-related bits of ``bumprace``. If it was a problem in the source code it would be helpful to also check the Upstream bug tracker. This is unfortunately often different for every package you have a look at, but if you search the web for it, you should in most cases find it pretty easily.
de_DE: Wir arbeiten an einem besonderen Problem, da es nur die für das Paketieren relevanten Teile des ``bumprace`` betrifft. Wenn es ein Problem im Quellcode wäre, würde es hilfreich sein auch den Upstream-Bugtracker zu überprüfen. Das ist leider von Paket zu Paket unterschiedlich; aber wenn Sie im Web danach suchen, sollte es in den meisten Fällen einfach zu finden sein.

en: Offering help
de_DE: Hilfe anbieten

en: If you found an open bug and it is not assigned to somebody and you are in a position to fix it, you should comment on it with your solution. Be sure to include as much information as you can: Under which circumstances does the bug occur? How did you fix the problem? Did you test your solution?
de_DE: Wenn Sie einen offenen Fehler gefunden haben, dieser noch nicht zugewiesen ist und Sie die Möglichkeit haben ihn zu beheben, sollten Sie einen Kommentar mit Ihrem Lösungsvorschlag abgeben. Geben Sie so viele Informationen wie möglich an: Unter welchen Umständen tritt der Fehler auf? Wie haben Sie den Fehler behoben? Haben Sie die Lösung getestet?

en: If no bug report has been filed, you can file a bug for it. What you might want to bear in mind is: Is the issue so small that just asking for somebody to commit it is good enough? Did you manage to only partially fix the issue and you want to at least share your part of it?
de_DE: Wenn noch kein Fehlerbericht eingesandt wurde, können Sie das tun. Was Sie im Kopf behalten solltn ist: ist das Problem klein genug, dass man vielleicht einfach jemand direkt darum bittet einen Patch hoch zu laden? Haben Sie es vielleicht geschafft einen Teil des Problems zu beheben und wollen dies mitteilen?

en: It is great if you can offer help and will surely be appreciated.
de_DE: Es ist toll wenn Sie Hilfe anbieten können und man wird dafür sehr dankbar sein.

en: Getting the code
de_DE: Den Quellcode herunterladen

en: Once you know the source package to work on, you will want to get a copy of the code on your system, so that you can debug it. The ubuntu-dev-tools package has a tool called ``pull-lp-source`` that a developer can use to grab the source code for any package. For example, to grab the source code for the tomboy package in ``xenial``, you can type this::
de_DE: Sobald das Quellpaket bekannt ist auf dem gearbeitet werden soll, möchten Sie wahrscheinlich eine Kopie des Codes haben damit Sie diesen verbessern können. Das ubuntu-dev-tools Paket beinhaltet ein Werkzeug namens ``pull-lp-source`` welches ein Entwickler nutzen kann um den Quelltext jedes Pakets zu bekommen. Beispiel: Um den Sourcecode für das das Paket tomboy zu in ``xenial`` zu bekommen, können Sie dies eingeben::

en: If you do not specify a release such as ``xenial``, it will automatically get the package from the development version.
de_DE: Wird keine Veröffentlichung wie ``xenial`` angeben, wird automatisch das Paket der Entwicklungsversion geholt.

en: Once you've got a local clone of the source package, you can investigate the bug, create a fix, generate a debdiff, and attach your debdiff to a bug report for other developers to review. We'll describe specifics in the next sections.
de_DE: Sobald man eine lokale Kopie des Quellpakets hat, kann man den Bug untersuchen, eine Behebung erstellen, ein debdiff erstellen und sein debdiff an einen Bug-Report zur Überprüfung durch andere Entwickler anhängen. Wir werden die Besonderheiten in den nächsten Abschnitten beschreiben.

en: Work on a fix
de_DE: Arbeiten an einer Fehlerbehebung

en: There are entire books written about finding bugs, fixing them, testing them, etc. If you are completely new to programming, try to fix easy bugs such as obvious typos first. Try to keep changes as minimal as possible and document your change and assumptions clearly.
de_DE: Es wurden ganze Bücher darüber verfasst, wie man Fehler findet, sie behebt, testet, usw. Wenn Sie ein Anfänger im Programmieren sind, versuchen Sie zuerst einfache Fehler wie beispielsweise in der Rechtschreibung zu beheben. Versuchen Sie die Änderungen so minimal wie möglich zu halten und dokumentieren Sie Ihre Änderungen und Annahmen übersichtlich.

en: Before working on a fix yourself, make sure to investigate if nobody else has fixed it already or is currently working on a fix. Good sources to check are:
de_DE: Bevor Sie sich daran machen, einen Fehler selbst zu beheben, sollten Sie sicherstellen, dass nicht schon ein anderer diesen Fehler behoben hat oder gerade daran arbeitet. Anlaufstellen dafür sind:

en: Upstream (and Debian) bug tracker (open and closed bugs),
de_DE: Upstream (und Debian) Fehlererfassung (offene and geschlossene Fehler),

en: Upstream revision history (or newer release) might have fixed the problem,
de_DE: Die Upstream-Revisionseinträge (oder eine neue Veröffentlichung) haben möglicherweise das Problem behoben,

en: bugs or package uploads of Debian or other distributions.
de_DE: Fehler oder Paket-Uploads von Debian oder einer anderen Distribution

en: You may want to create a patch which includes the fix. The command ``edit-patch`` is a simple way to add a patch to a package. Run::
de_DE: Sie möchten vielleicht einen Patch erstellen, der die Behebung enthält. Der Befehl ``edit-patch`` ist eine einfache Art einen Patch einem Paket hinzuzufügen. Starten Sie::

en: This will copy the packaging to a temporary directory.  You can now edit files with a text editor or apply patches from upstream, for example::
de_DE: Das wird die Paketierung in temporäres Verzeichnis kopieren. Sie können nun die Dateien mit einem Texteditor bearbeiten oder die Patches vom Upstream anwenden, zum Beispiel::

en: After editing the file type ``exit`` or press ``control-d`` to quit the temporary shell.  The new patch will have been added into ``debian/patches``.
de_DE: Nachdem Sie die Datei bearbeitet haben, schreiben Sie ``exit`` oder drücken ``Strg+D`` um die zeitweilige Umgebung zu verlassen. Der neue Patch wird dann unter ``debian/patches`` eingefügt.

en: You must then add a header to your patch containing meta information so that other developers can know the purpose of the patch and where it came from. To get the template header that you can edit to reflect what the patch does, type this::
de_DE: Sie müssen dann einen Header zu Ihrem Patch inklusive Metainformationen hinzufügen, so dass andere Entwickler den Zweck des Patches kennen und woher dieser stammt. Um den Vorlagen-Header zum Editieren zu bekommen, um zu zeigen was der Patch macht, geben Sie folgendes ein::

en: This will open the template in a text editor. Follow the template and make sure to be thorough so you get all the details necessary to describe the patch.
de_DE: Dies wird die Vorlage in einem Texteditor öffnen. Folgen Sie der Vorlage und vergewisseren sich, dass Sie ausführlich sind, so dass alle nötigen Details, die den Patch beschreiben, vorhanden sind.

en: In this specific case, if you just want to edit ``debian/control``, you do not need a patch. Put ``Homepage: http://www.linux-games.com/bumprace/`` at the end of the first section and the bug should be fixed.
de_DE: Wenn Sie nur``debian/control`` in diesem spezifischen Fall bearbeiten möchten brauchen Sie keinen Patch. Tragen Sie ``Homepage: http://www.linux-games.com/bumprace/`` am Ende der ersten Sektion ein und der Bug sollte behoben sein.

en: Documenting the fix
de_DE: Die Lösung dokumentieren

en: It is very important to document your change sufficiently so developers who look at the code in the future won't have to guess what your reasoning was and what your assumptions were. Every Debian and Ubuntu package source includes ``debian/changelog``, where changes of each uploaded package are tracked.
de_DE: Es ist sehr wichtig Ihre Änderung ausreichend zu dokumentieren, so dass Entwickler, die sich den Code zukünftig ansehen, nicht raten müssen, was Ihre Gründe und Annahmen gewesen sind. Jedes Debian- und Ubuntu-Quellpaket beinhaltet die Datei ``debian/changelog``, wo die Änderungen jedes hochgeladenen Paketes dokumentiert werden.

en: The easiest way to update this is to run::
de_DE: Die einfachste Möglichkeit um zu updaten ist den Befehl auszuführen::

en: This will add a boilerplate changelog entry for you and launch an editor where you can fill in the blanks. An example of this could be::
de_DE: Dies wird eine Vorlage für einen Changelog-Eintrag für Sie erstellen, wo Sie die Lücken ausfüllen können. Ein Beispiel dafür wäre etwa::

en: ``dch`` should fill out the first and last line of such a changelog entry for you already. Line 1 consists of the source package name, the version number, which Ubuntu release it is uploaded to, the urgency (which almost always is 'low'). The last line always contains the name, email address and timestamp (in :rfc:`5322` format) of the change.
de_DE: ``dch`` sollte die erste und letzte Zeile von solch einem Änderungsprotokolleintrag bereits für Sie ausgefüllt haben. Zeile 1 enthält den Quellpaketnamen, die Versionsnummer, die Ubuntu-Zielversion und die Dringlichkeit (welche meistens »low« ist). Die letzte Zeile enthält immer den Namen des Autors, E-Mail-Adresse und Zeitstempel (im Format :rfc:`5322`) der Änderung.

en: With that out of the way, let's focus on the actual changelog entry itself: it is very important to document:
de_DE: Wenn dieses Hindernis beseitigt ist, können wir uns auf den eigentlichen Eintrag des Änderungsprotokolls selbst konzentrieren: Es ist sehr wichtig festzuhalten:

en: Where the change was done.
de_DE: Wo die Änderung gemacht wurde.

en: What was changed.
de_DE: Was geändert wurde.

en: Where the discussion of the change happened.
de_DE: Wo die Diskussion um die Änderung statt fand.

en: In our (very sparse) example the last point is covered by ``(LP: #123456)`` which refers to Launchpad bug 123456. Bug reports or mailing list threads or specifications are usually good information to provide as a rationale for a change. As a bonus, if you use the ``LP: #<number>`` notation for Launchpad bugs, the bug will be automatically closed when the package is uploaded to Ubuntu.
de_DE: In unserem (sehr dürftigen) Beispiel ist der letzte Punkt mit ``(LP: #123456)`` abgedeckt, was sich auf den Launchpad-Fehler 123456 bezieht. Fehlerberichte, Beiträge zu Mailing-Listen oder Spezifikationen sind allgemein gute Informationen, die als Rationale für eine Änderung angegeben werden können. Zusätzlich wird im Falle der Verwendung von ``LP: #<Nummer>`` der angegebene Fehler automatisch geschlossen, wenn das Paket zu Ubuntu hochgeladen wird.

en: In order to get it sponsored in the next section, you need to file a bug report in Launchpad (if there isn't one already, if there is, use that) and explain why your fix should be included in Ubuntu. For example, for tomboy, you would file a bug `here`_ (edit the URL to reflect the package you have a fix for). Once a bug is filed explaining your changes, put that bug number in the changelog.
de_DE: Um Unterstützung im nächsten Abschnitt zu bekommen ist es nötig, einen Bugreport in Lauchpad zu erstellen (falls noch keiner vorhanden ist, falls doch – verwenden Sie diesen) und zu erklären warum Ihre Behebung in Ubuntu enthalten sein sollte. Beispielsweise bei tomboy würde man einen Bug `hier`_  angeben (bearbeiten Sie die URL für das Paket für das Sie eine Behebung haben). Sobald ein Bug aufgegeben wurde, der Ihre Änderungen erklärt, geben Sie diese Bugnummer im Changelog ein.

en: Testing the fix
de_DE: Die Lösung testen

en: To build a test package with your changes, run these commands::
de_DE: Um ein Testpaket mit Ihren Änderungen zu bauen, durchlaufen Sie diese Kommandos::

en: This will create a source package from the branch contents (``-us -uc`` will just omit the step to sign the source package and ``-d`` will skip the step where it checks for build dependencies, pbuilder will take care of that) and ``pbuilder-dist`` will build the package from source for whatever ``release`` you choose.
de_DE: Dies wird ein Quellpaket von den Zweiginhalten (``-us -uc`` wird nur den Schritt der Unterzeichnung des Quellpakets überspringen und``-d`` wird den Schritt der Prüfung nach Build-Abhängigkeiten auslassen, pbuilder wird sich darum kümmern) und ``pbuilder-dist`` wird das Paket aus den Quellen für jegliches gewählte ``release`` bauen.

en: If ``debuild`` errors out with "Version number suggests Ubuntu changes, but Maintainer: does not have Ubuntu address" then run the ``update-maintainer`` command (from ubuntu-dev-tools) and it will automatically fix this for you. This happens because in Ubuntu, all Ubuntu Developers are responsible for all Ubuntu packages, while in Debian, packages have maintainers.
de_DE: Wenn ``debuild`` folgende Fehlermeldung ausgibt "Version number suggests Ubuntu changes, but Maintainer: does not have Ubuntu address" starten Sie den ``update-maintainer`` Befehl (aus ubuntu-dev-tools) und es wird dies automatisch für Sie beheben. Dies passiert weil in Ubuntu alle Ubuntu Entwickler für alle Ubuntu-Pakete verantwortlich sind. In Debian hingegen haben die Pakete Maintainer.

en: In this case with bumprace, run this to view the package information::
de_DE: Im Falle von bumprace, starten Sie folgendes um die Paketinformationen zu sehen::

en: As expected, there should now be a ``Homepage:`` field.
de_DE: Wie erwartet sollte nun ein ``Homepage:`` Feld dort sein.

en: In a lot of cases you will have to actually install the package to make sure it works as expected. Our case is a lot easier. If the build succeeded, you will find the binary packages in ``~/pbuilder/<release>_result``. Install them via ``sudo dpkg -i <package>.deb`` or by double-clicking on them in your file manager.
de_DE: In vielen Fällen werden Sie das Paket auch installieren müssen, um zu prüfen, dass alles funktioniert. In unserem Fall ist das viel einfacher. Wenn der Build erfolgreich war, werden Sie die Binärpakete in ``~/pbuilder/<release>_result`` finden. Installieren Sie sie einfach per ``sudo dpkg -i <package>.deb`` oder indem Sie auf sie im Dateimanager doppelt-klicken.

en: Submitting the fix and getting it included
de_DE: Einreichen der Behebung und es einbringen

en: With the changelog entry written and saved, run ``debuild`` one more time::
de_DE: Sobald der changelog Eintrag geschrieben und gespeichert ist, starten Sie ``debuild`` noch einmal::

en: and this time it will be signed and you are now ready to get your diff to submit to get sponsored.
de_DE: und dieses Mal wird es unterschrieben werden und Sie sind nun bereit, Ihr diff einzuschicken und Unterstützung zu bekommen.

en: In a lot of cases, Debian would probably like to have the patch as well (doing this is best practice to make sure a wider audience gets the fix). So, you should submit the patch to Debian, and you can do that by simply running this::
de_DE: In vielen Fällen möchte Debian eventuell den Patch ebenfalls haben (dies zu tun ist vorbildlich um sicherzustellen dass ein weiterer Kreis die Behebung bekommt). Somit sollten Sie den Patch an Debian schicken und Sie können dies wie folgt tun::

en: This will take you through a series of steps to make sure the bug ends up in the correct place. Be sure to review the diff again to make sure it does not include random changes you made earlier.
de_DE: Dies wird Sie durch eine Reihe von Schritten führen, um sicherzustellen, dass der Bug an der richtigen Stelle landet. Überprüfen Sie das Diff noch einmal, um sicherzustellen, dass es keine unerwünschten Änderungen enthält, die Sie vorher gemacht haben.

en: Communication is important, so when you add some more description to it to the inclusion request, be friendly, explain it well.
de_DE: Kommunikation ist wichtig, also sollten Sie mehr Beschreibung mitliefern, wenn Sie darum bitten die Änderung einzupflegen. Seien Sie freundlich, erklären Sie es ausreichend.

en: If everything went well you should get a mail from Debian's bug tracking system with more information. This might sometimes take a few minutes.
de_DE: Wenn alles geklappt hat, sollten Sie eine Mail von Debian's Bug-Tracker mit weiteren Informationen bekommen. Dies kann manchmal einige Minuten dauern.

en: It might be beneficial to just get it included in Debian and have it flow down to Ubuntu, in which case you would not follow the below process. But, sometimes in the case of security updates and updates for stable releases, the fix is already in Debian (or ignored for some reason) and you would follow the below process. If you are doing such updates, please read our :doc:`Security and stable release updates<./security-and-stable-release-updates>` article. Other cases where it is acceptable to wait to submit patches to Debian are Ubuntu-only packages not building correctly, or Ubuntu-specific problems in general.
de_DE: Es mag vorteilhaft sein, es einfach in Debian einzubringen und es zu Ubuntu fließen zu lassen. In diesem Falle folgt man nicht dem untenstehenden Prozess. Aber manchmal im Falle von Security-Updates und Updates für stabile Veröffentlichungen ist die Behebung bereits in Debian enthalten (oder wird aus einem bestimmten Grund ignoriert) und Sie möchten dem untenstehenden Prozess folgen. Wenn Sie solche Updates machen, lesen Sie bitte unseren Artikel :doc:`Security and stable release updates<./security-and-stable-release-updates>`. Andere Fälle wo es möglich ist zu warten Patches an Debian zu schicken, sind reine Ubuntu Pakete, die nicht korrekt bauen oder Ubuntu-spezifische allgemeine Probleme.

en: But if you're going to submit your fix to Ubuntu, now it's time to generate a "debdiff", which shows the difference between two Debian packages. The name of the command used to generate one is also ``debdiff``. It is part of the ``devscripts`` package. See ``man debdiff`` for all the details. To compare two source packages, pass the two dsc files as arguments::
de_DE: Aber wenn Sie vorhaben Ihre Behebung an Ubuntu zu schicken wird es nun Zeit, ein "debdiff" zu erstellen. Dieses soll den Unterschied zwischen zwei Debian Paketen zeigen. Der Name des Befehls um eins zu erstellen ist ebenfalls ``debdiff``. Es ist Teil des ``devscripts`` Pakets. Siehen Sie ``man debdiff`` für alle Details. Um zwei Quellpakete zu vergleichen, geben Sie die zwei dsc-Dateien als Argumente an::

en: In this case, ``debdiff`` the dsc you downloaded with ``pull-lp-source`` and the new dsc file you generated. This will generate a patch that your sponsor can then apply locally (by using ``patch -p1 < /path/to/debdiff``). In this case, pipe the output of the debdiff command to a file that you can then attach to the bug report::
de_DE: In diesem Fall wenden Sie ein ``debdiff`` auf das heruntergeladene dsc mit ``pull-lp-source`` an sowie auf die neue dsc-Datei die Sie erstellt haben. Dies wird einen Patch erstellen, die Ihr Sponst lokal anwenden kann (durch ``patch -p1 < /path/to/debdiff``). In diesem Fall wenden Sie eine Pipe auf die Ausgabe des debdiff Befehls auf eine Datei an, die man dann dem Bugreport anhängen kann::

en: The format shown in ``1-1.0-1ubuntu1.debdiff`` shows:
de_DE: Das Format, welches in ``1-1.0-1ubuntu1.debdiff`` gezeigt wird, zeigt:

en: ``1-`` tells the sponsor that this is the first revision of your patch. Nobody is perfect, and sometimes follow-up patches need to be provided. This makes sure that if your patch needs work, that you can keep a consistent naming scheme.
de_DE: ``1-`` informiert den Betreuer, dass dies die erste Revision Ihres Patches ist. Niemand ist perfekt und machmal müssen Nachfolge-Patches angeboten werden. Dies stellt sicher, dass falls Ihr Patch mehr Arbeit benötigt, man ein konsistentes Namensschema verwenden kann.

en: ``1.0-1ubuntu1`` shows the new version being used. This makes it easy to see what the new version is.
de_DE: ``1.0-1ubuntu1`` zeigt die neue Version, die verwendet wird. Dies macht es einfach festzustellen, welche die neue Version ist.

en: ``.debdiff`` is an extension that makes it clear that it is a debdiff.
de_DE: ``.debdiff`` ist eine Erweiterung, die illustriert, dass es ein debdiff ist.

en: While this format is optional, it works well and you can use this.
de_DE: Während dieses Format optional ist, funktioniert es gut und Sie können dies verwenden.

en: Next, go to the bug report, make sure you are logged into Launchpad, and click "Add attachment or patch" under where you would add a new comment. Attach the debdiff, and leave a comment telling your sponsor how this patch can be applied and the testing you have done. An example comment can be::
de_DE: Gehen Sie anschließend zu dem Fehlerbericht, vergewisseren Sie sich, dass Sie auf Launchpad eingeloggt sind und klicken auf "Add attachment or patch" wo Sie einen neuen Kommentar hinzufügen. Hängen Sie das debdiff an und hinterlassen einen Kommentar, der Ihrem Betreuer sagt, wie dieser Patch angewendet werden kann und welche Tests erfolgt sind. Ein Beispielkommentar kann wie folgt aussehen::

en: Make sure you mark it as a patch (the Ubuntu Sponsors team will automatically be subscribed) and that you are subscribed to the bug report. You will then receive a review anywhere between several hours from submitting the patch to several weeks. If it takes longer than that, please join ``#ubuntu-motu`` on ``freenode`` and mention it there. Stick around until you get an answer from someone, and they can guide you as to what to do next.
de_DE: Vergewissern Sie sich, dass Sie es als einen Patch markieren (das Ubuntu Sponsors Team wird automatisch abonniert) und dass Sie den Fehlerbericht abonniert haben. Sie werden dann eine Durchsicht irgendwo zwischen mehreren Stunden seit dem Einreichen des Patches zu mehreren Wochen bekommen. Wenn dies länger dauern sollte, treten Sie bitte ``#ubuntu-motu`` auf ``freenode`` bei und erwähnen es dort. Bleiben Sie so lange da, bist Sie eine Antwort von jemand bekommen und diese Leute Sie anweisen, was als nächstes zu tun ist.

en: Once you have received a review, your patch was either uploaded, your patch needs work, or is rejected for some other reason (possibly the fix is not fit for Ubuntu or should go to Debian instead). If your patch needs work, follow the same steps and submit a follow-up patch on the bug report, otherwise submit to Debian as shown above.
de_DE: Sobald Sie einen Review erhalten haben, wurde Ihr Patch entweder hochgeladen, Ihr Patch braucht noch Arbeit oder wurde aus anderen Gründen abgelehnt (eventuell passt die Behebung nicht für Ubuntu und sollte stattdessen zu Debian gehen). Wenn den Patch noch etwas Arbeit benötigt, folgen Sie den gleichen Schritten und senden einen Folge-Patch im Bugreport. In anderen Fällen senden Sie diesen an Debian wie oben gezeigt.

en: Remember: good places to ask your questions are ``ubuntu-motu@lists.ubuntu.com`` and ``#ubuntu-motu`` on freenode. You will easily find a lot of new friends and people with the same passion that you have: making the world a better place by making better Open Source software.
de_DE: Bedenken Sie: Gute Orte um Ihre Fragen zu stellen sind ``ubuntu-motu@lists.ubuntu.com`` und ``#ubuntu-motu`` auf freenode. Sie werden leicht viele neue Freunde finden sowie Leute mit der gleichen Leidenschaft, wie Sie sie haben: Die Welt einen besseren Ort durch die Herstellung besserer Open Source Software machen.

en: Additional considerations
de_DE: Weitere Überlegungen

en: If you find a package and find that there are a couple of trivial things you can fix at the same time, do it. This will speed up review and inclusion.
de_DE: Wenn Sie ein Paket finden und es sich herausstellt, dass Sie mehrere triviale Dinge darin beheben können, machen Sie es ruhig in einer Änderung. Das wird die Code-Review und das Einpflegen beschleunigen.

en: If there are multiple big things you want to fix, it might be advisable to send individual patches or merge proposals instead. If there are individual bugs filed for the issues already, this makes it even easier.
de_DE: Sollte es mehrere große Dinge geben, die Sie beheben wollen, mag es Sinn ergeben stattdessen mehrere Patches oder Merge Proposals einzuschicken. Sollte es bereits individuelle Bugs dafür geben, macht das die Sache sogar noch einfacher.

en: Fixing FTBFS packages
de_DE: FTBFS-Pakete reparieren

en: Before a package can be used in Ubuntu, it has to build from source. If it fails this, it will probably wait in -proposed and will not be available in the Ubuntu archives. You can find a complete list of packages that are failing to build from source at http://qa.ubuntuwire.org/ftbfs/. There are 5 main categories shown on the page:
de_DE: Bevor ein Paket in Ubuntu verwendet werden kann, muss es aus den Quellen erstellt werden können. Falls dies nicht gelingt wird es in -proposed warten und ist daher nicht in den Ubuntu-Archiven verfügbar. Eine vollständige Liste solcher Pakete finden Sie unter http://qa.ubuntuwire.org/ftbfs/. Auf der Seite werden 5 Kategorien angezeigt:

en: Package failed to build (F): Something actually went wrong with the build process.
de_DE: Paket konnte nicht erstellt werden (F): Beim Erstellen trat ein Fehler auf.

en: Cancelled build (X): The build has been cancelled for some reason. These should probably be avoided to start with.
de_DE: Erstellung abgebrochen (X): Die Erstellung wurde aus einem Grund abgebrochen. Davon sollten folgende von Anfang vermieden werden.

en: Package is waiting on another package (M): This package is waiting on another package to either build, get updated, or (if the package is in main) one of it's dependancies is in the wrong part of the archive.
de_DE: Paket wartet auf ein anderes Paket (M): Dieses Paket wartet bis ein anderes anderes Paket erstellt oder aktualisiert wird oder (wenn das Paket in main ist) eine seiner Abhängigkeiten ist im falschen Archiv-Teil.

en: Failure in the chroot (C): Part of the chroot failed, this is most likely fixed by a rebuild. Ask a developer to rebuild the package and that should fix it.
de_DE: Fehler im chroot (C): Ein Teil des chroot ist fehlgeschlagen, das kann meist durch eine Neuerstellung des Pakets behoben werden. Bitten Sie einen Entwickler eine Neuerstellung vorzunehmen.

en: Failed to upload (U): The package could not upload. This is usually just a case of asking for a rebuild, but check the build log first.
de_DE: Fehler beim Hochladen (U): Das Paket konnte nicht hochgeladen werden. Das ist normalerweise ein Fall um eine Neuerstellung zu bitten, aber überprüfen Sie zuerst das Erstellungsprotokoll.

en: First steps
de_DE: Erste Schritte

en: The first thing you'll want to do is see if you can reproduce the FTBFS yourself. Get the code either by running ``bzr branch lp:ubuntu/PACKAGE`` and then getting the tarball or running ``dget PACKAGE_DSC`` on the .dsc file from the launchpad page. Once you have that, build it in a schroot.
de_DE: Als erstes sollten Sie versuchen das FTBFS selbst zu reproduzieren. Holen Sie sich den Code entweder per ``bzr branch lp:ubuntu/PACKAGE`` und dann den Tarball oder per ``dget PACKAGE_DSC`` auf der ".dsc"-Datei von der Launchpad-Seite. Ist das einmal erledigt, erstellen Sie es in einer schroot.

en: You should be able to reproduce the FTBFS. If not, check if the build is downloading a missing dependency, which means you just need to make that a build-dependency in debian/control. Building the package locally can also help find if the issue is caused by a missing, unlisted, dependency (builds locally but fails on a schroot).
de_DE: Sie sollten in der Lage sein das FTBFS zu reproduzieren. Wenn nicht, überprüfen Sie ob gerade eine fehlende Abhängigkeit heruntergeladen wird, was bedeutet das Sie sie zu einer Erstellungsabhängigkeit in debain/control machen müssen. Ein Paket lokal zu erstellen hilft auch ein Problem ausfindig zu machen, was durch eine fehlende, nicht aufgeführte Abhängigkeit verursacht wird (funktioniert lokal aber nicht in einer schroot).

en: Checking Debian
de_DE: Debian überprüfen

en: Once you have reproduced the issue, it's time to try and find a solution. If the package is in Debian as well, you can check if the package builds there by going to http://packages.qa.debian.org/PACKAGE. If Debian has a newer version, you should merge it. If not, check the buildlogs and bugs linked on that page for any extra information on the ftbfs or patches. Debian also maintains a list of command FTBFSs and how to fix them which can be found at https://wiki.debian.org/qa.debian.org/FTBFS, you will want to check it for solutions too.
de_DE: Können Sie das Problem reproduzieren, ist es an der Zeit eine Lösung zu finden. Falls das Paket auch in Debian enthalten ist, können Sie überprüfen ob es dort erstellt werden kann, indem Sie auf http://packages.qa.debian.org/PACKAGE gehen. Falls Debian eine aktuelle Version einsetzt, solltest Sie diese mergen. Falls nicht, überprüfen Sie die Erstellungs- und Fehlerberichte, die auf der Seite verlinkt sind, für zusätzliche Infos über FTBFS oder Patches. Debian betreut auch eine Liste von Befehl-FTBFS und wie sie behoben werden können; sie ist unter https://wiki.debian.org/qa.debian.org/FTBFS zu finden, Sie werden sie sicher auch bei der Lösungssuche einbeziehen wollen.

en: Other causes of a package to FTBFS
de_DE: Andere Gründe warum die Paketerstellung fehlschlägt

en: If a package is in main and missing a dependency that is not in main, you will have to file a MIR bug. https://wiki.ubuntu.com/MainInclusionProcess explains the procedure.
de_DE: Wenn ein Paket in main enthalten ist, aber eine dessen Abhängigkeiten nicht in main vorhanden ist, sollte ein MIR-Fehlerbericht eingereicht werden. https://wiki.ubuntu.com/MainInclusionProcess erklärt den Ablauf.

en: Fixing the issue
de_DE: Das Problem beheben

en: Once you have found a fix to the problem, follow the same process as any other bug. Make a patch, add it to a bzr branch or bug, subscribe ubuntu-sponsors, then try to get it included upstream and/or in Debian.
de_DE: Haben Sie erst einmal eine Lösung für das Problem gefunden, folgen Sie demselben Prozess wie bei jedem anderen Fehler. Erstellen Sie einen Patch, hängen ihn an einen bzr-Zweig oder -Fehler an, informieren ubuntu-sponsors, und versuchen dann das der Patch von Upstream und/oder Debian aufgenommen wird.

en: Getting Set Up
de_DE: Die Programme einrichten

en: There are a number of things you need to do to get started developing for Ubuntu. This article is designed to get your computer set up so that you can start working with packages, and upload your packages to Ubuntu's hosting platform, Launchpad. Here's what we'll cover:
de_DE: Es gibt einiges zu tun, bevor Sie mit der Ubuntu-Entwicklung loslegen können. Dieser Artikel wird Ihnen helfen, Ihr System so einzurichten, dass Sie mit Paketen arbeiten und Ihre Pakete auf Ubuntu's Hosting-Platform, Launchpad, hochladen können. Hierüber werden wir reden:

en: Installing packaging-related software. This includes:
de_DE: Paketierungs-Software installieren. Dies beinhaltet:

en: Ubuntu-specific packaging utilities
de_DE: Ubuntu-spezifische Paketierungs-Werkzeuge

en: Encryption software so your work can be verified as being done by you
de_DE: Verschlüsselungssoftware so dass Ihre Arbeit als Ihre eigene verifiziert werden kann

en: Additional encryption software so you can securely transfer files
de_DE: Weitere Verschlüsselungssoftware so dass Sie sichere Dateitransfers machen können

en: Creating and configuring your account on Launchpad
de_DE: Ihren Account auf Lauchpad erstellen und einrichten

en: Setting up your development environment to help you do local builds of packages, interact with other developers, and propose your changes on Launchpad.
de_DE: Ihre Entwicklungsumgebung aufsetzen, so dass Sie lokale Builds von Paketen machen, mit anderen Entwicklern interagieren und Ihre Änderungswünsche in Launchpad unterbreiten können.

en: It is advisable to do packaging work using the current development version of Ubuntu. Doing so will allow you to test changes in the same environment where those changes will actually be applied and used.
de_DE: Es macht Sinn, Paketierungaufgaben direkt in der Entwicklungsversion von Ubuntu zu machen. Dies wird es Ihnen erlauben Ihre Änderungen in derselben Umgebung zu testen, wo diese später eingepflegt und verwendet werden.

en: Don't want to install the latest development version of Ubuntu? Spin up an `LXD container <https://help.ubuntu.com/lts/serverguide/lxd.html>`_.
de_DE: Sie möchten nicht die neueste Ubuntu Entwicklerversion installieren? Richten Sie einen `LXD container <https://help.ubuntu.com/lts/serverguide/lxd.html>`_  ein.

en: Install basic packaging software
de_DE: Grundlegende Paketierungs-Software installieren

en: There are a number of tools that will make your life as an Ubuntu developer much easier. You will encounter these tools later in this guide. To install most of the tools you will need run this command::
de_DE: Es gibt eine Reihe von Werkzeugen, die Ihr Leben als Ubuntu Entwickler viel leichter machen. Auf diese Werkzeuge stossen Sie später in diesem Handbuch. Um den Großteil der Werkzeuge zu installieren brauchen Sie diesen Befehl::

en: This command will install the following software:
de_DE: Dieser Befehl wird folgende Software installieren:

en: ``gnupg`` -- `GNU Privacy Guard <GPG_>`_ contains tools you will need to create a cryptographic key with which you will sign files you want to upload to Launchpad.
de_DE: ``gnupg`` -- `GNU Privacy Guard <GPG_>`_ enthält Werkzeuge die Sie brauchen werden, um einen kryptografischen Schlüssel zu erstellen mit dem Sie Dateien unterzeichnen werden, die Sie auf Launchpad hochladen möchten.

en: ``pbuilder`` -- a tool to do reproducible builds of a package in a clean and isolated environment.
de_DE: ``pbuilder`` -- ein Werkzeug um reproduzierbare Builds eines Pakets in einer sauberen und isolierten Umgebung zu machen.

en: ``ubuntu-dev-tools`` (and ``devscripts``, a direct dependency) -- a collection of tools that make many packaging tasks easier.
de_DE: ``ubuntu-dev-tools`` (und ``devscripts``, eine direkte Abhängkigkeit) -- eine Sammlung von Werkzeugen, die viele Paketierungsaufgaben einfacher machen.

en: ``apt-file`` provides an easy way to find the binary package that contains a given file.
de_DE: ``apt-file`` ist eine einfache Möglichkeit das Binärpaket zu finden welches eine gegebene Datei enthält.

en: Create your GPG key
de_DE: Ihren GPG-Schlüssel erstellen

en: GPG stands for `GNU Privacy Guard <GPG_>`_ and it implements the OpenPGP standard which allows you to sign and encrypt messages and files. This is useful for a number of purposes. In our case it is important that you can sign files with your key so they can be identified as something that you worked on. If you upload a source package to Launchpad, it will only accept the package if it can absolutely determine who uploaded the package.
de_DE: GPG steht für `GNU Privacy Guard <GPG_>`_ und es implementiert den OpenPGP Standard, der es möglich macht, Nachrichten und Dateien zu signieren und zu verschlüsseln. Dies ist für verschiedene Zwecke wichtig. In unserem Falle ist es wichtig, dass Sie Dateien mit Ihrem Schlüssel signieren können, so dass sie identifizieren, dass es etwas ist woran Sie gearbeitet haben. Wenn Sie ein Quellpaket auf Launchpad hochladen, wird dieses das Paket nur akzeptieren wenn es genau bestimmen kann wer das Paket hochgeladen hat.

en: To generate a new GPG key, run::
de_DE: Um Ihren GPG-Schlüssel zu erstellen, starten Sie::

en: GPG will first ask you which kind of key you want to generate. Choosing the default (RSA and DSA) is fine. Next it will ask you about the keysize. The default (currently 2048) is fine, but 4096 is more secure. Afterwards, it will ask you if you want it to expire the key at some stage. It is safe to say "0", which means the key will never expire. The last questions will be about your name and email address. Just pick the ones you are going to use for Ubuntu development here, you can add additional email addresses later on. Adding a comment is not necessary. Then you will have to set a passphrase, choose a safe one (a passphrase is just a password which is allowed to include spaces).
de_DE: GPG fragt zuerst, welche Art von Schlüssel Sie generieren möchten. Die Standardauswahl (RSA und DSA) ist eine gute Wahl. Als nächstes werden Sie nach der Schlüsselgröße gefragt. Die Standardauswahl (zur Zeit 2048) ist zwar eine gute Wahl, aber 4096 bietet deutlich mehr Sicherheit. Danach müssen Sie angeben, ob der Schlüssel zu einem bestimmten Zeitpunkt ungültig werden soll. Auch hier ist die Stadardauswahl »0« ein guter Wert, der bedeutet, dass der Schlüssel unbegrenzt gültig ist. Zum Schluss werden noch Ihr Name sowie Ihre E-Mail-Adresse abgefragt. Geben Sie hier die E-Mail-Adresse an, mit der Sie bei der Entwicklung bei Ubuntu tätig sein möchten. Bei Bedarf können später weitere hinzugefügt werden. Die letzte Angabe ist eine Passphrase (eine Passphrase ist ein Passwort, in dem auch Leerzeichen enthalten sein dürfen). Sie sollte sehr sicher sein.

en: Now GPG will create a key for you, which can take a little bit of time; it needs random bytes, so if you give the system some work to do it will be just fine.  Move the cursor around, type some paragraphs of random text, load some web page.
de_DE: Jetzt wird GPG einen Schlüssel für Sie generieren, was ein bisschen dauern kann. Es braucht zufällige Bytes, also ist eine gute Idee das System ein wenig auszulasten. Bewegen Sie den Mauszeiger hin und her, schreiben ein paar Zeilen und laden ein paar Webseiten.

en: Once this is done, you will get a message similar to this one::
de_DE: Wenn das getan ist, werden Sie in etwa solch eine Meldung erhalten::

en: In this case ``43CDE61D`` is the *key ID*.
de_DE: In diesem Fall ist ``43CDE61D`` die *key ID*.

en: Next, you need to upload the public part of your key to a keyserver so the world can identify messages and files as yours. To do so, enter::
de_DE: Als nächstes müssen Sie den öffentlichen Teil Ihres Schlüssels auf einen Keyserver hochladen, so dass man Nachrichten und Dateien Ihnen zuordnen kann. Um das zu tun, führen Sie folgenden Befehl aus::

en: This will send your key to the Ubuntu keyserver, but a network of keyservers will automatically sync the key between themselves. Once this syncing is complete, your signed public key will be ready to verify your contributions around the world.
de_DE: Dies wird Ihren Schlüssel auf den Ubuntu-Schlüsselserver laden, aber ein Netzwerk aus Schlüsselservern wird den Schlüssel untereinander weiterreichen. Ist der Vorgang erst einmal abgeschlossen, ist Ihr unterschriebener öffentlicher Schlüssel bereit alle Ihre Beiträge auf der ganzen Welt zu verifizieren.

en: Create your SSH key
de_DE: Ihren SSH-Schlüssel erstellen

en: SSH_ stands for *Secure Shell*, and it is a protocol that allows you to exchange data in a secure way over a network. It is common to use SSH to access and open a shell on another computer, and to use it to securely transfer files. For our purposes, we will mainly be using SSH to securely upload source packages to Launchpad.
de_DE: SSH_ steht für *Secure Shell* und ist ein Protokoll, welches es Ihnen erlaubt, Daten sicher über ein Netzwerk auszutauschen. Es ist üblich per SSH Zugang zur Kommandozeile eines andern Rechners zu erhalten und es zur sicheren Dateiübertragung zu verwenden. Für unsere Zwecke nutzen wir SSH hauptsächlich zum sicheren Hochladen von Paketen zu Launchpad.

en: To generate an SSH key, enter::
de_DE: Um Ihren SSH-Schlüssel zu erstellen, starten Sie::

en: The default file name usually makes sense, so you can just leave it as it is. For security purposes, it is highly recommended that you use a passphrase.
de_DE: Der Standardname ergibt normalerweise Sinn, deshalb kann er auch einfach so bleiben. Aus Sicherheitsgründen ist es ratsam eine Passphrase zu verwenden.

en: Set up pbuilder
de_DE: pbuilder einrichten

en: ``pbuilder`` allows you to build packages locally on your machine. It serves a couple of purposes:
de_DE: ``pbuilder`` ermöglicht es Ihnen, Pakete lokal auf Ihrem Rechner zu erstellen. Das dient mehreren Zwecken:

en: The build will be done in a minimal and clean environment. This helps you make sure your builds succeed in a reproducible way, but without modifying your local system
de_DE: Die Erstellung wird in einer minimalen und sauberen Umgebung vorgenommen. Das hilft sicherzustellen, dass der Vorgang in einer wiederholbaren Weise abläuft ohne Ihr System zu modifizieren.

en: There is no need to install all necessary *build dependencies* locally
de_DE: Sie brauchen nicht alle nötigen Build-Abhängigkeiten lokal installieren.

en: You can set up multiple instances for various Ubuntu and Debian releases
de_DE: Sie können mehrere Instanzen für diverse Ubuntu- und Debian-Versionen einrichten

en: Setting ``pbuilder`` up is very easy, run::
de_DE: ``pbuilder`` einzurichten ist sehr einfach, starten Sie::

en: where <release> is for example `xenial`, `zesty`, `artful` or in the case of Debian maybe `sid` or `buster`. This will take a while as it will download all the necessary packages for a "minimal installation". These will be cached though.
de_DE: wobei <release> beispielsweise `xenial`, `zesty`, `artful` sein kann bzw. im Falle von Debian `sid` oder `buster`. Es wird einige Zeit dauern da es alle nötigen Pakete für eine "minimale Installation" herunterlädt. Diese werden aber im Cache gespeichert werden.

en: Get set up to work with Launchpad
de_DE: Alles einrichten um mit Launchpad arbeiten zu können

en: With a basic local configuration in place, your next step will be to configure your system to work with Launchpad. This section will focus on the following topics:
de_DE: Mit einer grundlegenden lokalen Konfiguration vor Ort ist Ihr nächster Schritt Ihr System auf die Arbeit mit Launchpad einzurichten. Dieses Kapitel legt den Schwerpunkt auf folgende Themen:

en: What Launchpad is and creating a Launchpad account
de_DE: Was Launchpad ist und einen Launchpad Account erstellen

en: Uploading your GPG and SSH keys to Launchpad
de_DE: Ihren GPG- und SSH-Schlüssel auf Launchpad hochladen

en: Configure your shell to recognize you (for putting your name in changelogs)
de_DE: Konfigurieren Ihrer Shell, Sie zu erkennen (um Ihren Namen im Changelogs zu bringen)

en: About Launchpad
de_DE: Über Launchpad

en: Launchpad is the central piece of infrastructure we use in Ubuntu. It not only stores our packages and our code, but also things like translations, bug reports, and information about the people who work on Ubuntu and their team memberships.  You will also use Launchpad to publish your proposed fixes, and get other Ubuntu developers to review and sponsor them.
de_DE: Launchpad ist das Kernstück der Infrastruktur in Ubuntu. Es speichert nicht nur unsere Pakete und unseren Code, sondern auch Dinge wie Übersetzungen, Fehlerberichte, Informationen über Personen die an Ubuntu arbeiten sowie deren Mitgliedschaften in Entwicklerteams. Sie werden Launchpad ebenso dazu benutzen um Ihre Lösungen zu veröffentlichen und andere Ubuntu-Entwickler dazu zu bringen sie zu überprüfen und zu fördern.

en: You will need to register with Launchpad and provide a minimal amount of information. This will allow you to download and upload code, submit bug reports, and more.
de_DE: Sie werden sich mit Launchpad anmelden und ein Minumum an Informationen preisgeben müssen. Das gibt Ihnen die Möglichkeit Code runter- und hochzuladen, Fehlerberichte auszustellen und vieles mehr.

en: Besides hosting Ubuntu, Launchpad can host any Free Software project. For more information see the `Launchpad Help wiki <https://help.launchpad.net/>`_.
de_DE: Neben Ubuntu kann Launchpad jedes beliebige Projekt mit freier Software beherbergen. Für weitere Informationen sehen Sie im `Launchpad Hilfe Wiki <https://help.launchpad.net/>`_.

en: Get a Launchpad account
de_DE: Einen Launchpad Account erstellen

en: If you don't already have a Launchpad account, you can easily `create one <LP-AccountCreate_>`_. If you have a Launchpad account but cannot remember your Launchpad id, you can find this out by going to https://launchpad.net/~ and looking for the part after the `~` in the URL.
de_DE: Wenn Sie noch nicht bereits einen Launchpad Account besitzt, können Sie leicht `einen erstellen <LP-AccountCreate_>`_. Wenn Sie ein Launchpad-Konto besitzt aber Ihre Launchpad ID nicht wissen, können Sie durch Besuch auf https://launchpad.net/~ herauszufinden und nach dem Teil nach der `~` in der URL schauen.

en: Launchpad's registration process will ask you to choose a display name. It is encouraged for you to use your real name here so that your Ubuntu developer colleagues will be able to get to know you better.
de_DE: Der Registrierungsprozess von Launchpad wird nach einem Anzeigenamen verlangen. Es ist empfehlenswert hier seinen echten Namen zu verwenden, damit die anderen Ubuntu-Entwickler eine Möglichkeit haben Sie besser kennenzulernen.

en: When you register a new account, Launchpad will send you an email with a link you need to open in your browser in order to verify your email address. If you don't receive it, check in your spam folder.
de_DE: Sobald Sie einen neuen Account registrieren, wird Ihnen Launchpad eine E-Mail mit einem Weblink senden, der Ihre E-Mail-Adresse bestätigt. Falls Sie keine E-Mail erhälten, sollten Sie Ihren Spam-Ordner überprüfen.

en: `The new account help page <LP-AccountHelp_>`_ on Launchpad has more information about the process and additional settings you can change.
de_DE: `Die new account help page <LP-AccountHelp_>`_ auf Launchpad hat mehr Informationen über den Prozess und zusätzliche Einstellungen, die Sie ändern können.

en: Upload your GPG key to Launchpad
de_DE: Ihren GPG-Schlüssel auf Launchpad hochladen

en: First, you will need to get your fingerprint and key ID.
de_DE: Als erstes müssen Sie Ihren Fingerprint und key ID erhalten.

en: To find about your GPG fingerprint, run::
de_DE: Um Ihren GPG-Fingerabdruck zu finden, starten Sie::

en: and it will print out something like::
de_DE: und es wird Ihnen etwa sowas ausgegeben::

en: Then run this command to submit your key to Ubuntu keyserver::
de_DE: Starten Sie dann diesen Befehl um Ihren Schlüssel an den Ubuntu Keyserver zu schicken::

en: where ``43CDE61D`` should be replaced by your key ID (which is in the first line of output of the previous command). Now you can import your key to Launchpad.
de_DE: wobei ``43CDE61D`` durch Ihre Schlüssel-ID ersetzt werden sollte (welche die erste Zeile der Ausgabe des vorherigen Befehls ist). Nun können Sie Ihren Schlüssel auf Launchpad importieren.

en: Head to https://launchpad.net/~/+editpgpkeys and copy the "Key fingerprint" into the text box. In the case above this would be ``5C28 0144 FB08 91C0 2CF3  37AC 6F0B F90F 43CD E61D``. Now click on "Import Key".
de_DE: Gehen Sie auf https://launchpad.net/~/+editpgpkeys und kopieren den "Key fingerprint" in das Textfeld. Im oben genannten Beispiel wäre das ``5C28 0144 FB08 91C0 2CF3  37AC 6F0B F90F 43CD E61D``. Klicken Sie jetzt auf "Import Key".

en: Launchpad will use the fingerprint to check the Ubuntu key server for your key and, if successful, send you an encrypted email asking you to confirm the key import. Check your email account and read the email that Launchpad sent you. `If your email client supports OpenPGP encryption, it will prompt you for the password you chose for the key when GPG generated it. Enter the password, then click the link to confirm that the key is yours.`
de_DE: Launchpad benutzt den Fingerabdruck, um Ihren Schlüssel am Ubuntu-Schlüsselserver abzufragen. Bei Erfolg erhalten Sie eine verschlüsselte E-Mail mit der Bitte, den Schlüsselimport zu bestätigen. Durchsuchen Sie dazu Ihr E-Mail Postfach nach dieser E-Mail. `Unterstützt Ihr E-Mail Anbieter OpenPGP-Verschlüsselung, werden Sie nach dem Passwort gefragt, dass Sie bei der Erstellung des Schlüssels verwendet haben. Geben Sie dieses ein und klicken Sie auf den Link, um zu bestätigen, dass dies Ihr Schlüssel ist.`

en: Launchpad encrypts the email, using your public key, so that it can be sure that the key is yours. If you are using Thunderbird, the default Ubuntu email client, you can install the `Enigmail plugin <Enigmail_>`_ to easily decrypt the message. If your email software does not support OpenPGP encryption, copy the encrypted email's contents, type ``gpg`` in your terminal, then paste the email contents into your terminal window.
de_DE: Launchpad verschlüsselt die E-Mail mit Ihrem öffentlichen Schlüssel und so kann es davon sicher ausgehen, dass der Schlüssel Ihnen gehört. Wenn Sie Thunderbird, den Standard-E-Mail-Client verwenden, können Sie das `Enigmail Plugin <Enigmail_>`_  verwenden, um schnell die Nachricht zu entschlüsseln. Wenn Ihre E-Mail-Software nicht OpenPGP unterstützt kopieren Sie die Inhalte der verschlüsselten E-Mail, geben ``gpg`` in Ihrem Terminal ein und fügen die E-Mail-Inhalte in Ihr Terminalfenster ein.

en: Back on the Launchpad website, use the Confirm button and Launchpad will complete the import of your OpenPGP key.
de_DE: Zurück auf der Launchpad-Webseite, drücken Sie die Schaltfläche zur Bestätigung und Launchpad wird den Import Ihres OpenPGP-Schlüssels abschließen.

en: Find more information at https://help.launchpad.net/YourAccount/ImportingYourPGPKey
de_DE: Weitere Informationen finden Sie auf https://help.launchpad.net/YourAccount/ImportingYourPGPKey

en: Upload your SSH key to Launchpad
de_DE: Ihren SSH-Schlüssel auf Launchpad hochladen

en: Open https://launchpad.net/~/+editsshkeys in a web browser, also open ``~/.ssh/id_rsa.pub`` in a text editor. This is the public part of your SSH key, so it is safe to share it with Launchpad. Copy the contents of the file and paste them into the text box on the web page that says "Add an SSH key". Now click "Import Public Key".
de_DE: Öffnen Sie https://launchpad.net/~/+editsshkeys in einem Webbrowser, und öffnen auch ``~/.ssh/id_rsa.pub`` in einem Texteditor. Dies ist der öffentliche Teil Ihres SSH-Schlüssels, also ist es sicher ihn auf Launchpad zu veröffentlichen. Kopieren Sie den Inhalt der Datei und fügen sie in die Textbox ein die mit "Add an SSH key" überschrieben ist. Klicken Sie jetzt "Import Public Key".

en: For more information on this process, visit the `creating an SSH keypair <genssh_>`_ page on Launchpad.
de_DE: Für weitere Informationen über diesen Prozess besuchen Sie die Seite `creating an SSH keypair <genssh_>`_ auf Launchpad.

en: Configure your shell
de_DE: Ihre Shell einrichten

en: The Debian/Ubuntu packaging tools need to learn about you as well in order to properly credit you in the changelog. Simply open your `~/.bashrc` in a text editor and add something like this to the bottom of it::
de_DE: Die Debian/Ubuntu Paketierungswerkzeuge müssen auch mehr über Sie erfahren um Sie entsprechend im Changelog aufzulisten. Öffnen Sie einfach Ihre `~/.bashrc` in einem Texteditor und fügen etwas wie folgt am Ende davon ein::

en: Now save the file and either restart your terminal or run::
de_DE: Speichern Sie die Datei jetzt und starten entweder Ihr Terminal neu oder starten::

en: (If you do not use the default shell, which is `bash`, please edit the configuration file for that shell accordingly.)
de_DE: (Falls Sie nicht die Standardanwendung `bash` benutzt, passen Sie bitte die Konfigurationsdatei für diese Anwendung dementsprechend an.)

en: Ubuntu Packaging Guide
de_DE: Ubuntu Packaging Handbuch

en: Welcome to the Ubuntu Packaging and Development Guide!
de_DE: Willkommen beim Ubuntu Paketierungs- und Entwicklungshandbuch!

en: This is the official place for learning all about Ubuntu Development and packaging. After reading this guide you will have:
de_DE: Dies ist der offizielle Ort um alles über die Ubuntu Entwicklung und Paketierung zu lernen. Nach dem Lesen dieses Handbuch, werden Sie folgendes haben:

en: Heard about the most important players, processes and tools in Ubuntu development,
de_DE: Ein Verständnis der wichtigsten Mitspieler, Prozesse und Werkzeuge in der Ubuntu-Entwicklung,

en: Your development environment set up correctly,
de_DE: Ihre Entwicklungsumgebung richtig eingerichtet,

en: A better idea of how to join our community,
de_DE: Einen besseren Eindruck wie man sich unserer Gemeinschaft anschließt,

en: Fixed an actual Ubuntu bug as part of the tutorials.
de_DE: Einen echten Ubuntu Bug als Teil des Kurses behoben haben.

en: Ubuntu is not only a free and open source operating system, its platform is also open and developed in a transparent fashion. The source code for every single component can be obtained easily and every single change to the Ubuntu platform can be reviewed.
de_DE: Ubuntu ist nicht nur ein freies Open Source Betriebssystem, seine Plattform ist auch offen und wird in einer transparenten Art entwickelt. Der Quellcode für jede einzelnen Komponenten kann einfach besorgt werden und jede einzelne Änderung an der Ubuntu Plattform kann angeschaut werden.

en: This means you can actively get involved in improving it and the community of Ubuntu platform developers is always interested in helping peers getting started.
de_DE: Das heißt, Sie können selbst aktiv werden und die Dinge verbessern. Die Gemeinschaft der Ubuntu Plattform Entwickler ist immer an neuen Kollegen, die gerade anfangen, interessiert.

en: Ubuntu is also a community of great people who believe in free software and that it should be accessible for everyone. Its members are welcoming and want you to be involved as well. We want you to get involved, to ask questions, to make Ubuntu better together with us.
de_DE: Ubuntu ist außerdem eine Gemeinschaft von tollen Leuten, die an freie Software glauben und dass jeder Zugang dazu haben sollte. Die Mitglieder sind einladend und freuen sich, wenn Sie mit machen wollen. Wir freuen uns über Fragen und wenn Sie anfangen, Ubuntu zusammen mit uns besser zu machen.

en: If you run into problems: don't panic! Check out the :doc:`communication article<./communication>` and you will find out how to most easily get in touch with other developers.
de_DE: Sollten Sie Probleme haben: keine Panik! Schau Sie den :doc:`Artikel über Kommunikation<./communication>` an und Sie werden sehen, wie Sie am leichtesten in Kontakt mit anderen Entwicklern kommen.

en: The guide is split up into two sections:
de_DE: Die Anleitung teilt sich in zwei Bereiche auf:

en: A list of articles based on tasks, things you want to get done.
de_DE: Eine Liste von Artikel, die spezifische Aufgaben betreffen.

en: A set of knowledge-base articles that dig deeper into specific bits of our tools and workflows.
de_DE: Eine Sammlung von Knowledge-Base Artikel, die ins Detail gehen und Werkzeuge und Workflows erklären.

en: Articles
de_DE: Artikel

en: Knowledge Base
de_DE: Wissensdatenbank

en: Further Reading
de_DE: Weiterführende Literatur

en: You can read this guide offline in different formats, if you install one of the `binary packages <BinPkgs_>`_.
de_DE: Sie können dieses Handbuch offline in verschiedenen Formaten lesen, wenn man eins der `Binärpakete <BinPkgs_>`_ installiert.

en: If you want to learn more about building Debian packages, here are some Debian resources you may find useful:
de_DE: Wenn Sie mehr über das Bauen von Debian-Paketen lernen wollen, sind hier einige Debian-Resourcen, die Sie hilfreich finden könnten.

en: `How to package for Debian <HowToPackage_>`_;
de_DE: `Wie man für Debian paketiert <HowToPackage_>`_;

en: `Debian New Maintainers' Guide <NewMaintGuide_>`_ — available in many languages;
de_DE: `Debian New Maintainers' Guide <NewMaintGuide_>`_ — verfügbar in vielen Sprachen;

en: `Packaging tutorial <PkgTutorial_>`_ (also available as a `package <PkgTutorialPkg_>`_);
de_DE: `Paketierungskurs <PkgTutorial_>`_ (auch als `Paket <PkgTutorialPkg_>`_) verfügbar;

en: `Guide for Packaging Python Modules <PythonModules_>`_.
de_DE: `Handbuch zur Paketierung von Python Modulen <PythonModules_>`_.

en: We are always looking to improve this guide. If you find any problems or have some suggestions, please `report a bug on Launchpad <Bugs_>`_. If you'd like to help work on the guide, `grab the source <Source_>`_ there as well.
de_DE: Wir suchen ständig nach Wegen, dieses Handbuch zu verbessern. Wenn Sie auf Probleme stossen oder einige Vorschläge haben, bitte `melden Sie einen Bug auf Launchpad <Bugs_>`_. Wenn Sie gerne an dem Hanbuch arbeiten möchten `holen Sie die Quellen <Source_>`_ ebenfalls dort.

en: Introduction to Ubuntu Development
de_DE: Einführung in die Ubuntu-Entwicklung

en: Ubuntu is made up of thousands of different components, written in many different programming languages. Every component -  be it a software library, a tool or a graphical application - is available as a source package. Source packages in most cases consist of two parts: the actual source code and metadata. Metadata includes the dependencies of the package, copyright and licensing information, and instructions on how to build the package. Once this source package is compiled, the build process provides binary packages, which are the .deb files users can install.
de_DE: Ubuntu besteht aus tausenden verschiedenen Komponenten, geschrieben in vielen verschiedenen Programmiersprachen. Jede Komponente – sei es eine Softwarebibliothek, ein Werkzeug oder eine grafische Anwendung – ist als Quellpaket erhältlich. Quellpakete bestehen in den meisten Fällen aus zwei Teilen: dem eigentlichen Quellcode und den Metadaten. Metadaten enthalten die Abhängigkeiten des Pakets, Informationen zum Urheberrecht und zur Lizenz, und Einweisungen wie das Paket erstellt werden soll. Ist das Quellpaket einmal kompiliert, werden durch den Erstellungsprozess Binärpakete zur Verfügung gestellt, welche der Benutzer in Form von .deb Dateien installieren kann.

en: Every time a new version of an application is released, or when someone makes a change to the source code that goes into Ubuntu, the source package must be uploaded to Launchpad's build machines to be compiled. The resulting binary packages then are distributed to the archive and its mirrors in different countries. The URLs in ``/etc/apt/sources.list`` point to an archive or mirror. Every day images are built for a selection of different Ubuntu flavours. They can be used in various circumstances. There are images you can put on a USB key, you can burn them on DVDs, you can use netboot images and there are images suitable for your phone and tablet. Ubuntu Desktop, Ubuntu Server, Kubuntu and others specify a list of required packages that get on the image. These images are then used for installation tests and provide the feedback for further release planning.
de_DE: Jedes Mal wenn eine neue Version einer Anwendung veröffentlicht wird oder jemand eine Änderung am Sourcecode macht, der in Ubuntu geht muss das Quellpaket auf Launchpads Buildrechner hochgeladen und kompiliert werden. Das entstandene Binärpaket wird dann ins Archiv verteilt sowie an Spiegelserver in verschiedenen Ländern. Die URLs in ``/etc/apt/sources.list`` zeigen auf ein Archiv oder Spielgelserver. Jeden Tag werden Abbilder für unterschiedliche Ubuntu Richtungen gebaut. Diese können in verschiedenen Umständen verwendet werden. Dies sind Abbilder, die man auf eine USB-Stick schreiben, auf DVDs brennen kann oder man kann netboot Abilder verwenden. Ebenso gibt es Abbilder, die für Ihr Telefon und Tablet passen. Ubuntu Desktop, Ubuntu Server, Kubuntu und andere geben eine Liste von benötigten Paketen an, die auf das Abbild kommen. Diese Abbilder werden dann zu Installationstests verwendet oder Feedback für die weitere Release-Planung verwendet.

en: Ubuntu's development is very much dependent on the current stage of the release cycle. We release a new version of Ubuntu every six months, which is only possible because we have established strict freeze dates. With every freeze date that is reached developers are expected to make fewer, less intrusive changes. Feature Freeze is the first big freeze date after the first half of the cycle has passed. At this stage features must be largely implemented. The rest of the cycle is supposed to be focused on fixing bugs. After that the user interface, then the documentation, the kernel, etc. are frozen, then the beta release is put out which receives a lot of testing. From the beta release onwards, only critical bugs get fixed and a release candidate release is made and if it does not contain any serious problems, it becomes the final release.
de_DE: Die Entwicklung von Ubuntu ist sehr stark abhängig vom aktuelle Veröffentlichungszyklus. Alle 6 Monate wird eine neue Version von Ubuntu veröffentlicht. Dies ist aber nur möglich, weil es fest definierte Enddaten für den Eingang neuer Paketversionen gibt. Ab diesem Datum sind Entwickler dazu angehalten, nur noch kleinere Veränderungen vorzunehmen. Nach der Hälfte des Entwicklungszeitraumes ist das sogenannte »Feature Freeze« erreicht, bis zu dem alle neuen Funktionalitäten implementiert sein müssen. In der restlichen Zeit wird hauptsächlich an der Fehlerbehebung gearbeitet. Zu diesem Zeitpunkt werden die Benutzeroberfläche, die Dokumentation, der Kernel usw. gesperrt, die »Beta-Phase« ist erreicht, in der sehr viele Tests durchgeführt werden. Von nun an werden nur noch kritische Fehler behoben und eine Vorveröffentlichung wird erstellt. Sobald keine größeren Probleme mehr auftreten, wird daraus die letztendliche neue Versionsveröffentlichung.

en: Thousands of source packages, billions of lines of code, hundreds of contributors require a lot of communication and planning to maintain high standards of quality. At the beginning and in the middle of each release cycle we have the Ubuntu Developer Summit where developers and contributors come together to plan the features of the next releases. Every feature is discussed by its stakeholders and a specification is written that contains detailed information about its assumptions, implementation, the necessary changes in other places, how to test it and so on. This is all done in an open and transparent fashion, so you can participate remotely and listen to a videocast, chat with attendants and subscribe to changes of specifications, so you are always up to date.
de_DE: Tausende Quellpakete, Millionen von Codezeilen und hunderte beteiligte Personen benötigen eine gute Kommunikation und Planung, um einen hohen Qualitätsstandard zu halten. Am Anfang sowie in der Mitte eines Veröffentlichungszyklus findet eine Veranstaltung Namens »Ubuntu Developer Summit« statt, bei dem Entwickler und sonstige beteiligte Personen zusammentreffen und zukünftige Funktionalitäten der nächsten Version planen. Die zuständigen Projektgruppen diskutieren dort über diese Funktionalitäten und stellen eine Spezifikation auf, in der alle detaillierten Informationen, Erwartungen, Implementierungen, nötigen Veränderungen an anderen Stellen und Testbedingungen enthalten sind. Der komplette Prozess ist dabei transparent und für jeden einsehbar, sodass Sie auch teilnehmen können, ohne direkt anwesend zu sein. Dazu gibt es Videoübertragungen, Chats mit Teilnehmern oder auch das Abonnement der Änderungen an Spezifikationen. Sie sind also immer auf dem neusten Stand.

en: Not every single change can be discussed in a meeting though, particularly because Ubuntu relies on changes that are done in other projects. That is why contributors to Ubuntu constantly stay in touch. Most teams or projects use dedicated mailing lists to avoid too much unrelated noise. For more immediate coordination, developers and contributors use Internet Relay Chat (IRC). All discussions are open and public.
de_DE: Aber nicht jede einzelne Änderung kann bei einem solchen Treffen diskutiert werden, besonders, weil Ubuntu auch von Änderungen in vielen anderen Projekten abhängt. Deshalb stehen alle an Ubuntu beteiligten Menschen dauerhaft in Kontakt. Die meisten Projekte benutzen eigene externe Mailinglisten, um nicht den Überblick in der Hauptarbeit zu verlieren. Für eilige Änderungen benutzen Entwickler und alle Beitragenden außerdem noch den Internet Relay Chat (IRC). Jegliche Diskussionen sind offen und öffentlich einsehbar.

en: Another important tool regarding communication is bug reports. Whenever a defect is found in a package or piece of infrastructure, a bug report is filed in Launchpad. All information is collected in that report and its importance, status and assignee updated when necessary. This makes it an effective tool to stay on top of bugs in a package or project and organise the workload.
de_DE: Ein weiteres wichtiges Werkzeug, welches die Kommunikation betrifft ist, sind Fehlerberichte. Wann immer ein Defekt in einem Paket oder einem Teil der Infrastruktur gefunden wird, wird ein Fehlerbericht auf Launchpad eingereicht. Jede Information ist diesem Bericht vereinigt und seine Wichtigkeit, Status und Bearbeiter werden bei Bedarf angepasst. Das macht es zu einem effektiven Werkzeug den Fehlern in einem Paket oder Projekt Herr zu bleiben und den Arbeitsaufwand zu organisieren.

en: Most of the software available through Ubuntu is not written by Ubuntu developers themselves. Most of it is written by developers of other Open Source projects and then integrated into Ubuntu. These projects are called "Upstreams", because their source code flows into Ubuntu, where we "just" integrate it. The relationship to Upstreams is critically important to Ubuntu. It is not just code that Ubuntu gets from Upstreams, but it is also that Upstreams get users, bug reports and patches from Ubuntu (and other distributions).
de_DE: Die meiste in Ubuntu erhältliche Software ist nicht von den Ubuntu-Entwicklern selbst geschrieben, sondern von Entwicklern anderer Open-Source-Projekte und die dann in Ubuntu eingefügt wird. Diese Projekte werden "Upstreams" genannt, weil ihr Quellcode in Ubuntu einfließt, wo wir ihn "nur" integrieren. Die Beziehung zu den Upstreams ist von kritischer Wichtigkeit für Ubuntu. Es ist nicht nur der Code den wir von ihnen bekommen, sondern sie bekommen von uns auch Benutzer, Fehlerberichte und Fehlerbehebungen von Ubuntu (und anderen Distributionen).

en: The most important Upstream for Ubuntu is Debian. Debian is the distribution that Ubuntu is based on and many of the design decisions regarding the packaging infrastructure are made there. Traditionally, Debian has always had dedicated maintainers for every single package or dedicated maintenance teams. In Ubuntu there are teams that have an interest in a subset of packages too, and naturally every developer has a special area of expertise, but participation (and upload rights) generally is open to everyone who demonstrates ability and willingness.
de_DE: Der wichtigste Upstream für Ubuntu ist Debian. Debian ist die Distribution auf der Ubuntu aufbaut und viele der Entscheidungen über das Designs der Paket-Infrastruktur werden dort getroffen. Traditionell hatte Debian schon immer eigene Betreuer oder ganze Entwicklerteams für jedes einzelne Paket. In Ubuntu gibt es auch Teams die ein Interesse an einer Einheit von Paketen zeigen und natürlicherweise hat jeder Entwickler ein Spezialgebiet. Jedoch sind Teilnahme (und Rechte zum Hochladen) generell offen für jeden der Fähigkeiten und Willen zeigt.

en: Getting a change into Ubuntu as a new contributor is not as daunting as it seems and can be a very rewarding experience. It is not only about learning something new and exciting, but also about sharing the solution and solving a problem for millions of users out there.
de_DE: Selber zu Ubuntu beizutragen ist nicht so schwierig wie es scheint und kann durchaus eine lohnenswerte Erfahrung sein. Dabei geht es nicht nur darum, etwas neues und spannendes zu lernen, sondern auch um das Lösen von Problemen und so das Helfen von Millionen von Menschen.

en: Open Source Development happens in a distributed world with different goals and different areas of focus. For example there might be the case that a particular Upstream is interested in working on a new big feature while Ubuntu, because of the tight release schedule, is interested in shipping a solid version with just an additional bug fix. That is why we make use of "Distributed Development", where code is being worked on in various branches that are merged with each other after code reviews and sufficient discussion.
de_DE: Quelloffene Entwicklung geschieht in einer dezentralen Art mit unterschiedlichen Zielen. Beispielsweise kommt es vor, dass ein Entwickler gerne eine neue großartige Funktion implementieren möchte, während Ubuntu, gebunden an den Veröffentlichungszyklus, ein Hauptaugenmerk auf ein stabiles System mit guter Fehlerbehebung legt. Darum wird hier das Prinzip der "aufgeteilten Arbeit" angewendet, wo in vielen Zweigen gleichzeitig entwickelt wird, die am Ende alle zusammengeführt werden.

en: In the example mentioned above it would make sense to ship Ubuntu with the existing version of the project, add the bugfix, get it into Upstream for their next release and ship that (if suitable) in the next Ubuntu release. It would be the best possible compromise and a situation where everybody wins.
de_DE: In dem oben gezeigtem Beispiel würde es Sinn machen, Ubuntu mit der bestehenden Version des Projektes ausliefern, die Fehlerbehebung hinzufügen, diese für die nächste Veröffentlichung Upstream hinzuzufügen und es mit der (wenn geeignet) nächsten Ubuntu-Veröffentlichung auszuliefern. Dieses ist der bestmögliche Kompromiss und es würde jeder Gewinnen.

en: To fix a bug in Ubuntu, you would first get the source code for the package, then work on the fix, document it so it is easy to understand for other developers and users, then build the package to test it. After you have tested it, you can easily propose the change to be included in the current Ubuntu development release. A developer with upload rights will review it for you and then get it integrated into Ubuntu.
de_DE: Um einen Fehler in Ubuntu zu reparieren, müssen Sie sich zuerst den Quelltext des Paketes besorgen. Dann den Fehler beheben und so dokumentieren, dass es einfach für andere Entwickler und Benutzer zu verstehen ist und schließlich das Paket bauen um es zu testen. Nachdem Sie das Paket getestet haben, können Sie Ihre Änderung einfach zur Aufnahme in den aktuellen Ubuntu Entwicklungszweig vorschlagen. Ein Entwickler mit dem Recht zum hochladen wird Ihre Änderung für Sie bewerten und anschließend es für Sie in Ubuntu integrieren.

en: When trying to find a solution it is usually a good idea to check with Upstream and see if the problem (or a possible solution) is known already and, if not, do your best to make the solution a concerted effort.
de_DE: Wenn Sie eine Lösung suchen, ist es eine gute Idee zu prüfen, ob Upstream das Problem bekannt ist. Wenn es noch keine Lösung gibt, macht es Sinn, daran gemeinsam zu arbeiten.

en: Additional steps might involve getting the change backported to an older, still supported version of Ubuntu and forwarding it to Upstream.
de_DE: Zusätzliche Schritte könnten beinhalten, die Änderung auf einen älteren, immer noch unterstützten Release zurückzuportieren oder die Änderungen an Upstream weiterzuleiten.

en: The most important requirements for success in Ubuntu development are: having a knack for "making things work again," not being afraid to read documentation and ask questions, being a team player and enjoying some detective work.
de_DE: Die wichtigsten Anforderungen für den Erfolg in der Ubuntu-Entwicklung sind: Der Drang »Dinge wieder zum Laufen zu bringen«, keine Angst davor zu haben Dokumentationen zu lesen und Fragen zu stellen, Teamgeist zu zeigen und ein wenig Detektivarbeit genießen zu können.

en: Good places to ask your questions are ``ubuntu-motu@lists.ubuntu.com`` and ``#ubuntu-motu`` on ``freenode.``. You will easily find a lot of new friends and people with the same passion that you have: making the world a better place by making better Open Source software.
de_DE: Gute Orte um Ihre Fragen zu stellen sind ``ubuntu-motu@lists.``.ubuntu.com`` und ``#ubuntu-motu`` auf freenode. Sie werden leicht viele neue Freunde finden sowie Leute mit der gleichen Leidenschaft, wie Sie sie haben: Die Welt einen besseren Ort durch die Herstellung besserer Open Source Software machen.

en: KDE Packaging
de_DE: KDE Paketierung

en: Packaging of KDE programs in Ubuntu is managed by the Kubuntu and MOTU teams.  You can contact the Kubuntu team on the `Kubuntu mailing list <KubuntuML_>`_ and ``#kubuntu-devel`` Freenode IRC channel.  More information about Kubuntu development is on the `Kubuntu wiki page <Wiki_>`_.
de_DE: Paketierung von KDE Programmen in Ubuntu wird vom Kubuntu und MOTU-Teams verwaltet. Sie können das Kubuntu Team auf der `Kubuntu Mailingliste <KubuntuML_>`_ und ``#kubuntu-devel`` Freenode IRC Kanal kontaktieren.  Mehr Informationen über Kubuntu-Entwicklung ist auf der `Kubuntu Wikiseite <Wiki_>`_.

en: Our packaging follows the practices of the `Debian Qt/KDE Team <QtKDETeam_>`_ and Debian KDE Extras Team.  Most of our packages are derived from the packaging of these Debian teams.
de_DE: Unsere Paketierung folgt der Praxis des `Debian Qt/KDE Team <QtKDETeam_>`_ und dem Debian KDE Extras Team. Die meisten unserer Pakete werden aus der Paketierung dieser Debian-Teams abgeleitet.

en: Patching Policy
de_DE: Richtlinien für Fehlerkorrekturen

en: Kubuntu does not add patches to KDE programs unless they come from the upstream authors or submitted upstream with the expectation they will be merged soon or we have consulted the issue with the upstream authors.
de_DE: Kubuntu führt keine Fehlerkorrekturen an KDE-Programmen durch solange sie nicht von Upstream-Autoren oder dortigen Einreichungen stammen, mit der Absicht sie bald in das Programm einfließen zu lassen, oder das Problem mit den Upstream-Autoren abgesprochen wurde.

en: Kubuntu does not change the branding of packages except where upstream expects this (such as the top left logo of the Kickoff menu) or to simplify (such as removing splash screens).
de_DE: Kubuntu ändert keine Paketbezeichnungen mit Ausnahme dort, wo Upstream dies erwartet (wie das Logo des Kickoff-Menüs links oben) oder es der Vereinfachung dient (wie der Entfernung des Begrüßungsbildschirms).

en: Debian packages include some additions to the basic Debhelper usage. These are kept in the ``pkg-kde-tools`` package.
de_DE: Debian-Pakete verwenden Zusätze zur herkömmlichen Debhelper-Verwendung. Diese sind im Paket `pkg-kde-tools`` enthalten.

en: Packages which use Debhelper 7 should add the ``--with=kde`` option. This will ensure the correct build flags are used and add options such as handling kdeinit stubs and translations::
de_DE: Pakete, welche Debhelper 7 verwenden, sollten die Option ``--with=kde`` anhängen. Dies stellt sicher, dass die richtigen Flags zum Bauen benutzt werden und Optionen zum Umgang mit kdeinit-Stubs and Übersetzungen hinzugefügt werden::

en: Some newer KDE packages use the ``dhmk`` system, an alternative to ``dh`` made by the Debian Qt/KDE team.  You can read about it in /usr/share/pkg-kde-tools/qt-kde-team/2/README.  Packages using this will ``include /usr/share/pkg-kde-tools/qt-kde-team/2/debian-qt-kde.mk`` instead of running ``dh``.
de_DE: Einige neuere KDE-Packete verwenden das ``dhmk``-System, eine alternative zu ``dh``, welches von dem Debian Qt/KDE-Team entwickelt wurde. Sie können sich darüber in /usr/share/pkg-kde-tools/qt-kde-team/2/README informieren.  Pakete die dieses benutzen, werden ``/usr/share/pkg-kde-tools/qt-kde-team/2/debian-qt-kde.mk enthalten`` anstelle des Ausführens von ``dh``.

en: Translations
de_DE: Übersetzungen

en: Packages in main have their translations imported into Launchpad and exported from Launchpad into Ubuntu's language-packs.
de_DE: Übersetzungen von Paketen in main werden in Launchpad importiert und werden von Launchpad in Ubuntu's Language-Packs exportiert.

en: So any KDE package in main must generate translation templates, include or make available upstream translations and handle ``.desktop`` file translations.
de_DE: Daher muss jedes KDE-Paket Übersetzungsvorlagen generieren, Upstream-Übersetzungen verwenden oder bereitstellen und Übersetzungen für ``.desktop``-Dateien interpretieren können.

en: To generate translation templates the package must include a ``Messages.sh`` file; complain to the upstream if it does not.  You can check it works by running ``extract-messages.sh`` which should produce one or more ``.pot`` files in ``po/``.  This will be done automatically during build if you use the ``--with=kde`` option to ``dh``.
de_DE: Um Übersetzungsvorlagen zu generieren, muss das Paket eine ``Message.sh`` Datei einbinden. Wenn dem nicht so ist, beschweren Sie sich Upstream. Ob es funktioniert, können Sie überprüfen, in dem Sie ``extract-messages.sh`` ausführen, welches eine oder mehrere Dateien namens ``.pot`` in ``po/`` erstellen sollte. Dies wird während des Bauens automatisch getan, wenn Sie ``dh``mit der Option ``--width=kde`` benutzen.

en: Upstream will usually have also put the translation ``.po`` files into the ``po/`` directory.  If they do not, check if they are in separate upstream language packs such as the KDE SC language packs.  If they are in separate language packs Launchpad will need to associate these together manually, contact `David Planella <dpm_>`_ to do this.
de_DE: Upstream wird normalerweise auch die Übersetzungs ``.po`` Dateien in das ``po/`` Verzeichnis packen müssen. Falls sie das nicht tun, prüfen Sie ob diese in separaten Upsteam Sprachpaketen wie dem KDE SC Sprachpaket sind. Wenn diese in separaten Sprachpaketen sind, muss Launchpad diese manuell zusammenfügen. Kontaktieren Sie `David Planella <dpm_>`_ dies durchzuführen.

en: If a package is moved from universe to main it will need to be re-uploaded before the translations get imported into Launchpad.
de_DE: Wenn ein Paket von universe zu main verschoben wird, muss es erneut hochgeladen werden bevor die Übersetzung in Launchpad importiert wird.

en: ``.desktop`` files also need translations.  We patch KDELibs to read translations out of ``.po`` files which are pointed to by a line ``X-Ubuntu-Gettext-Domain=`` added to ``.desktop`` files at package build time.  A .pot file for each package is be generated at build time and .po files need to be downloaded from upstream and included in the package or in our language packs.  The list of .po files to be downloaded from KDE's repositories is in ``/usr/lib/kubuntu-desktop-i18n/desktop-template-list``.
de_DE: ``.desktop``Dateien benötigen ebenfalls Übersetzungen. Wir patchen KDELibs, dass die Übersetzungen aus ``.po`` Dateien geholt werden, auf die durch eine Zeile ``X-Ubuntu-Gettext-Domain=`` gezeigt wird und den ``.desktop``Dateien zur Buildzeit hinzugefügt werden. Eine .pot-Datei für jedes Paket wird während des Builds erzeugt und die .po-Dateien müssen von Upstream heruntergeladen und in das Paket bzw. unsere Sprachpakete gebracht werden. Die Liste von .po-Dateien, die aus KDEs Repositories heruntergeladen werden soll, ist in ``/usr/lib/kubuntu-desktop-i18n/desktop-template-list``.

en: Library Symbols
de_DE: Bibliothekssymbole

en: Library symbols are tracked in ``.symbols`` files to ensure none go missing for new releases.  KDE uses C++ libraries which act a little differently compared to C libraries.  Debian's Qt/KDE Team have scripts to handle this. See `Working with symbols files <SymbolsFiles_>`_ for how to create and keep these files up to date.
de_DE: Bibliothekssymbole werden in  ``.symbols`` Dateien verfolgt um sicherzustellen, dass keine für neue Veröffentlichungen verloren gehen. KDE verwendet C++ Bibliotheken die etwas anders funktionieren als C-Bibliotheken. Debian's Qt/KDE Team hat Skripte, die dies bewältigen. Schauen Sie sich `Working with symbols files <SymbolsFiles_>`_ wie man diese Dateien erstellt und aktuell hält.

en: Shared Libraries
de_DE: Gemeinsame Bibliotheken

en: Shared libraries are compiled code which is intended to be shared among several different programs.  They are distributed as ``.so`` files in ``/usr/lib/``.
de_DE: Gemeinsame Bibliotheken sind kompilierter Code, der von vielen verschiedenen Programmen gemeinsam genutzt wird. Sie werden als ``.so``-Dateien unter ``/usr/lib/`` zur Verfügung gestellt.

en: A library exports symbols which are the compiled versions of functions, classes and variables.  A library has a name called an SONAME which includes a version number.  This SONAME version does not necessarily match the public release version number.  A program gets compiled against a given SONAME version of the library.  If any of the symbols is removed or changes then the version number needs to be changed which forces any packages using that library to be recompiled against the new version.  Version numbers are usually set by upstream and we follow them in our binary package names called an ABI number, but sometimes upstreams do not use sensible version numbers and packagers have to keep separate version numbers.
de_DE: Eine Bibliothek exportiert Symbole, welche die kompilierten Versionen von Funktion, Klassen und Variablen sind. Eine Bibliothek wird als SONAME bezeichnet und beinhaltet eine Versionsnummer. Dieser SONAME entspricht nicht zwingend der öffentlichen Versionsbezeichnung. Ein Programm wird gegen eine gegebene SONAME-Version der Bibliothek kompiliert. Wenn eines der Symbole entfernt oder geändert wird, muss die Versionsnummer angepasst werden, was dazu führt, dass jedes Paket welches die Bibliothek benutzt, wieder gegen die neue Version kompiliert werden muss. Versionsnummern werden normalerweise vom Upstream festgelegt und wir folgen ihnen mit unseren Binärpaketnamen, auch ABI-Nummer genannt. Aber manchmal benutzt der Upstream keine vernünftigen Versionsnummern und die Paketierer müssen einer getrennten Nummerierung folgen.

en: Libraries are usually distributed by upstream as standalone releases. Sometimes they are distributed as part of a program.  In this case they can be included in the binary package along with the program (this is called bundling) if you do not expect any other programs to use the library, more often they should be split out into separate binary packages.
de_DE: Bibliotheken werden normalerweise von Upstream als Einzelreleases verteilt. Manchmal werden sie auch als Teil einen Programms herausgegeben. In diesem Fall können sie einfach mit in das Programm-Paket integriert werden (wenn zu erwarten ist, dass kein anderes Programm diese Bibliothek benutzt). Meistens sollten sie jedoch getrennt werden und in gesonderte Pakete gepackt werden.

en: The libraries themselves are put into a binary package named ``libfoo1`` where ``foo`` is the name of the library and ``1`` is the version from the SONAME. Development files from the package, such as header files, needed to compile programs against the library are put into a package called ``libfoo-dev``.
de_DE: Die Bibliotheken selbst werden in einem Binärpaket mit dem Namen ``libfoo1`` abgelegt, wobei ``foo`` der Name der Bibliothek und ``1`` die SONAME-Version ist. Entwicklungsdateien aus dem Paket, beispielsweise Kopfdateien, die benötigt werden, um Programme gegen die Bibliothek zu übersetzen, werden in einem Paket mit dem Namen ``libfoo-dev`` abgelegt.

en: An Example
de_DE: Ein Beispiel

en: We will use libnova as an example::
de_DE: Wir werden libnova als Beispiel verwenden::

en: To find the SONAME of the library run::
de_DE: Um den SONAME der Bibliothek herauszufinden, starten Sie::

en: The SONAME is ``libnova-0.12.so.2``, which matches the file name (usually the case but not always). Here upstream has put the upstream version number as part of the SONAME and given it an ABI version of ``2``.  Library package names should follow the SONAME of the library they contain. The library binary package is called ``libnova-0.12-2`` where ``libnova-0.12`` is the name of the library and ``2`` is our ABI number.
de_DE: Der SONAME ist ``libnova-0.12.so.2``, die dem Dateinamen entspricht (üblicherweise der Fall aber nicht immer). Hier hat Upstream die Versionsnummer als Teil des SONAME eingesetzt und ihm eine ABI-Version von ``2`` gegeben.  Bibliothekspaketnamen sollten dem SONAME der Bibliothek folgenden, die sie beinhalten. Das Binärbibliothekspaket heißt ``libnova-0.12-2`` wobei ``libnova-0.12`` der Name der Bibliothek und ``2`` unsere ABI-Nummer ist.

en: If upstream makes incompatible changes to their library they will have to reversion their SONAME and we will have to rename our library.  Any other packages using our library package will need to recompiled against the new version, this is called a transition and can take some effort. Hopefully our ABI number will continue to match upstream's SONAME but sometimes they introduce incompatibilities without changing their version number and we will need to change ours.
de_DE: Wenn im Upstream inkompatible Änderungen an den Bibliotheken durchgeführt werden, müssen sie eine neue Revision des SONAME erstellen und wir werden unsere Bibliothek umbenennen müssen. Jedes andere Paket welches unsere Bibliothek verwendet, muss dann wieder gegen die neue Version kompiliert werden; das nennt man Transition und kann einigen Aufwand verursachen. Im besten Fall bleibt unsere ABI-Nummer passend zu SONAME des Upstreams, aber manchmal führen sie Inkompatibilitäten ein ohne ihre Versionsnummer zu ändern und so müssen wir unsere anpassen.

en: Looking in debian/libnova-0.12-2.install we see it includes two files::
de_DE: Wenn wir uns debian/libnova-0.12-2.install ansehen, stellen wir fest, dass dort zwei Dateien eingebunden werden::

en: The last one is the actual library, complete with minor and point version number.  The first one is a symlink which points to the actual library.  The symlink is what programs using the library will look for, the running programs do not care about the minor version number.
de_DE: Das letzte ist die eigentliche Bibliothek, komplett mit Unter- und Punkversionsnummer. Das erste ist ein Symlink welcher auf die eigentliche Bibliothek verweist. Der Symlink ist das, nach dem die Programme welche Bibliothek benutzen suchen, sie kümmern sich nicht um die Unterversionsnummern.

en: ``libnova-dev.install`` includes all the files needed to compile a program with this library.  Header files, a config binary, the ``.la`` libtool file and ``libnova.so`` which is another symlink pointing at the library, programs compiling against the library do not care about the major version number (although the binary they compile into will).
de_DE: ``libnova-dev.install`` beinhaltet alle benötigten Dateien um das Programm mit dieser Bibliothek zu kompilieren. Kopfdateien, eine Konfigurationsbinärdatei, die libtool Datei ``.la`` und ``libnova.so``, welche als weiterer Symlink zu der Bibliothek führt; Programme die gegen die Bibliothek kompiliert werden kümmern sich nicht um die Hauptversionsnummer (jedoch wird das die Binärdatei in die sie kompilieren berücksichtigen).

en: ``.la`` libtool files are needed on some non-Linux systems with poor library support but usually cause more problems than they solve on Debian systems.  It is a current `Debian goal to remove .la files <LAFileRemoval_>`_ and we should help with this.
de_DE: ``.la`` libtool Datein werden auf manchen nicht-Linuxsystemen benötigt, die mangelnde Bibliotheksunterstützung haben aber verursachen normalerweise mehr Probleme auf Debiansystemen als sie lösen. Es ist ein aktuelles `Debian Ziel, .la-Dateien zu entfernen <LAFileRemoval_>`_ und wir sollten dabei helfen.

en: Static Libraries
de_DE: Statische Bibliotheken

en: The -dev package also ships ``usr/lib/libnova.a``.  This is a static library, an alternative to the shared library.  Any program compiled against the static library will include the code directory into itself.  This gets round worrying about binary compatibility of the library.  However it also means that any bugs, including security issues, will not be updated along with the library until the program is recompiled.  For this reason programs using static libraries are discouraged.
de_DE: Das -dev Paket stellt außerdem ``usr/lib/libnova.a`` bereit.  Dies ist eine statische Bibliothek, eine Alternative zu gemeinsamen Bibliotheken. Jedes gegen diese statische Bibliothek kompilierte Programm beinhaltet diesen Quelltext. Damit entfällt das Problem, die Bibliothek könnte als Binärdatei inkompatibel sein. Allerdings bedeutet dies auch, dass alle Fehler, die Sicherheitsprobleme inbegriffen, nicht behoben werden, solange das Programm nicht erneut kompiliert wird. Aus diesem Grund sind Programme, die statische Bibliotheken verwenden, zu vermeiden.

en: Symbol Files
de_DE: Symbol-Dateien

en: When a package builds against a library the ``shlibs`` mechanism will add a package dependency on that library.  This is why most programs will have ``Depends: ${shlibs:Depends}`` in ``debian/control``.  That gets replaced with the library dependencies at build time.  However shlibs can only make it depend on the major ABI version number, ``2`` in our libnova example, so if new symbols get added in libnova 2.1 a program using these symbols could still be installed against libnova ABI 2.0 which would then crash.
de_DE: Wenn ein Paket gegen eine Bibliothek baut wird der ``shlibs`` Mechanismus eine Paketabhängigkeit auf diese Bibliothek hinzuzufügen. Aus diesem Grund haben die meisten Programme ``Depends: ${shlibs:Depends}`` in ``debian/control``.  Dies wird mit den Bibliotheksabhängigkeiten zur Bauzeit ersetzt werden.  Trotzdem kann shlibs es nur auf die Major ABI Versionsnummer abhängen lassen, ``2`` in  unsersem libnova Beispiel. Falls also neue Symbole in libnova 2.1 hinzugefügt werden kann ein Programm welches diese Symbole benutzt trotzdem gegen libnova ABI 2.0 installiert werden was dann einen Absturz zur Folge hat.

en: To make the library dependencies more precise we keep ``.symbols`` files that list all the symbols in a library and the version they appeared in.
de_DE: Um die Bibliotheksabhängigkeiten präzise zu halten, verwenden wir ``.symbols``-Dateien, die alle Symbole in einer Bibliothek auflisten und in welcher Version sie zuerst auftauchten.

en: libnova has no symbols file so we can create one.  Start by compiling the package::
de_DE: libnova hat keine Symboldatei, also können wir eine erstellen. Beginnen Sie damit das Paket zu kompilieren::

en: The ``-nc`` will cause it to finish at the end of compilation without removing the built files.  Change to the build and run ``dpkg-gensymbols`` for the library package::
de_DE: Die Option ``-nc`` sorgt dafür, dass nach dem Kompilieren die Dateien des Programms, die währenddessen erzeugten wurden, nicht entfernt werden. Wechseln Sie in das Verzeichnis des Kompilierungsprozesses und führen Sie ``dpkg-gensymbols`` für das Bibliothekspaket aus::

en: This makes a diff file which you can self apply::
de_DE: Dies erstellt eine Diff-Datei welche Sie selbst anwenden können::

en: Which will create a file named similar to ``dpkg-gensymbolsnY_WWI`` that lists all the symbols.  It also lists the current package version.  We can remove the packaging version from that listed in the symbols file because new symbols are not generally added by new packaging versions, but by the upstream developers::
de_DE: Dies wird eine Datei erstellen die ähnlich ``dpkg-gensymbolsnY_WWI`` benannt wird, welche alle Symbole auflistet. Es listet auch die aktuelle Paketversion auf. Wir können die Paketierungsversion von derjenigen, die in der symbols Datei aufgelistet ist, entfernen da neue Symbole nicht allgemein durch neue Paketierungsversionen hinzugefügt werden sondern von den Upstream Entwicklern::

en: Now move the file into its location, commit and do a test build::
de_DE: Nun verschieben Sie die Datei an ihren Ort, comitten und machen einen Testlauf::

en: If it successfully compiles the symbols file is correct.  With the next upstream version of libnova you would run dpkg-gensymbols again and it will give a diff to update the symbols file.
de_DE: Wenn es erfolgreich kompiliert, ist die Symboldatei in Ordnung. Mit der nächsten Upstream-Version von libnova würden Sie erneut dpkg-gensymbols ausführen und es liefert eine Auflistung der Unterschiede um die Symboldatei zu aktualisieren.

en: C++ Library Symbols Files
de_DE: C++-Bibliothek-Symboldateien

en: C++ has even more exacting standards of binary compatibility than C.  The Debian Qt/KDE Team maintain some scripts to handle this, see their `Working with symbols files <SymbolsFiles_>`_ page for how to use them.
de_DE: C++ hat sogar noch genauere Binärkompatibilitäts-Standards als C. Das Debian Debian Qt/KDE Team wartet einige Skripte um dies zu verwalten. Schauen Sie ihre `Working with symbols files <SymbolsFiles_>`_ Seite an wie man diese verwendet.

en: Junichi Uekawa's `Debian Library Packaging Guide <LibraryGuide_>`_ goes into this topic in more detail.
de_DE: Junichi Uekawa's `Debian Library Packaging Guide <LibraryGuide_>`_ geht bei diesem Thema stärker ins Detail.

en: Packaging New Software
de_DE: Neue Software paketieren

en: While there are thousands of packages in the Ubuntu archive, there are still a lot nobody has gotten to yet. If there is an exciting new piece of software that you feel needs wider exposure, maybe you want to try your hand at creating a package for Ubuntu or a PPA_. This guide will take you through the steps of packaging new software.
de_DE: Auch wenn bereits tausende Pakete in den Ubuntu-Archiven vorhanden sind, gibt es noch immer sehr viele Programme, die nicht dort zu finden sind. Wenn es ein neues interessantes Programm gibt, das eine größere Verbreitung haben sollte, möchten Sie vielleicht versuchen ein Paket für Ubuntu zu erzeugen oder ein PPA einzurichten_. Dieser Leitfaden hilft Ihnen Schritt für Schritt dabei die neuen Softwarepakete zu erstellen.

en: You will want to read the :doc:`Getting Set Up<./getting-set-up>` article first in order to prepare your development environment.
de_DE: Sie sollten als erstes den :doc:`Vorbereitung<./getting-set-up>`s-Artikel lesen, um Ihre Entwicklungsumgebung vorzubereiten.

en: Checking the Program
de_DE: Das Programm überprüfen

en: The first stage in packaging is to get the released tar from upstream (we call the authors of applications "upstream") and check that it compiles and runs.
de_DE: Der erste Schritt in der Paketerstellung ist das Besorgen des veröffentlichen Quelltextes von Upstream (die Autoren von Software werden als "Upstream" bezeichnet) und das Überprüfen auf Kompilier- und Ausführbarkeit.

en: This guide will take you through packaging a simple application called GNU Hello which has been posted on GNU.org_.
de_DE: Dieser Leitfaden führt Sie anhand einer einfachen Anwendung namens GNU Hello, die von GNU.org_ veröffentlicht wurde, duch den Prozess des Paketbaus.

en: Download GNU Hello::
de_DE: Lade GNU Hello herunter::

en: Now uncompress it::
de_DE: Entpacke es::

en: This application uses the autoconf build system so we want to run ``./configure`` to prepare for compilation.
de_DE: Diese Anwendung nutzt das autoconf-Build-System, also wollen wir ``./configure`` ausführen, um uns für das Kompilieren vorzubereiten.

en: This will check for the required build dependencies. As ``hello`` is a simple example, ``build-essential`` should provide everything we need. For more complex programs, the command will fail if you do not have the needed libraries and development files. Install the needed packages and repeat until the command runs successfully.::
de_DE: Dies wird die benötigten Erstellungsabhängigkeiten überprüfen. Um ``hello`` als einfaches Beispiel zu nehmen, ``build-essential`` sollte alles bereitstellen was wir brauchen. An komplexeren Programmen wird dieser Befehl scheitern, wenn Sie nicht die benötigten Bibliotheken und Entwicklungsdateien besitzen. Installieren Sie die benötigten Pakete und Entwicklungsdateien bis der Befehl erfolgreich ausgeführt wird.::

en: Now you can compile the source::
de_DE: Jetzt können Sie den Quelltext kompilieren::

en: If compilation completes successfully you can install and run the program::
de_DE: Wenn das Kompilieren erfolgreich war, können Sie folgende Anwendung installieren und starten::

en: Starting a Package
de_DE: Ein Paket starten

en: When it asks what type of package type ``s`` for single binary. This will import the code into a branch and add the ``debian/`` packaging directory.  Have a look at the contents.  Most of the files it adds are only needed for specialist packages (such as Emacs modules) so you can start by removing the optional example files::
de_DE: Wenn Sie nach dem Pakettyp gefragt werden, wählen Sie mit der Eingabe von ``s`` den Typ einzelne Binärdatei. Der Quelltext wird in einen Zweig importiert und das ``debian/`` Paketverzeichnis wird hinzugefügt. Sehen Sie sich einmal den Inhalt an. Die meisten Dateien werden nur für spezielle Pakete (beispielsweise Emacs Module) benötigt, sodass Sie mit dem Entfernen der nicht benötigten Dateien anfangen können::

en: You should now customise each of the files.
de_DE: Sie sollten nun jede der Dateien anpassen.

en: In ``debian/changelog`` change the version number to an Ubuntu version: ``2.10-0ubuntu1`` (upstream version 2.10, Debian version 0, Ubuntu version 1).  Also change ``unstable`` to the current development Ubuntu release such as ``trusty``.
de_DE: Ändern Sie in ``debian/changelog`` die Versionsnummer auf eine Ubuntu-Version: ``2.10-0ubuntu1`` (Upstream-Version 2.10, Debian-Version 0, Ubuntu-Version 1). Ändern Sie außerdem ``unstable`` in die aktuelle Entwicklungsversion von Ubuntu wie ``trusty``.

en: Much of the package building work is done by a series of scripts called ``debhelper``.  The exact behaviour of ``debhelper`` changes with new major versions, the compat file instructs ``debhelper`` which version to act as.  You will generally want to set this to the most recent version which is ``9``.
de_DE: Vieles Paketbauarbeit wird von einer Reihe von Skripten übernommen, die ``debhelper`` heißen. Das exakte Verhalten von ``debhelper`` ändert sich mit neuen Majorversionen. Die compat Datei weist  ``debhelper`` an unter welcher Version dies geschehen soll. Im allgemeinen empfiehlt es sich, dies auf die neueste Version zu stellen welche ``9`` ist.

en: ``control`` contains all the metadata of the package.  The first paragraph describes the source package. The second and following paragraphs describe the binary packages to be built.  We will need to add the packages needed to compile the application to ``Build-Depends:``. For ``hello``, make sure that it includes at least::
de_DE: Unter ``control`` sind alle Metadaten eines Paketes enthalten. Der erste Abschnitt beschreibt das Quellpaket. Der zweite Abschnitt beschreibt die Binärpakete, die erstellt werden. Unter ``Build-Depends:`` müssen alle Pakete eingetragen werden, von denen die Kompilierung abhängt. Für ``hello`` werden mindestens die folgenden benötigt::

en: You will also need to fill in a description of the program in the ``Description:`` field.
de_DE: Sie müssen außerdem eine Beschreibung der Anwendung das Feld ``Description:`` eintragen.

en: ``copyright`` needs to be filled in to follow the licence of the upstream source.  According to the hello/COPYING file this is GNU GPL 3 or later.
de_DE: ``copyright`` muss ausgefüllt werden um der Lizenz des Upstreams gerecht zu werden. Der Datei hello/COPYING nach ist das die GNU GPL 3 oder neuer.

en: ``docs`` contains any upstream documentation files you think should be included in the final package.
de_DE: ``docs`` enthält alle Dokumentationsdateien des Upstreams, die Ihrer Meinung nach in dem entgültigen Paket enthalten sein sollten.

en: ``README.source`` and ``README.Debian`` are only needed if your package has any non-standard features, we don't so you can delete them.
de_DE: ``README.source`` und ``README.Debian`` werden nur benötigt, wenn Ihr Paket nicht nur Standardfunktionen hat. Das trifft hier nicht zu, also können sie gelöscht werden.

en: ``source/format`` can be left as is, this describes the version format of the source package and should be ``3.0 (quilt)``.
de_DE: ``source/format`` kann beibehalten werden, es beschreibt das Versionsformat des Quellpakets und sollte ``3.0 (quilt)`` sein.

en: ``rules`` is the most complex file.  This is a Makefile which compiles the code and turns it into a binary package.  Fortunately most of the work is automatically done these days by ``debhelper 7`` so the universal ``%`` Makefile target just runs the ``dh`` script which will run everything needed.
de_DE: Die umfangreichste Datei ist ``rules``.  Hierbei handelt es sich um eine Make-Datei, die den Quelltext kompiliert und in ein Binärpaket verwandelt.  Erfreulicherweise wird dabei heutzutage die meiste Arbeit von ``debhelper 7`` erledigt, sodass das universale ``%`` Make-Dateiziel nur das ``dh`` Script ausführt, das alles benötigte durchführt.

en: All of these file are explained in more detail in the :doc:`overview of the debian directory<./debian-dir-overview>` article.
de_DE: Alle Dateien sind in größerer Ausführlichkeit in der :doc:`Übersicht im Artikel über das Debian Verzeichnis<./debian-dir-overview>` beschrieben.

en: Finally commit the code to your packaging branch::
de_DE: Schlussendlich committen Sie den Code zu Ihrem Paketier-Zweig::

en: Building the package
de_DE: Das Paket bauen

en: Now we need to check that our packaging successfully compiles the package and builds the .deb binary package::
de_DE: Jetzt wird überprüft, ob das Programm kompiliert und das -deb Binärpaket erfolgreich gebaut werden kann::

en: ``bzr builddeb`` is a command to build the package in its current location. The ``-us -uc`` tell it there is no need to GPG sign the package.  The result will be placed in ``..``.
de_DE: Mit dem Befehl ``bzr builddeb`` wird das Paket im aktuellen Verzeichnis gebaut. Die Option ``-us -uc`` ist die Anweisung, dass das Paket nicht GPG signiert werden muss.  Das Ergebnis wird in ``..`` ausgegeben.

en: You can view the contents of the package with::
de_DE: Sie können sich den Inhalt eines Paketes mit folgendem Befehl ansehen::

en: Install the package and check it works (later you will be able to uninstall it using ``sudo apt-get remove hello`` if you want)::
de_DE: Installieren Sie das Paket und prüfen ob es funktioniert (später werden Sie in der Lage sein, es mit ``sudo apt-get remove hello`` zu deinstallieren sofern gewünscht)::

en: You can also install all packages at once using::
de_DE: Sie können auch alle Pakete sofort wie folgt installieren::

en: Next Steps
de_DE: Nächste Schritte

en: Even if it builds the .deb binary package, your packaging may have bugs.  Many errors can be automatically detected by our tool ``lintian`` which can be run on the source .dsc metadata file, .deb binary packages or .changes file::
de_DE: Selbst wenn es das .deb Binärpaket baut kann Ihre Paketierung Bugs haben. Viele Fehler können automatisch durch unser Werkzeug ``lintian`` entdeckt werden. Dies kann gegen die Quell- .dsc Metadaten Datei, .deb Binärpakete oder .changes Datei gestartet werden::

en: To see verbose description of the problems use ``--info`` lintian flag or ``lintian-info`` command.
de_DE: Um ausführlichere Beschreibungen der Probleme zu sehen verwenden Sie das ``--info`` lintian Flag oder den Befehl ``lintian-info``.

en: For Python packages, there is also a ``lintian4python`` tool that provides some additional lintian checks.
de_DE: Für Python Pakete gibt es auch ein  ``lintian4python`` Werkzeug, welches einige zusätzliche lintian Überprüfungen bietet.

en: After making a fix to the packaging you can rebuild using ``-nc`` "no clean" without having to build from scratch::
de_DE: Nachdem der Fehler im Bauprozess behoben wurde, können Sie mit der Option ``-nc`` "no clean" das Paket erneut bauen, ohne mit der Kompilierung des Quelltextes starten zu müssen::

en: Having checked that the package builds locally you should ensure it builds on a clean system using ``pbuilder``. Since we are going to upload to a PPA (Personal Package Archive) shortly, this upload will need to be *signed* to allow Launchpad to verify that the upload comes from you (you can tell the upload will be signed because the ``-us`` and ``-uc`` flags are not passed to ``bzr builddeb`` like they were before). For signing to work you need to have set up GPG. If you haven't set up ``pbuilder-dist`` or GPG yet, :doc:`do so now<./getting-set-up>`::
de_DE: Nachdem sichergestellt ist, dass das Paket auf dem eigenen Rechner erfolgreich gebaut werden kann, sollten Sie überprüfen, ob dies auch auf einem frisch installierten System funktioniert. Zu diesem Zweck kann ``pbuilder`` eingesetzt werden. Da das gebaute Paket in ein PPA (Personal Package Archive) hochgeladen werden soll, ist es erforderlich, das Paket zu *signieren*. So kann Launchpad überprüfen, dass dieses Paket wirklich von Ihnen stammt (die hochzuladende Datei muss signiert werden, da die ``-us`` und ``-uc`` Markierungen nicht wie zuvor an ``bzr builddeb`` übergeben wurden). Für das Signieren benötigen Sie eine funktionierende Version von GPG. Sollten Sie ``pbuilder-dist`` oder GPG noch nicht installiert haben, :doc:`so machen Sie dies jetzt<./getting-set-up>`::

en: When you are happy with your package you will want others to review it.  You can upload the branch to Launchpad for review::
de_DE: Wenn Sie mit Ihrem Paket zufrieden sind, wird es vermutlich Ihre Absicht sein, dass andere Benutzer Ihr Paket überprüfen. Dazu können Sie den Zweig in Launchpad hochladen::

en: Uploading it to a PPA will ensure it builds and give an easy way for you and others to test the binary packages.  You will need to set up a PPA in Launchpad and then upload with ``dput``::
de_DE: Das Hochladen in ein PPA hat mehrere Vorteile: Sie können einfach den Paketbauvorgang auf Fehlerfreiheit überprüfen und andere können die Binärpakete testen. Hierfür benötigen Sie ein PPA in Launchpad, in das Sie ihre Dateien mittels ``dput`` hochladen::

en: You can ask for reviews in ``#ubuntu-motu`` IRC channel, or on the `MOTU mailing list <ubuntu-motu_>`_.  There might also be a more specific team you could ask such as the GNU team for more specific questions.
de_DE: Sie können nach Feedback im ``#ubuntu-motu`` IRC Kanal, oder auf der`MOTU Mailingliste <ubuntu-motu_>`_. fragen. Dort kann auch ein spezielles Team wie das GNU Team für detailliertere Fragen gefragt werden.

en: Submitting for inclusion
de_DE: Zur Einbindung einsenden

en: There are a number of paths that a package can take to enter Ubuntu. In most cases, going through Debian first can be the best path. This way ensures that your package will reach the largest number of users as it will be available in not just Debian and Ubuntu but all of their derivatives as well. Here are some useful links for submitting new packages to Debian:
de_DE: Es gibt eine Vielzahl von Wegen, auf denen ein Paket in Ubuntu einziehen kann. In den meisten Fällen ist der Weg über Debian der beste Weg. Auf diesem Weg wird versichert, dass das Paket die größte Anzahl an Nutzern hat da es nicht nur in Debian und Ubuntu vorhanden sein wird, sondern auch in ihren Derivaten. Hier sind einige nützliche Links für das Hinzufügen neuer Pakete im Debianprojekt:

en: `Debian Mentors FAQ <MentorsFAQ_>`_ - debian-mentors is for the mentoring of new and prospective Debian Developers. It is where you can find a sponsor to upload your package to the archive.
de_DE: `Debian Mentors FAQ <MentorsFAQ_>`_ – debian-mentors dient dem Mentoring von neuen und zukünftigen Debianentwicklern. Hier können Sie einen Sponsor finden um Ihr Paket ins Archiv hochzuladen.

en: `Work-Needing and Prospective Packages <WNPP_>`_ - Information on how to file "Intent to Package" and "Request for Package" bugs as well as list of open ITPs and RFPs.
de_DE: `Work-Needing and Prospective Packages <WNPP_>`_ – Informationen wie man "Intent to Package" und "Request for Package" Bugs meldet und offene of open ITPs und RFPs auflistet.

en: `Debian Developer's Reference, 5.1. New packages <DevRef_>`_ - The entire document is invaluable for both Ubuntu and Debian packagers. This section documents processes for submitting new packages.
de_DE: `Debian Developer's Reference, 5.1. New packages <DevRef_>`_ – Das gesamte Dokument ist äußerst wichtig sowohl für Ubuntu als auch Debian Paketierer. Diese Sektion dokumentiert wie man neue Pakete einreicht.

en: In some cases, it might make sense to go directly into Ubuntu first. For instance, Debian might be in a freeze making it unlikely that your package will make it into Ubuntu in time for the next release. This process is documented on the `"New Packages" <NewPackages_>`_ section of the Ubuntu wiki.
de_DE: In manchen Fällen mag es Sinn ergeben direkt zuerst in Ubuntu zu gehen. Beispielsweise mag Debian in einem Freeze sein, was es wiederum unwahrscheinlich macht, dass Ihr Paket es rechtzeitig in Ubuntu für die nächste Veröffentlichung schafft. Dieser Prozess ist in der Sektion " <NewPackages_>`_ des Ubuntu Wikis dokumentiert.

en: Screenshots
de_DE: Bildschirmfotos

en: Once you have uploaded a package to debian, you should add screenshots to allow propective users to see what the program is like. These should be uploaded to http://screenshots.debian.net/upload .
de_DE: Haben Sie einmal ein Paket zu Debian hochgeladen, sollten Sie Bildschirmfotos bereitstellen, um zukünftigen Benutzern einen Einblick in das Programm zu geben. Diese sollen auf http://screenshots.debian.net/upload hochgeladen werden.

en: Patches to Packages
de_DE: Patches für Pakete

en: Sometimes, Ubuntu package maintainers have to change the upstream source code in order to make it work properly on Ubuntu.  Examples include, patches to upstream that haven't yet made it into a released version, or changes to the upstream's build system needed only for building it on Ubuntu.  We could change the upstream source code directly, but doing this makes it more difficult to remove the patches later when upstream has incorporated them, or extract the change to submit to the upstream project.  Instead, we keep these changes as separate patches, in the form of diff files.
de_DE: Manchmal müssen Ubuntu Paketmaintainer den Upstream Sourcecode ändern damit dieser einwandfrei auf Ubuntu funktioniert. Beispiele sind Patches an Upstream, die noch nicht in eine veröffentlichte Version eingebunden wurden oder Änderungen auf das Buildsystem die nur verwendet werden müssen um auf Ubuntu zu kompilieren. Wir könnten den Upstream Sourcecode direkt ändern aber dies macht es schwieriger die Patches später zu entfernen wenn Upstream diese eingebunden hat bzw. die Änderung zu extrahieren um es beim Upstream-Projekt einzureichen. Stattdessen behalten wir diese Änderungen als separate Patches in Form von diff-Dateien.

en: There are a number of different ways of handling patches in Debian packages, fortunately we are standardizing on one system, `Quilt`_, which is now used by most packages.
de_DE: Man kann Patches in Debian-Paketen auf unterschiedliche Arten handhaben, glücklicherweise stellt sich `Quilt`_ als Standard heraus, weil es von den meisten Paketen verwendet wird.

en: Let's look at an example package, ``kamoso`` in Trusty::
de_DE: Schauen wir uns ein Beispiel an: ``kamoso`` in Trusty::

en: The patches are kept in ``debian/patches``.  This package has one patch ``kubuntu_01_fix_qmax_on_armel.diff`` to fix a compile failure on ARM.  The patch has been given a name to describe what it does, a number to keep the patches in order (two patches can overlap if they change the same file) and in this case the Kubuntu team adds their own prefix to show the patch comes from them rather than from Debian.
de_DE: Die Patches werden in ``debian/patches`` gespeichert. Dieses Paket hat einen Patch ``kubuntu_01_fix_qmax_on_armel.diff`` um einen Komplierfehler auf ARM zu beheben. Dem Patch wurde ein Name gegeben um zu beschreiben was er macht, eine Nummer um die Patches in einer Reihe zu halten (zwei Patches können sich überschneiden wenn sie die gleiche Datei ändern) und in diesem Falle fügt das Kubuntu Team ihre eigene Vorsilbe hinzu um zu zeigen, dass der Patch von ihnen kommt und nicht von Debian.

en: The order of patches to apply is kept in ``debian/patches/series``.
de_DE: Die Reihenfolge in der Patches angewandt werden ist in ``debian/patches/series`` definiert.

en: Patches with Quilt
de_DE: Patches mit Quilt

en: Before working with Quilt you need to tell it where to find the patches.  Add this to your ``~/.bashrc``::
de_DE: Bevor Sie mit Quilt arbeiten, müssen Sie spezifizieren, wo die Patches liegen. Fügen Sie dies in Ihre ``~/.bashrc`` hinzu::

en: And source the file to apply the new export::
de_DE: Und verwenden Sie ``source``, um die neuen Exports anzuwenden::

en: By default all patches are applied already to UDD checkouts or downloaded packages.  You can check this with::
de_DE: Standardmäßig werden alle Patches angewandt, wenn Sie UDD Checkouts oder heruntergeladene Quellpakete benutzen. Sie können dies folgendermaßen überprüfen::

en: If you wanted to remove the patch you would run ``pop``::
de_DE: Wenn Sie den Patch entfernen wollten, würden Sie ``pop`` ausführen::

en: And to apply a patch you use ``push``::
de_DE: Und um einen Patch anzuwenden, verwenden Sie ``push``::

en: Adding a New Patch
de_DE: Einen neuen Patch hinzufügen

en: To add a new patch you need to tell Quilt to create a new patch, tell it which files that patch should change, edit the files then refresh the patch::
de_DE: Um einen neuen Patch hinzuzufügen, muss Quilt angewiesen werden, einen neuen Patch zu erstellen, sagen Sie ihm, welche Dateien dieser Patch ändern soll, bearbeiten Sie die Dateien und aktualisieren Sie den Patch::

en: The ``quilt add`` step is important, if you forget it the files will not end up in the patch.
de_DE: Der ``quilt add`` ist sehr wichtig, wenn Sie ihn vergessen, werden die Dateien nicht im Patch auftauchen.

en: The change will now be in ``debian/patches/kubuntu_02_program_description.diff`` and the ``series`` file will have had the new patch added to it.  You should add the new file to the packaging::
de_DE: Die Änderung wird jetzt in ``debian/patches/kubuntu_02_program_description.diff`` sein und die ``series`` Datei wird den Patch auflisten. Sie sollten die neue Datei zur Paketierung hinzufügen::

en: Quilt keeps its metadata in the ``.pc/`` directory, so currently you need to add that to the packaging too.  This should be improved in future.
de_DE: Quilt behält seine Metadaten im ``.pc/`` Verzeichnis, sodass dieses momentan ebenfalls für das Paketieren hinzugefügt werden muss. In der Zukunft sollte das verbessert werden.

en: As a general rule you should be careful adding patches to programs unless they come from upstream, there is often a good reason why that change has not already been made.  The above example changes a user interface string for example, so it would break all translations.  If in doubt, do ask the upstream author before adding a patch.
de_DE: Im Allgemeinen sollten Sie vorsichtig sein, Patches zu Programmen hinzuzufügen sofern diese nicht von Upstream kommen, es gibt häufig einen guten Grund warum die Änderung noch nicht vorgenommen wurde. Das oben genannte Beispiel ändert einen Benutzerschnittstellen-String beispielsweise und würde somit mit den gesamten Übersetzungen brechen. Wenn Zweifel bestehen, fragen Sie den Upstreamautor bevor ein Patch hinzugefügt wird.

en: We recommend that you tag every patch with DEP-3_ headers by putting them at the top of patch file. Here are some headers that you can use:
de_DE: Wir empfehlen, dass Sie jeden Patch mit den DEP-3_ Kopfzeilen versehen. Hier sind einige Einträge, die Sie verwenden können:

en: Description
de_DE: Beschreibung

en: Description of what the patch does. It is formatted like ``Description`` field in ``debian/control``: first line is short description, starting with lowercase letter, the next lines are long description, indented with a space.
de_DE: Beschreibung was der Patch macht. Diese wird wie das ``Description`` Feld in ``debian/control`` formatiert: die erste Zeile ist die Kurzbeschreibung, die mit einem Kleinbuchstaben anfängt, die nächsten Zeilen sind ausführliche Beschreibung, die mit einem Leerzeichen eingerückt sind.

en: Author
de_DE: Autor

en: Who wrote the patch (i.e. "Jane Doe <packager@example.com>").
de_DE: Autor des Patches (i.e. "Jane Doe <packager@example.com>").

en: Origin
de_DE: Ursprung

en: Where this patch comes from (i.e. "upstream"), when *Author* is not present.
de_DE: Wo der Patch herkommt (z.B. "upstream"), wenn *Author* nicht verwendet wird.

en: A link to Launchpad bug, a short form is preferred (like *https://bugs.launchpad.net/bugs/XXXXXXX*). If there are also bugs in upstream or Debian bugtrackers, add *Bug* or *Bug-Debian* headers.
de_DE: Ein Link zu einem Launchpad-Bug, eine Kurzform wird vorgezogen (wie z.B. *https://bugs.launchpad.net/bugs/XXXXXXX*). Wenn es auch Bugs in Upstream-Bugtracker oder in Debian gibt, fügen Sie auch *Bug* oder *Bug-Debian* Einträge hinzu.

en: Forwarded
de_DE: Weitergeleitet

en: Whether the patch was forwarded upstream. Either "yes", "no" or "not-needed".
de_DE: Ob der Patch an Upstream weitergeleitet wurde. Entweder "yes", "no" oder "not-needed".

en: Date of the last revision (in form "YYYY-MM-DD").
de_DE: Datum der letzten Revision (in der Form "YYYY-MM-DD").

en: Upgrading to New Upstream Versions
de_DE: Auf neue Upstream Versionen aktualisieren

en: To upgrade to the new version, you can use ``bzr merge-upstream`` command::
de_DE: Um zur neuen Version zu upgraden, können Sie das ``bzr merge-upstream`` Kommando verwenden::

en: When you run this command, all patches will be unapplied, because they can become out of date. They might need to be refreshed to match the new upstream source or they might need to be removed altogether. To check for problems, apply the patches one at a time::
de_DE: Wenn Sie diesen Befehl starten, werden alle Patches nicht angewandt, da sie nicht mehr zu alt werden können. Sie müssen eventuell aktualisiert werden um der neuen Upstreamquelle zu entsprechen oder sie müssen eventuell in ihrer Gesamtheit entfernt werden. Um nach Problemen zu forschen, wenden Sie die Patches nacheinander an::

en: If it can be reverse-applied this means the patch has been applied already by upstream, so we can delete the patch::
de_DE: Wenn er umgekehrt angewendet werden kann, bedeutet das, dass der Patch bereits von Upstream angewendet wurde, damit kann er gelöscht werden::

en: Then carry on::
de_DE: Dann fahren Sie fort::

en: It is a good idea to run refresh, this will update the patch relative to the changed upstream source::
de_DE: Es ist sinnvoll Refresh zu starten, dies wird den Patch entsprechend der veränderten Upstreamquelle aktualisieren::

en: Then commit as usual::
de_DE: Dann committen Sie wie üblich::

en: Making A Package Use Quilt
de_DE: Quilt im Paket verwenden

en: Modern packages use Quilt by default, it is built into the packaging format.  Check in ``debian/source/format`` to ensure it says ``3.0 (quilt)``.
de_DE: Moderne Pakete nutzen standardmäßig Quilt, welches in das Paketierungsformat eingebaut ist. Prüfen Sie ``debian/source/format`` um sich zu vergewissern, dass dort ``3.0 (quilt)`` steht.

en: Older packages using source format 1.0 will need to explicitly use Quilt, usually by including a makefile into ``debian/rules``.
de_DE: Ältere Pakete, die das Quellformat 1.0 verwenden, werden explizit Quilt verwenden müssen, normalerweise in dem ein Makefile in ``debian/rules`` eingebunden wird.

en: Configuring Quilt
de_DE: Quilt konfigurieren

en: You can use ``~/.quiltrc`` file to configure quilt. Here are some options that can be useful for using quilt with debian/packages:
de_DE: Die ``~/.quiltrc`` Datei kann verwendet werden um quilt zu konfigurieren. Hier sind einige Optionen, die nützlich sein können, für die Verwendung von quilt mit debian/packages:

en: Other Patch Systems
de_DE: Andere Patch-Systeme

en: Other patch systems used by packages include ``dpatch`` and ``cdbs simple-patchsys``, these work similarly to Quilt by keeping patches in ``debian/patches`` but have different commands to apply, un-apply or create patches. You can find out which patch system is used by a package by using the ``what-patch`` command (from the ``ubuntu-dev-tools`` package). You can use ``edit-patch``, shown in :ref:`previous chapters <working-on-a-fix>`, as a reliable way to work with all systems.
de_DE: Andere Patchsysteme, die von Paketen verwendet werden beinhalten ``dpatch`` und ``cdbs simple-patchsys``. Diese arbeiten ähnlich wie Quilt indem Patches in ``debian/patches`` gehalten werden aber unterschiedliche Befehle haben Patches anzuwenden, rückabzuwickeln oder Patches zu erstellen. Sie können herausfinden welches Patchsystem von einem Paket verwendet wird in dem Sie den ``what-patch`` Befehl (aus dem Paket ``ubuntu-dev-tools``) verwenden. Sie können ``edit-patch``, gezeigt in :ref:`vorherigen Kapiteln <working-on-a-fix>`, als einen zuverlässigen Weg verwenden, um mit allen Systemen zu arbeiten.

en: In even older packages changes will be included directly to sources and kept in the ``diff.gz`` source file.  This makes it hard to upgrade to new upstream versions or differentiate between patches and is best avoided.
de_DE: In noch älteren Paketen werden Änderungen direkt in den Quellen beinhaltet und in der ``diff.gz`` Quelldatei gespeichert. Dies erschwert es, auf neue Upstream Versionen zu aktualisieren oder zu zwischen Patches zu unterscheiden und sollte am besten nicht gemacht werden.

en: Do not change a package's patch system without discussing it with the Debian maintainer or relevant Ubuntu team.  If there is no existing patch system then feel free to add Quilt.
de_DE: Änderen Sie nicht das Patch-System eines Pakets ohne das mit dem Debian-Maintainer oder dem zuständigen Ubuntu-Team zu besprechen. Wenn derzeit keines existiert, ist es Ihnen freigestellt Quilt hinzuzufügen.

en: Security and Stable Release Updates
de_DE: Security und Stable Release Updates

en: Fixing a Security Bug in Ubuntu
de_DE: Einen sicherheitstechnischen Fehler in Ubuntu beheben

en: Fixing security bugs in Ubuntu is not really any different than :doc:`fixing a regular bug in Ubuntu<./fixing-a-bug>`, and it is assumed that you are familiar with patching normal bugs. To demonstrate where things are different, we will be updating the dbus package in Ubuntu 12.04 LTS (Precise Pangolin) for a security update.
de_DE: Beheben von Sicherheitslücken und Bugs ist nicht wirklich anders als  :doc:`fixing a regular bug in Ubuntu<./fixing-a-bug>` und es wird angenommen, dass Ihnen das Patchen von normalen Bugs bekannt ist. Um zu demonstrieren, wo Dinge anders ablaufen, werden wir das dbus Paket in Ubuntu 12.04 LTS (Precise Pangolin) einem Sicherheitsupdate unterziehen.

en: Obtaining the source
de_DE: Den Quelltext bekommen

en: In this example, we already know we want to fix the dbus package in Ubuntu 12.04 LTS (Precise Pangolin). So first you need to determine the version of the package you want to download. We can use the ``rmadison`` to help with this::
de_DE: In diesem Beispiel wissen wir bereits, dass wir das dbus-Paket in Ubuntu 12.04 LTS (Precise Pangolin) beheben möchten. Somit müssen Sie zuerst die Version des Pakets, welches Sie herunterladen möchten, bestimmen: Wir können  ``rmadison`` hier zur Hilfe verwenden::

en: Typically you will want to choose the highest version for the release you want to patch that is not in -proposed or -backports. Since we are updating Precise's dbus, you'll download 1.4.18-1ubuntu1.4 from precise-updates::
de_DE: Normalerweise sollten Sie die höchste Version für die Veröffentlichung die Sie patchen möchten wählen, die nicht in  -proposed oder -backports ist. Da wird Precise's dbus aktualisieren, laden Sie 1.4.18-1ubuntu1.4 aus precise-updates herunter::

en: Patching the source
de_DE: Den Quelltext patchen

en: To create your patch using ``edit-patch``::
de_DE: Um einen Patch mit ``edit-patch`` anzulegen::

en: This will apply the existing patches and put the packaging in a temporary directory. Now edit the files needed to fix the vulnerability.  Often upstream will have provided a patch so you can apply that patch::
de_DE: Dies wird die existerenden Patches anwenden und die Paketierung in einem temporären Verzeichnis platzieren. Bearbeiten Sie nun die Dateien, die benötigt werden, die Lücke zu beheben. Oft bietet Upsteam einen Patch an so dass Sie diesen anwenden können::

en: After making the necessary changes, you just hit Ctrl-D or type exit to leave the temporary shell.
de_DE: Nachdem die nötigen Änderungen gemacht sind, drücken Sie einfach Strg-D oder geben exit ein um die temporäre Shell zu verlassen.

en: Formatting the changelog and patches
de_DE: Das Changelog und die Patches formatieren

en: After applying your patches you will want to update the changelog. The ``dch`` command is used to edit the ``debian/changelog`` file and ``edit-patch`` will launch ``dch`` automatically after un-applying all the patches. If you are not using ``edit-patch``, you can launch ``dch -i`` manually. Unlike with regular patches, you should use the following format (note the distribution name uses precise-security since this is a security update for Precise) for security updates::
de_DE: Nachdem Ihre Patches angewendet wurden, ist es sinnvoll, das Changelog zu überarbeiten. Der ``dch`` Befehl wird verwendet um die ``debian/changelog`` Datei zu bearbeiten und ``edit-patch`` wird ``dch``automatisch starten sobald alle Patches rück-angewendet wurden. Wenn Sie ``edit-patch`` nicht verwenden, können Sie ``dch -i`` manuell starten. Nicht wie bei regulären Patches sollten Sie das folgende Format benutzen (beachten Sie, dass der Distributionsname precise-security für Sicherheitsupdates verwendet, da es ein Sicherheitsupdate für Precise ist)::

en: Update your patch to use the appropriate patch tags. Your patch should have at a minimum the Origin, Description and Bug-Ubuntu tags. For example, edit debian/patches/99-fix-a-vulnerability.patch to have something like::
de_DE: Aktualisieren Sie Ihren Patch und verwenden die passenden Patchtags. Ihr Patch sollte mindest die Origin, Description und Bug-Ubuntu-Tags haben. Editieren Sie beispielsweise debian/patches/99-fix-a-vulnerability.patch dass es etwas wie folgt enthält::

en: Multiple vulnerabilities can be fixed in the same security upload; just be sure to use different patches for different vulnerabilities.
de_DE: Mehrere Sicherheitslücken können im gleichen Security Upload behoben werden; vergewisseren Sie sich nur, dass Sie verschiedene Patches für verschedene Sicherheitslücken verwendest.

en: Test and Submit your work
de_DE: Ihre Arbeit testen und einsenden

en: At this point the process is the same as for :doc:`fixing a regular bug in Ubuntu<./fixing-a-bug>`. Specifically, you will want to:
de_DE: Ab diesem Zeitpunkt entspricht der Prozess dem in :doc:`fixing a regular bug in Ubuntu<./fixing-a-bug>`. Insbesondere sollten Sie:

en: Build your package and verify that it compiles without error and without any added compiler warnings
de_DE: Ihre Pakete bauen und überprüfen, dass es fehlerfrei kompiliert und ohne zusätzliche Compilerwarnungen

en: Upgrade to the new version of the package from the previous version
de_DE: Aktualisieren Sie auf die neueste Version des Pakets von der vorherigen Version

en: Test that the new package fixes the vulnerability and does not introduce any regressions
de_DE: Testen Sie, dass das neue Paket die Verwundbarkeit behebt und keine neue Regressionen einführt

en: Submit your work via a Launchpad merge proposal and file a Launchpad bug being sure to mark the bug as a security bug and to subscribe ``ubuntu-security-sponsors``
de_DE: Reichen Sie Ihre Arbeit über einen Launchpad Merge Proposal ein und geben einen Launchpad Bug ein, wobei Sie sich vergewissern sollten, dass dieser Bug als Security Bug markiert wird und ``ubuntu-security-sponsors`` abonniert wird.

en: If the security vulnerability is not yet public then do not file a merge proposal and ensure you mark the bug as private.
de_DE: Wenn die Sicherheitslücke noch nicht öffentlich ist, dann geben Sie keinen Merge-Vorschlag auf und vergewisseren sich, dass Sie den Bug als privat markieren.

en: The filed bug should include a Test Case, i.e. a comment which clearly shows how to recreate the bug by running the old version then how to ensure the bug no longer exists in the new version.
de_DE: Der aufgegebene Bug sollte einen Testfall einhalten, beispielsweise einen Kommentar der klar zeigt, wie der Bug durch Aufruf der alten Version nachgestellt werden kann und dann wie der Bug nicht mehr in der neuen Version existiert.

en: The bug report should also confirm that the issue is fixed in Ubuntu versions newer than the one with the proposed fix (in the above example newer than Precise).  If the issue is not fixed in newer Ubuntu versions you should prepare updates for those versions too.
de_DE: Der Bugreport sollte auch bestätigen, dass diese Problematik in Ubuntu-Versionen behoben ist, die neuer sind als die Version mit der vorgeschlagenen Behebung (im oberen Beispiel neuer als Precise). Wenn diese Problematik nicht in neueren Ubuntu-Versionen behoben ist, sollten Sie Aktualisierungen für diese Versionen ebenfalls vorbereiten.

en: Stable Release Updates
de_DE: Updates für stabile Releases

en: We also allow updates to releases where a package has a high impact bug such as a severe regression from a previous release or a bug which could cause data loss.  Due to the potential for such updates to themselves introduce bugs we only allow this where the change can be easily understood and verified.
de_DE: Wir erlauben auch Updates auf Veröffentlichungen, wo ein Paket einen Bug mit großem Einfluss hat, wie beispielsweise schwere Regressionen von einer vorherigen Veröffentlichung oder einen Bug der Datenverlust verursachen könnte. Aufgrund der Schwere für solche Aktualisierungen auf sich selbst, wo sie selbst Bugs einführen erlauben wir dies nur, wenn die Änderung leicht verständlich und überprüft ist.

en: The process for Stable Release Updates is just the same as the process for security bugs except you should subscribe ``ubuntu-sru`` to the bug.
de_DE: Der Prozess für Stable Release Updates ist genau gleich wie der Prozess für Sicherheitsprobleme nur dass man ``ubuntu-sru`` beim Bug abonnieren sollte.

en: The update will go into the ``proposed`` archive (for example ``precise-proposed``) where it will need to be checked that it fixes the problem and does not introduce new problems.  After a week without reported problems it can be moved to ``updates``.
de_DE: Die Aktualisierung wird das ``proposed`` Archiv gehen (beispielsweise ``precise-proposed``). Dort wird eine Überprüfung notwendig, dass das Problem behoben wird und keine weiteren Probleme mit sich bringt. Nach einer Woche ohne gemeldete Probleme kann es in ``updates`` verschoben werden.

en: See the `Stable Release Updates wiki page <SRUWiki_>`_ for more information.
de_DE: Schauen Sie sich die `Stable Release Updates Wikiseite <SRUWiki_>`_ für weitere Informationen an.

en: Installing sbuild
de_DE: Installiere sbuild

en: Create ``.sbuildrc`` in your home directory with following content::
de_DE: Erstelle ``.sbuildrc`` im Home-Verzeichnis mit folgendem Inhalt::

en: Replace “Your Name <user@example.org>” with your name and e-mail address. Change default distribution if you want, but remember that you can specify target distribution when executing command.
de_DE: Ersetzen Sie "Your Name <user@example.org>" mit Ihrem Namen und Ihrer E-Mail-Adresse. Ändern Sie die Standarddistribution, wenn Sie wollen, aber denken Sie daran, dass Sie die Zieldistribution beim Ausführen des Befehls angeben können.

en: If you haven’t restarted your session after adding yourself to the ``sbuild`` group, enter::
de_DE: Wenn Sie Ihre Sitzung noch nicht neugestartet haben, nachdem Sie sich zur Gruppe ``sbuild`` hinzugefügt haben, geben Sie folgendes ein::

en: Generate GPG keypair for sbuild and create chroot for specified release::
de_DE: GPG-Schlüsselpaar für sbuild generieren und chroot für die angegebene Version erzeugen::

en: Entering schroot
de_DE: in schroot wechseln

en: You can use ``schroot -c <release>-<architecture> [-u <USER>]`` to enter newly created chroot, but that’s not exactly the reason why you are using sbuild::
de_DE: Sie können ``schroot -c <Release>-<Architektur> [-u <USER>]`` verwenden, um ein neu erstelltes chroot einzugeben, aber das ist nicht genau der Grund, warum Sie sbuild: verwenden::

en: Using schroot for package building
de_DE: schroot zum Bauen des Paketes benutzen

en: To make use of all power of your CPU, you can specify number of threads used for building using standard ``-j<threads>``::
de_DE: Um die gesamte Leistung Ihrer CPU zu nutzen, können Sie die Anzahl der Threads, die für die Erstellung verwendet werden, mit dem Standard ``-j<threads>`` angeben::

en: ubuntu-dev-tools: Tools for Ubuntu developers
de_DE: ubuntu-dev-tool: Werkzeuge für  Ubuntu Entwickler

en: Introducing yourself
de_DE: Sich vorstellen

en: Save file and restart terminal.
de_DE: Datei speichern und Terminal neu starten.

en: Downloading source packages
de_DE: Lade Quellpakete herunter
