Hi Michael!
Ich glaube, du hast eine falsche Vorstellung davon, was so ein Versionsverwaltungssystem macht. Deshalb hier ein paar Worte über Subversion (SVN).
Du kannst bei dir lokal auf der Festplatte einen Ordner erzeugen und in diesem Ordner dein Programm entwickeln. Am besten schön aufgeteilt -- also einzelne zusammengehörende Bereiche in eigene Module aufteilen. Das erleichtert später auch die Zusammenarbeit mit anderen Entwicklern.
Dann achtest du auch noch darauf, dass Funktionen als abgeschlossene Einheit arbeiten. Also keine globale Variablen erwarten.
Parameter --> Funktion --> Rückgabe
So lassen sich einzelne Funktionen unabhängig voneinander TESTEN. Das ist ziemlich wichtig. Damit bestimmst du wie sich eine Funktion verhalten muss und kannst das immer wieder nachprüfen.
Und jetzt kommt SVN ins Spiel. Du erstellst dir auf einem Server ein Subversion-Repository. In diesem Repository erstellst du drei Basisordner ``trunk``, ``tags`` und ``branches``.
Der Ordner ``trunk`` ist für den aktuellen Entwicklungszweig. Hier befindet sich immer die aktuellste Programmrelease.
Der Ordner ``tags`` ist für die einzelnen Zwischenstände. Jedes mal, wenn du eine Programmrelease veröffentlichst, dann speicherst du hier in einem eigenen Unterordner (mit Versionsbezeichnung) den Quellcode, zum Stand des Programmreleases. Damit hast du immer die Möglichkeit, auf den exakten Stand eines Programmreleases zurück zu greifen. Noch dazu kostet das kaum Speicherplatz, da SVN beim Kopieren keine Kopie, sondern einen Link zu einer Dateiversion erstellt.
Der Ordner ``branches`` ist für ausgelagerte Entwicklungen. Es ist so, dass man meistens untereinander ausmacht, dass in den ``trunk``-Ordner nur dann Code eingeckeckt werden darf, wenn dieser kompilierbar oder im Fall von Python ausführbar/testbar ist. Das ist wichtig, damit andere Programmierer am Code arbeiten können und dafür funktionierenden Code zur Verfügung haben. Wenn du also ein Feature einprogrammieren möchtest, für das du viele Tage brauchst und in dieser Zeit das Programm nicht ausführbar/testbar sein wird und du in dieser Zeit nicht auf die Versionsverwaltung verzichten möchtest (ist ja auch eine gute Backupstrategie), dann erstellst du dir im ``branches``-Ordner einen neuen Ordner, ganz speziell nur für dieses Feature. Dann kopierst du dir den Inhalt des ``trunk``-Ordners in diesen neuen Ordner und arbeitst an diesem Feature nur in diesem ``branches``-Unterordner. Dazu stellst du deine lokale Arbeitskope so um, dass beim **Commit** (das ist der Vorgang, wenn du deinen Quellcode ins Repository zurück speicherst) nicht in den ``trunk``-Ordner sondern in den speziellen ``branches``-Unterordner gespeichert wird.
Ist das Feature fertig entwickelt, dann stellst du wieder auf ``trunk`` um und pflegst die Änderungen, die inzwischen im ``trunk``-Ordner gemacht wurden, in deinen **Branch** ein (merge). Läuft bei dir dann das Programm, inklusive deiner und den Änderungen der anderen Programmierer, dann kannst du den neuen Stand wieder in den ``trunk``-Ordner commiten.
Du kannst jeden Entwicklungsstand, der je in das SVN eingepflegt wurde, wiederherstellen und so Fehler wieder ausbessern. So ist es kein Problem, wenn jemand mal einen Pfusch gebaut hat. Auch lässt sich schön nachverfolgen, was von wem am Quellcode in welcher Datei geändert wurde. So lässt sich schnell herausfinden, welche Änderung am Quellcode schuld ist, warum etwas nicht mehr so wie gewünscht funktioniert.
Beim Commit muss jeder einen Kommentar übermitteln. Die gesammelten Kommentare beschreiben dann den Verlauf der Entwicklung eines Programmes. Das ist auch der Grund, weshalb ich für jedes Programm ein eigenes SVN-Repository verwalte.
Als Entwickler der vor hat gemeinsam mit anderen Entwicklern ein Programm zu programmieren, ist es, meines Erachtens, ein absolutes Muss, sich mit Subversion zu beschäftigen.
Auch wenn man alleine ist und nicht gemeinsam programmiert, ist so eine Versionsverwaltung ein wahrer Segen. Es ist schon einige Male vorgekommen, dass ich dankend wieder auf eine vorhergehende Version eines Programmes zurückgegriffen habe, da ich mich beim Programmieren verrannt oder schlicht eine Datei versehentlich gelöscht habe.
Genausoviel, wenn nicht noch mehr dieser nützliche Dinge kann ich auch über Trac schreiben. SVN ist gut, aber in Verbindung mit Trac ist es spitze! Trac verbindet SVN mit einer Projektverwaltung (Ticketsystem, Timeline, Roadmap) und einem Wiki. Vom Wiki aus lassen sich Links zu Tickets, zu einzelnen Zeilen in einer Quellcodedatei und zu Changesets erstellen. Sogar die Auflistung der einzelnen Tickets (=ToDo-Anweisungen oder Fehlerberichte) kann angepasst und über das Wiki aufgerufen werden. Quellcode mit Syntaxhighlighting, reStructured Text usw.
Klar -- man braucht schon einige Tage um sich in so ein System einzuarbeiten, aber das ist es auf jeden Fall wert.
Wenn du jetzt noch, zum zusätzlichen Koordinieren und gemeinsamen Besprechen von Codeteilen, ein Forum heranziehst, dann hast du eine wunderschöne Programmfabrik, die Fehler verzeiht und mit der die Zusammenarbeit an einem Programm Spaß macht.
lg
Gerold
Will auch teilhaben, an so einem Projekt!)
;D
Kennt einer das Problem und seine Lösung?