Merge pull request #85 from max123kl/Anhang-B

Anhang B – Übersetzung fertig

Author: max123kl

B-embedding-git-in-your-applications.asc

@@ -1,12 +1,12 @@
 [[B-embedding-git-in-your-applications]]
 [appendix]
-== Embedding Git in your Applications
+== Git in Ihre Anwendungen einbetten
 
-If your application is for developers, chances are good that it could benefit from integration with source control.
-Even non-developer applications, such as document editors, could potentially benefit from version-control features, and Git's model works very well for many different scenarios.
+Wenn Ihre Anwendung für Software-Entwickler gedacht ist, stehen die Chancen gut, dass sie von der Integration mit der Quellcode-Versionsverwaltung profitieren kann.
+Auch Anwendungen, die nicht für Entwickler bestimmt sind, wie z.B. Texteditoren, könnten potenziell von Funktionen der Versionskontrolle profitieren. Das Git-System funktioniert sehr gut für viele unterschiedliche Einsatzszenarien.
 
-If you need to integrate Git with your application, you have essentially two options: spawn a shell and call the `git` command-line program, or embed a Git library into your application.
-Here we'll cover command-line integration and several of the most popular embeddable Git libraries.
+Wenn Sie Git in Ihre Anwendung integrieren müssen, haben Sie im Wesentlichen zwei Möglichkeiten: eine Shell zu erzeugen und damit das Git-Kommandozeilenprogramm aufzurufen oder eine Git-Bibliothek in Ihre Anwendung einzubetten.
+Hier werden wir die Befehlszeilenintegration und einige der beliebtesten, integrierbaren Git-Bibliotheken behandeln.
 
 include::book/B-embedding-git/sections/command-line.asc[]
 
@@ -17,4 +17,3 @@ include::book/B-embedding-git/sections/jgit.asc[]
 include::book/B-embedding-git/sections/go-git.asc[]
 
 include::book/B-embedding-git/sections/dulwich.asc[]
-

book/07-git-tools/sections/interactive-staging.asc

@@ -1,5 +1,5 @@
 [[_interactive_staging]]
-=== Interactives Stagen
+=== Interaktives Stagen
 
 In diesem Abschnitt werden Sie einige interaktive Git-Befehle kennenlernen, mit denen Sie Ihre Commits so gestalten können, dass sie nur bestimmte Kombinationen und Teile von Dateien enthalten.
 Diese Tools sind nützlich, um zu entscheiden, ob eine Vielzahl von umfassend modifizierten Dateien in mehrere gezielte Commits aufgeteilt oder in einem großen unübersichtlichen Commit übertragen werden sollen.

book/B-embedding-git/sections/command-line.asc

@@ -1,16 +1,16 @@
-=== Command-line Git
+=== Die Git-Kommandozeile
 
-One option is to spawn a shell process and use the Git command-line tool to do the work.
-This has the benefit of being canonical, and all of Git's features are supported.
-This also happens to be fairly easy, as most runtime environments have a relatively simple facility for invoking a process with command-line arguments.
-However, this approach does have some downsides.
+Die eine Möglichkeit besteht darin, einen Shell-Prozess zu erzeugen und das Git-Kommandozeilen-Tool zu verwenden, um die Arbeit zu erledigen.
+Das hat den Vorteil, dass es kanonisch ist und alle Funktionen von Git unterstützt werden.
+Außerdem ist dieses Verfahren ganz einfach, da die meisten Laufzeit-Umgebungen eine vergleichsweise unkomplizierte Möglichkeit haben, einen Prozess mit Kommandozeilen-Argumenten aufzurufen.
+Dieser Weg hat jedoch auch einige Nachteile.
 
-One is that all the output is in plain text.
-This means that you'll have to parse Git's occasionally-changing output format to read progress and result information, which can be inefficient and error-prone.
+Zum einen ist die gesamte Textausgabe in Klartext.
+Das bedeutet, dass Sie das gelegentlich wechselnde Ausgabeformat von Git analysieren müssen, um Fortschritts- und Ergebnisinformationen zu erfassen, was ineffizient und fehleranfällig sein kann.
 
