Git Magic deutsch - en to de translation catalogue (58 entries)

note: type: Plain text
en: == Lessons of History ==
de: == Geschichtsstunde ==

note: type: Plain text
en: A consequence of Git's distributed nature is that history can be edited easily. But if you tamper with the past, take care: only rewrite that part of history which you alone possess. Just as nations forever argue over who committed what atrocity, if someone else has a clone whose version of history differs to yours, you will have trouble reconciling when your trees interact.
de: Eine Folge von Git's verteilter Natur ist, dass die Chronik einfach verändert werden kann. Aber, wenn du an der Vergangenheit manipulierst, sei vorsichtig: verändere nur den Teil der Chronik, den du ganz alleine hast. So wie Nationen ewig diskutieren, wer welche Greueltaten vollbracht hat, wirst du beim Abgleichen in Schwierigkeiten geraten, falls jemand einen 'Clone' mit abweichender Chronik hat und die Zweige sich austauschen sollen.

note: type: Plain text
en: Some developers strongly feel history should be immutable, warts and all.  Others feel trees should be made presentable before they are unleashed in public. Git accommodates both viewpoints. Like cloning, branching, and merging, rewriting history is simply another power Git gives you. It is up to you to use it wisely.
de: Einige Entwickler setzen sich nachhaltig für die Unantastbarkeit der Chronik ein, mit allen Fehlern, Nachteilen und Mängeln. Andere denken, daß Zweige vorzeigbar gemacht werden sollten, bevor sie auf die Öffentlichkeit losgelassen werden. Git versteht beide Gesichtspunkte. Wie 'Clonen', 'Branchen' und 'Mergen' ist das Umschreiben der Chronik lediglich eine weitere Stärke, die Git dir bietet. Es liegt an dir diese weise zu nutzen.

note: type: Plain text
en: === I Stand Corrected ===
de: === Ich nehme alles zurück ===

note: type: Plain text
en: Did you just commit, but wish you had typed a different message? Then run:
de: Hast du gerade 'commitet', aber du hättest gerne eine andere Beschreibung eingegeben? Dann gib ein:

note: type: Plain text
en: to change the last message. Realized you forgot to add a file? Run *git add* to add it, and then run the above command.
de: um die letzte Beschreibung zu ändern. Du merkst, dass du vergessen hast eine Datei hinzuzufügen? Führe *git add* aus um sie hinzuzufügen und dann die vorhergehende Anweisung.

note: type: Plain text
en: Want to include a few more edits in that last commit? Then make those edits and run:
de: Du willst noch ein paar Änderungen zu deinem letzten 'Commit' hinzufügen? Dann mache diese Änderungen und gib ein:

note: type: Plain text
en: === ... And Then Some ===
de: === ... und noch viel mehr ===

note: type: Plain text
en: Let's suppose the previous problem is ten times worse. After a lengthy session you've made a bunch of commits. But you're not quite happy with the way they're organized, and some of those commit messages could use rewording. Then type:
de: Nehmen wir jetzt an, das vorherige Problem ist zehnmal schlimmer. Nach einer längeren Sitzung hast du einen Haufen 'Commits' gemacht. Aber du bist mit der Art der Organisation nicht glücklich und einige 'Commits' könnten etwas umformuliert werden. Dann gib ein:

note: type: Plain text
en: and the last 10 commits will appear in your favourite $EDITOR. A sample excerpt:
de: und die letzten zehn 'Commits' erscheinen in deinem bevorzugten $EDITOR. Auszug aus einem Beispiel:

note: type: Plain text
en:     pick 5c6eb73 Added repo.or.cz link
        pick a311a64 Reordered analogies in "Work How You Want"
        pick 100834f Added push target to Makefile
de:     pick 5c6eb73 Link repo.or.cz hinzugefügt
        pick a311a64 Analogien in "Arbeite wie du willst" umorganisiert
        pick 100834f Push-Ziel zum Makefile hinzugefügt

note: type: Plain text
en: Then:
de: Dann:

note: type: Bullet: '- '
en: Remove commits by deleting lines.
de: Entferne 'Commits' durch das Löschen von Zeilen.

note: type: Bullet: '- '
en: Reorder commits by reordering lines.
de: Organisiere 'Commits' durch verschieben von Zeilen.

note: type: Plain text
en: - Replace `pick` with:
       * `edit` to mark a commit for amending.
       * `reword` to change the log message.
       * `squash` to merge a commit with the previous one.
       * `fixup` to merge a commit with the previous one and discard the log message.
de: - Ersetze `pick` mit:
       * `edit` um einen 'Commit' für 'amends' zu markieren.
       * `reword` um die Log-Beschreibung zu ändern.
       * `squash` um einen 'Commit' mit dem vorhergehenden zu vereinen ('merge').
       * `fixup` um einen 'Commit' mit dem vorhergehenden zu vereinen ('merge') und die Log-Beschreibung zu verwerfen.

note: type: Plain text
en: Save and quit. If you marked a commit for editing, then run:
de: Speichere und Beende. Wenn du einen 'Commit' mit 'edit' markiert hast, gib ein:

note: type: Plain text
en: Otherwise, run:
de: Ansonsten:

note: type: Plain text
en: So commit early and commit often: you can tidy up later with rebase.
de: Also 'commite' früh und oft: du kannst später mit 'rebase' aufräumen.

note: type: Plain text
en: === Local Changes Last ===
de: === Lokale Änderungen zum Schluß ===

note: type: Plain text
en: You're working on an active project. You make some local commits over time, and then you sync with the official tree with a merge. This cycle repeats itself a few times before you're ready to push to the central tree.
de: Du arbeitest an einem aktiven Projekt. Über die Zeit haben sich einige lokale 'Commits' angesammelt und dann synchronisierst du mit einem 'Merge' mit dem offiziellen Zweig. Dieser Zyklus wiederholt sich ein paar Mal bevor du zum 'Pushen' in den zentralen Zweig bereit bist.

note: type: Plain text
en: But now the history in your local Git clone is a messy jumble of your changes and the official changes. You'd prefer to see all your changes in one contiguous section, and after all the official changes.
de: Aber nun ist die Chronik in deinem lokalen Git-'Clone' ein chaotisches Durcheinander deiner Änderungen und den Änderungen vom offiziellen Zweig. Du willst alle Deine Änderungen lieber in einem fortlaufenden Abschnitt und hinter den offiziellen Änderungen sehen.

note: type: Plain text
en: This is a job for *git rebase* as described above. In many cases you can use the *--onto* flag and avoid interaction.
de: Das ist eine Aufgabe für *git rebase*, wie oben beschrieben. In vielen Fällen kannst du den *--onto* Schalter benutzen um Interaktion zu vermeiden.

note: type: Plain text
en: Also see *git help rebase* for detailed examples of this amazing command. You can split commits. You can even rearrange branches of a tree.
de: Siehe auch *git help rebase* für ausführliche Beispiele dieser erstaunlichen Anweisung. Du kannst auch 'Commits' aufteilen. Du kannst sogar 'Branches' in einem 'Repository' umorganisieren.

note: type: Plain text
en: === Rewriting History ===
de: === Chronik umschreiben ===

note: type: Plain text
en: Occasionally, you need the source control equivalent of airbrushing people out of official photos, erasing them from history in a Stalinesque fashion. For example, suppose we intend to release a project, but it involves a file that should be kept private for some reason. Perhaps I left my credit card number in a text file and accidentally added it to the project. Deleting the file is insufficient, for the file can be accessed from older commits. We must remove the file from all commits:
de: Gelegentlich brauchst du Versionsverwaltung vergleichbar dem Wegretuschieren von Personen aus einem offiziellen Foto, um diese in stalinistischer Art aus der Geschichte zu löschen. Stell dir zum Beispiel vor, du willst ein Projekt veröffentlichen, aber es enthält eine Datei, die aus irgendwelchen Gründen privat bleiben muss. Vielleicht habe ich meine Kreditkartennummer in einer Textdatei notiert und diese versehentlich dem Projekt hinzugefügt. Die Datei zu löschen ist zwecklos, da über ältere 'Commits' auf sie zugegriffen werden könnte. Wir müssen die Datei aus allen 'Commits' entfernen:

note: type: Plain text
en:  $ git filter-branch --tree-filter 'rm top/secret/file' HEAD
de:  $ git filter-branch --tree-filter 'rm sehr/geheime/Datei' HEAD

note: type: Plain text
en: See *git help filter-branch*, which discusses this example and gives a faster method. In general, *filter-branch* lets you alter large sections of history with a single command.
de: Siehe *git help filter-branch*, wo dieses Beispiel erklärt und eine schnellere Methode vorstellt wird. Allgemein, *filter-branch* lässt dich große Bereiche der Chronik mit einer einzigen Anweisung verändern.