-Another is the lack of error recovery.
-If a repository is corrupted somehow, or the user has a malformed configuration value, Git will simply refuse to perform many operations.
+Ein weiterer Nachteil ist die unzureichende Fehlerkorrektur.
+Wenn ein Repository irgendwie beschädigt ist oder der Benutzer einen fehlerhaften Konfigurationswert eingestellt hat, verweigert Git einfach die Durchführung vieler Operationen.
 
-Yet another is process management.
-Git requires you to maintain a shell environment on a separate process, which can add unwanted complexity.
-Trying to coordinate many of these processes (especially when potentially accessing the same repository from several processes) can be quite a challenge.
+Noch ein anderer ist das Prozessmanagement.
+Git erfordert die Verwaltung einer Shell-Umgebung in einem separaten Prozess, was zu unerwünschter Komplexität führen kann.
+Der Versuch, viele dieser Prozesse zu koordinieren (insbesondere wenn mehrere Prozesse auf das gleiche Repository zugreifen wollen), kann eine ziemliche Herausforderung darstellen.

book/B-embedding-git/sections/dulwich.asc

@@ -1,14 +1,14 @@
 === Dulwich
 
 (((Dulwich)))(((Python)))
-There is also a pure-Python Git implementation - Dulwich.
-The project is hosted under https://www.dulwich.io/
-It aims to provide an interface to git repositories (both local and remote) that doesn't call out to git directly but instead uses pure Python.
-It has an optional C extensions though, that significantly improve the performance.
+Es gibt auch eine pure Python-Implementierung in Git – Dulwich.
+Das Projekt wird unter https://www.dulwich.io/ gehostet.
+Es zielt darauf ab, eine Schnittstelle zu Git-Repositorys (lokal und remote) bereitzustellen, die nicht direkt Git aufruft, sondern stattdessen reines Python verwendet.
+Es hat dennoch eine optionale C-Erweiterung, die die Leistung erheblich verbessert.
 
-Dulwich follows git design and separate two basic levels of API: plumbing and porcelain.
+Dulwich folgt dem Git-Design und trennt die beiden grundlegenden API-Bereiche: Basis- und Standardbefehle (engl. plumbing and porcelain).
 
-Here is an example of using the lower level API to access the commit message of the last commit:
+Das folgende Beispiel zeigt die API der low-level (Basis-)Ebene, um auf die Commit-Beschreibung des letzten Commits zuzugreifen:
 
 [source, python]
 -----
@@ -25,7 +25,7 @@ c.message
 # 'Add note about encoding.\n'
 -----
 
-To print a commit log using high-level porcelain API, one can use:
+Zum Drucken eines Commit-Protokolls mit der high-level Standard-API kann man folgendes verwenden:
 
 [source, python]
 -----
@@ -38,7 +38,7 @@ porcelain.log('.', max_entries=1)
 -----
 
 
-==== Further Reading
+==== Weiterführende Informationen
 
- * The official API documentation is available at https://www.dulwich.io/apidocs/dulwich.html[]
- * Official tutorial at https://www.dulwich.io/docs/tutorial[] has many examples of how to do specific tasks with Dulwich
+ * Die offizielle API-Dokumentation ist unter https://www.dulwich.io/apidocs/dulwich.html[] verfügbar.
+ * Das offizielle Tutorial bei https://www.dulwich.io/docs/tutorial[] enthält viele Beispiele dafür, wie bestimmte Aufgaben mit Dulwich erledigt werden können.

book/B-embedding-git/sections/go-git.asc

@@ -1,25 +1,25 @@
 === go-git
 
 (((go-git)))(((Go)))
-In case you want to integrate Git into a service written in Golang, there also is a pure Go library implementation.
-This implementation does not have any native dependencies and thus is not prone to manual memory management errors.
-It is also transparent for the standard Golang performance analysis tooling like CPU, Memory profilers, race detector, etc.
+Für den Fall, dass Sie Git in einen in Golang geschriebenen Service integrieren wollen, gibt es auch eine direkte Umsetzung der Go-Bibliothek.
+Diese Implementierung hat keine eigenen Abhängigkeiten und ist daher nicht anfällig für manuelle Fehler in der Speicherverwaltung.
+Sie ist auch transparent für die standardmäßigen Golang-Tools zur Leistungsanalyse wie CPU, Memory-Profiler, Race-Detektor usw.
 