note: type: Plain text
en: Afterwards, the +.git/refs/original+ directory describes the state of affairs before the operation. Check the filter-branch command did what you wanted, then delete this directory if you wish to run more filter-branch commands.
de: Danach beschreibt der Ordner +.git/refs/original+ den Zustand der Lage vor der Operation. Prüfe, ob die 'filter-branch' Anweisung getan hat was du wolltest, dann lösche dieses Verzeichnis bevor du weitere 'filter-branch' Operationen durchführst.

note: type: Plain text
en: Lastly, replace clones of your project with your revised version if you want to interact with them later.
de: Zuletzt, ersetze alle 'Clones' deines Projekts mit deiner überarbeiteten Version, falls du später mit ihnen interagieren möchtest.

note: type: Plain text
en: === Making History ===
de: === Geschichte machen ===

note: type: Plain text
en: [[makinghistory]] Want to migrate a project to Git? If it's managed with one of the more well-known systems, then chances are someone has already written a script to export the whole history to Git.
de: [[makinghistory]] Du möchtest ein Projekt zu Git umziehen? Wenn es mit einem der bekannteren Systeme verwaltet wird, besteht die Möglichkeit, dass schon jemand ein Skript geschrieben hat, das die gesamte Chronik für Git exportiert.

note: type: Plain text
en: Otherwise, look up *git fast-import*, which reads text input in a specific format to create Git history from scratch. Typically a script using this command is hastily cobbled together and run once, migrating the project in a single shot.
de: Anderenfalls, sieh dir *git fast-import* an, das Text in einem speziellen Format einliest um eine Git Chronik von Anfang an zu erstellen. Normalerweise wird ein Skript, das diese Anweisung benutzt, hastig zusammengeschustert und einmalig ausgeführt um das Projekt in einem einzigen Lauf zu migrieren.

note: type: Plain text
en: As an example, paste the following listing into temporary file, such as `/tmp/history`:
    ----------------------------------
de: Erstelle zum Beispiel aus folgendem Listing eine temporäre Datei, z.B. `/tmp/history`:
    ----------------------------------

note: type: Plain text
en: int main() {
      printf("Hello, world!\n");
      return 0;
    }
    EOT
de: int main() {
      printf("Hallo, Welt!\n");
      return 0;
    }
    EOT

note: type: Plain text
en: commit refs/heads/master committer Bob <bob@example.com> Tue, 14 Mar 2000 01:59:26 -0800 data <<EOT Replace printf() with write().  EOT
de: commit refs/heads/master committer Bob <bob@example.com> Tue, 14 Mar 2000 01:59:26 -0800 data <<EOT Ersetze printf() mit write().  EOT

note: type: Plain text
en: int main() {
      write(1, "Hello, world!\n", 14);
      return 0;
    }
    EOT
de: int main() {
      write(1, "Hallo, Welt!\n", 14);
      return 0;
    }
    EOT

note: type: Plain text
en: Then create a Git repository from this temporary file by typing:
de: Dann, erstelle ein Git 'Repository' aus dieser temporären Datei, durch Eingabe von:

note: type: Plain text
en: You can checkout the latest version of the project with:
de: Die aktuellste Version des Projekts kannst du abrufen ('checkout') mit:

note: type: Plain text
en: The *git fast-export* command converts any repository to the *git fast-import* format, whose output you can study for writing exporters, and also to transport repositories in a human-readable format. Indeed, these commands can send repositories of text files over text-only channels.
de: Die Anweisung *git fast-export* konvertiert jedes 'Repository' in das *git fast-import* Format, diese Ausgabe kannst du studieren um Exporteure zu schreiben und außerdem um 'Repositories' in Klartext zu übertragen.  untersuchen wes you can study for writing exporters, and also to transport repositories in a human-readable format. Wirklich, diese Anweisung kann Klartext-'Repositories' über reine Textkanäle übertragen.

note: type: Plain text
en: === Where Did It All Go Wrong? ===
de: === Wo ging alles schief? ===

note: type: Plain text
en: You've just discovered a broken feature in your program which you know for sure was working a few months ago. Argh! Where did this bug come from? If only you had been testing the feature as you developed.
de: Du hast gerade ein Funktion in deiner Anwendung entdeckt, die nicht mehr funktioniert und du weißt sicher, dass sie vor ein paar Monaten noch ging. Argh! Wo kommt dieser Fehler her? Hättest du nur die Funktion während der Entwicklung getestet.

note: type: Plain text
en: It's too late for that now. However, provided you've been committing often, Git can pinpoint the problem:
de: Dafür ist es nun zu spät. Wie auch immer, vorausgesetzt du hast oft 'comittet', kann Git dir sagen, wo das Problem liegt:

note: type: Plain text
en: Git checks out a state halfway in between. Test the feature, and if it's still broken:
de: Git ruft eine Stand ab, der genau dazwischen liegt. Teste die Funktion und wenn sich immer noch nicht funktioniert:

note: type: Plain text
en: If not, replace "bad" with "good". Git again transports you to a state halfway between the known good and bad versions, narrowing down the possibilities.  After a few iterations, this binary search will lead you to the commit that caused the trouble. Once you've finished your investigation, return to your original state by typing:
de: Wenn nicht, ersetzte "bad" mit "good". Git versetzt dich wieder auf einen Stand genau zwischen den bekannten Versionen "good" und "bad" und reduziert so die Möglichkeiten. Nach ein paar Durchläufen wird dich diese binäre Suche zu dem 'Commit' führen, der die Probleme verursacht. Wenn du deine Ermittlungen abgeschlossen hast, kehre zum Originalstand zurück mit:

note: type: Plain text
en: Instead of testing every change by hand, automate the search by running:
de: Anstatt jede Änderung per Hand zu untersuchen, automatisiere die Suche durch Ausführen von:

note: type: Plain text
en:  $ git bisect run my_script
de:  $ git bisect run mein_skript

note: type: Plain text
en: Git uses the return value of the given command, typically a one-off script, to decide whether a change is good or bad: the command should exit with code 0 when good, 125 when the change should be skipped, and anything else between 1 and 127 if it is bad. A negative return value aborts the bisect.
de: Git benutzt den Rückgabewert der übergebenen Anweisung, normalerweise ein Skript für einmalige Ausführung, um zu entscheiden, ob eine Änderung gut ('good') oder schlecht ('bad') ist: Das Skript sollte 0 für 'good' zurückgeben, 125 wenn die Änderung übersprungen werden soll und irgendetwas zwischen 1 und 127 für 'bad'. Ein negativer Rückgabewert beendet die 'bisect'-Operation sofort.

note: type: Plain text
en: You can do much more: the help page explains how to visualize bisects, examine or replay the bisect log, and eliminate known innocent changes for a speedier search.
de: Du kannst noch viel mehr machen: die Hilfe erklärt, wie man 'bisect'-Operationen visualisiert, das 'bisect'-Log untersucht oder wiedergibt und sicher unschuldige Änderungen ausschließt um die Suche zu beschleunigen.

note: type: Plain text
en: === Who Made It All Go Wrong? ===
de: === Wer ist verantwortlich? ===

note: type: Plain text
en: Like many other version control systems, Git has a blame command:
de: Wie viele andere Versionsverwaltungssysteme hat Git eine 'blame' Anweisung:

note: type: Plain text
en: which annotates every line in the given file showing who last changed it, and when. Unlike many other version control systems, this operation works offline, reading only from local disk.
de: das jede Zeile in der angegebenen Datei kommentiert um anzuzeigen, wer sie zuletzt geändert hat und wann. Im Gegensatz zu vielen anderen Versionsverwaltungssystemen funktioniert diese Operation offline, es wird nur von der lokalen Festplatte gelesen.

note: type: Plain text
en: === Personal Experience ===
de: === Persönliche Erfahrungen ===

note: type: Plain text
en: In a centralized version control system, history modification is a difficult operation, and only available to administrators. Cloning, branching, and merging are impossible without network communication. So are basic operations such as browsing history, or committing a change. In some systems, users require network connectivity just to view their own changes or open a file for editing.
de: In einem zentralisierten Versionsverwaltungssystem ist das Bearbeiten der Chronik eine schwierige Angelegenheit und den Administratoren vorbehalten. 'Clonen', 'Branchen' und 'Mergen' sind unmöglich ohne Netzwerkverbindung. Ebenso grundlegende Funktionen wie das Durchsuchen der Chronik oder das 'comitten' einer Änderung. In manchen Systemen benötigt der Anwender schon eine Netzwerkverbindung nur um seine eigenen Änderungen zu sehen oder um eine Datei zum Bearbeiten zu öffnen.