-go-git is focused on extensibility, compatibility and supports most of the plumbing APIs, which is documented at https://github.com/src-d/go-git/blob/master/COMPATIBILITY.md[].
+go-git konzentriert sich auf Erweiterbarkeit und Kompatibilität. Es unterstützt die meisten APIs für die Basisbefehle (engl. plumbing), die auf https://github.com/go-git/go-git/blob/master/COMPATIBILITY.md[] dokumentiert sind.
 
-Here is a basic example of using Go APIs:
+Hier ist ein einfaches Beispiel für die Verwendung der Go-APIs:
 
 [source, go]
 -----
-import 	"gopkg.in/src-d/go-git.v4"
+import "github.com/go-git/go-git/v5"
 
 r, err := git.PlainClone("/tmp/foo", false, &git.CloneOptions{
-    URL:      "https://github.com/src-d/go-git",
+    URL:      "https://github.com/go-git/go-git",
     Progress: os.Stdout,
 })
 -----
 
-As soon as you have a `Repository` instance, you can access information and perform mutations on it:
+Sobald Sie eine `Repository` Instanz haben, können Sie auf Informationen zugreifen und Änderungen daran vornehmen:
 
 
 [source, go]
@@ -40,25 +40,25 @@ for _, c := range history {
 -----
 
 
-==== Advanced Functionality
+==== Erweiterte Funktionalität
 
-go-git has few notable advanced features, one of which is a pluggable storage system, which is similar to Libgit2 backends.
-The default implementation is in-memory storage, which is very fast.
+go-git hat nur wenige nennenswerte fortgeschrittene Funktionen, von denen eine ein erweiterbares Speichersystem ist, das den Libgit2-Backends ähnlich ist.
+Die Standard-Implementierung ist der In-Memory Storage, welcher sehr effizient ist.
 
 [source, go]
 -----
 r, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
-    URL: "https://github.com/src-d/go-git",
+    URL: "https://github.com/go-git/go-git",
 })
 -----
 
-Pluggable storage provides many interesting options.
-For instance, https://github.com/src-d/go-git/tree/master/_examples/storage[] allows you to store references, objects, and configuration in an Aerospike database.
+Die anpassbare Speicherlösung bietet viele interessante Optionen.
+So können Sie beispielsweise mit https://github.com/go-git/go-git/tree/master/_examples/storage[] Referenzen, Objekte und Konfiguration in einer Aerospike-Datenbank speichern.
 
-Another feature is a flexible filesystem abstraction.
-Using https://godoc.org/github.com/src-d/go-billy#Filesystem[] it is easy to store all the files in different way i.e by packing all of them to a single archive on disk or by keeping them all in-memory.
+Ein anderes Feature ist eine flexible Abstraktion des Dateisystems.
+Mit https://pkg.go.dev/github.com/go-git/go-billy/v5?tab=doc#Filesystem[] ist es einfach, alle Dateien auf unterschiedliche Weise zu speichern, d.h. alle Dateien in ein einziges Archiv auf der Festplatte zu komprimieren oder sie alle im Arbeitsspeicher zu halten.
 
-Another advanced use-case includes a fine-tunable HTTP client, such as the one found at https://github.com/src-d/go-git/blob/master/_examples/custom_http/main.go[].
+Ein weiterer fortgeschrittener Verwendungszweck enthält einen fein anpassbaren HTTP-Client, wie er bei https://github.com/go-git/go-git/blob/master/_examples/custom_http/main.go[] zu finden ist.
 
 [source, go]
 -----
@@ -80,7 +80,7 @@ r, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{URL: url})
 -----
 
 
-==== Further Reading
+==== Weiterführende Informationen
 
-A full treatment of go-git's capabilities is outside the scope of this book.
-If you want more information on go-git, there's API documentation at https://godoc.org/gopkg.in/src-d/go-git.v4[], and a set of usage examples at https://github.com/src-d/go-git/tree/master/_examples[].
+Eine vollständige Behandlung der Fähigkeiten von go-git liegt außerhalb des eigentlichen Ziels dieses Buches.
+Wenn Sie weitere Informationen über go-git wünschen, finden Sie die API-Dokumentation auf https://pkg.go.dev/github.com/go-git/go-git/v5[] und eine Reihe von Anwendungsbeispielen unter https://github.com/go-git/go-git/tree/master/_examples[].