note: type: Plain text
en: Centralized systems preclude working offline, and need more expensive network infrastructure, especially as the number of developers grows. Most importantly, all operations are slower to some degree, usually to the point where users shun advanced commands unless absolutely necessary. In extreme cases this is true of even the most basic commands. When users must run slow commands, productivity suffers because of an interrupted work flow.
de: Zentralisierte Systeme schließen es aus offline zu arbeiten und benötigen teurere Netzwerkinfrastruktur, vor allem, wenn die Zahl der Entwickler steigt. Am wichtigsten ist, dass alle Operationen bis zu einem gewissen Grad langsamer sind, in der Regel bis zu dem Punkt, wo Anwender erweiterte Anweisungen scheuen, bis sie absolut notwendig sind. In extremen Fällen trifft das auch auf die grundlegenden Anweisungen zu. Wenn Anwender langsame Anweisungen ausführen müssen, sinkt die Produktivität, da der Arbeitsfluss unterbrochen wird.

note: type: Plain text
en: I experienced these phenomena first-hand. Git was the first version control system I used. I quickly grew accustomed to it, taking many features for granted. I simply assumed other systems were similar: choosing a version control system ought to be no different from choosing a text editor or web browser.
de: Ich habe diese Phänomen aus erster Hand erfahren. Git war das erste Versionsverwaltungssystem, das ich benutzt habe. Ich bin schnell in die Anwendung hineingewachsen und betrachtete viele Funktionen als selbstverständlich. Ich habe einfach vorausgesetzt, dass andere Systeme ähnlich sind: die Auswahl eines Versionsverwaltungssystems sollte nicht anders sein als die Auswahl eines Texteditors oder Internetbrowser.

note: type: Plain text
en: I was shocked when later forced to use a centralized system. A flaky internet connection matters little with Git, but makes development unbearable when it needs to be as reliable as local disk. Additionally, I found myself conditioned to avoid certain commands because of the latencies involved, which ultimately prevented me from following my desired work flow.
de: Ich war geschockt, als ich später gezwungen war ein zentralisiertes System zu benutzen. Eine unzuverlässige Internetverbindung stört mit Git nicht sehr, aber sie macht die Entwicklung unerträglich, wenn sie so zuverlässig wie ein lokale Festplatte sein sollte. Zusätzlich habe ich mich dabei ertappt, bestimmte Anweisungen zu vermeiden, um die damit verbundenen Wartezeiten zu vermeiden und das hat mich letztendlich davon abgehalten meinem gewohnten Arbeitsablauf zu folgen.

note: type: Plain text
en: When I had to run a slow command, the interruption to my train of thought dealt a disproportionate amount of damage. While waiting for server communication to complete, I'd do something else to pass the time, such as check email or write documentation. By the time I returned to the original task, the command had finished long ago, and I would waste more time trying to remember what I was doing. Humans are bad at context switching.
de: Wenn ich eine langsame Anweisung auszuführen hatte, wurde durch die Unterbrechung meiner Gedankengänge dem Arbeitsfluss ein unverhältnismäßiger Schaden zugefügt. Während dem Warten auf das Ende der Serverkommunikation tat ich etwas anderes um die Wartezeit zu überbrücken, zum Beispiel E-Mails lesen oder Dokumentation schreiben. Wenn ich zur ursprünglichen Arbeit zurückkehrte, war die Operation längst beendet und ich vergeudete noch mehr Zeit beim Versuch mich zu erinnern was ich getan habe. Menschen sind nicht gut im Kontextwechsel.

note: type: Plain text
en: There was also an interesting tragedy-of-the-commons effect: anticipating network congestion, individuals would consume more bandwidth than necessary on various operations in an attempt to reduce future delays. The combined efforts intensified congestion, encouraging individuals to consume even more bandwidth next time to avoid even longer delays.
de: Da war auch ein interessanter http://de.wikipedia.org/wiki/Tragik_der_Allmende[Tragik-der-Allmende] Effekt: Netzwerküberlastungen erahnend, verbrauchten einzelne Individuen für diverse Operationen mehr Netzwerkbandbreite als erforderlich, um zukünftige Engpässe zu vermeiden. Die Summe der Bemühungen verschlimmerte die Überlastungen, was einzelne wiederum ermutigte noch mehr Bandbreite zu verbrauchen um noch längere Wartezeiten zu verhindern.
