\documentclass[hyperref={bookmarks=true}]{beamer}

\usepackage{beamerthemesplit}
\usepackage{ngerman}
\usepackage[latin1]{inputenc}
\usepackage{eurosym}
\usepackage{graphicx}
\useoutertheme{jhd}
\usecolortheme{jhd}

\title{Parallele Programmentwicklung mit CVS}
\author{Jan Hendrik Dithmar}
\date{03.11.2005}

\begin{document}

\newcommand{\bild}[2]{
	\begin{figure}[htpb]
		\centering
			\includegraphics[width=#1cm]{#2}
	\end{figure}
	}

\newcommand{\Link}[2]{
	\textcolor{blue}{\href{#1}{#2}}
}

\frame{\titlepage}

\section{Einführung}
\frame
{
	\frametitle{Einführung}
	\pause
	
	Bisherige Arbeitsweise: \\
	Es gibt ein Verzeichnis, auf das alle Entwickler Zugriff haben und arbeiten können. Dabei \glqq gewinnt\grqq\ immer die letzte Speicherung	einer Datei. \\[0.5cm] \pause
	
	Vorschlag der zukünftigen Arbeitsweise: \\
	CVS (Concurrent Versions System)
}

\section{Vor- und Nachteile der bisherigen Arbeitsweise}
\frame
{
	\frametitle{Vor- und Nachteile der bisherigen Arbeitsweise}
	\pause
	
	Vorteile:
	\begin{itemize}
		\item relativ einfache Installation und Wartung
		\item einfache Bedienung (Arbeiten wie mit lokalen Verzeichnissen und/oder Laufwerken)
	\end{itemize}
	
	\pause
	
	Nachteile:
	\begin{itemize}
		\item Ändern 2 Entwickler etwas an der gleichen Datei (beispielsweise der eine am Anfang, der andere am Ende) so geht die Änderung eines Entwicklers beim Speichern verloren
		\item Frühere Konfigurationen des Softwaresystems müssen über recht komplizierte Wege wiederhergestellt werden (z.B. mit umständlichen Backups)
	\end{itemize}
}

\section{Versionierung eines Softwaresystems}
\frame
{
	\frametitle{Versionierung eines Softwaresystems}
	
	Wird ein Softwaresystem aus mehreren Komponenten versioniert, gilt es, zwei Ziele zu verfolgen: \\[0.3cm]
	\pause
	\textbf{Konsistenz:} Es muss stets gesichert sein, dass die in Anspruch genommenen Dienste einer Schnittstelle auch tatsächlich zur Verfügung gestellt werden. D.h.: Wird eine Schnittstelle verändert, so müssen diese Änderungen \textit{gekoppelt} sein, so dass sie nicht unabhängig voneinander angewandt werden können. \\[0.2cm]
	\pause
	\textbf{Flexibilität:} So lange die Schnittstelle unverändert bleibt, muss es möglich sein, beliebige Versionen einer Komponente auszuwählen und so ein System passend für einen bestimmten Zweck oder eine bestimmte Umgebung zu \textit{konfigurieren}. \\[0.3cm]
	\pause
	Konsistenz ist eine absolut notwendige Qualitätsbedingung für Softwaresysteme. Durch das Benennen von Konfigurationen können konsistente Konfigurationen identifiziert und zu einem späteren Zeitpunkt wiederhergestellt werden.
}

\section{Was bedeutet Konsistenz bei Softwaresystemen?}
\frame
{
	\frametitle{Was bedeutet Konsistenz bei Softwaresystemen?}
	\pause
	
	Beispiel (abstrakt): \\
	Bei einem Softwaresystem gibt es die Komponente $A$ und eine Komponente $A'$, die eine Revision von $A$ mit erweiterter Funktionalität darstellt. Eine Komponente $B$ nutzt diese erweiterte Funktionalität von $A'$. $B$ kann nicht (mehr) mit $A$ kombiniert werden. \\[0.3cm] \pause
	Beispiel (konkreter): \\
	Ein Programm \glqq Taschenrechner\grqq\ hat eine Klasse, in der alle Berechnungen stattfinden (Komponente $A$). Die grafische Oberfläche (Komponente $B$) ruft die jeweiligen Prozeduren der Komponente $A$ auf. $A$ wird jetzt um die Möglichkeit erweitert, das letzte berechnete Zwischenergebnis zu speichern (und wird zu Komponente $A'$). Die grafische Oberfläche nutzt diesen Vorteil aus und stellt das Zwischenergebnis immer in einem Feld dar. $B$ kann nicht mehr mit $A$ kombiniert werden, da $A$ diese Funktionalität nicht aufweist.
}

\section{Vor- und Nachteile von CVS}
\frame
{
	\frametitle{Vor- und Nachteile von CVS}
	\pause
	
	Vorteile:
	\begin{itemize}
		\item CVS kann ganze Dateibäume versionieren
		\item CVS berücksitigt das Anlegen und Löschen von Dateien
		\item es können mehrere Entwickler parallel entwickeln, keine Änderung geht verloren; es kann höchstens ein Konflikt auftreten (später mehr dazu)
	\end{itemize}
	
	\pause
	
	Nachteile:
	\begin{itemize}
		\item Eingewöhnungszeit in die neue Arbeitsweise
	\end{itemize}
}

\section{CVS-Kommandos}
\frame
{
	\frametitle{CVS-Kommandos}
	
	\begin{tabular}{lcl}
		\texttt{cvs checkout} & - & Kopieren der Quellen des Projekts aus \\
		& & dem CVS-Archiv in den Arbeitsbereich \\
		\texttt{cvs commit} & - & Kopieren der aktuellen Dateiversionen aus \\
		& & dem Arbeitsbereich in das CVS-Archiv \\
		\texttt{cvs tag} & - & Vergabe eines Namens für eine bestimmte \\
		& & Konfiguration \\
		\texttt{cvs add} & - & Hinzufügen einer Datei in das CVS-Archiv \\
		& & (erst bei \texttt{commit} wird die Datei in das \\
		& & CVS-Archiv übernommen) \\
		\texttt{cvs remove} & - & Löschen einer Datei aus dem CVS-Archiv \\
		& & (ebenfalls erst nach \texttt{commit} wirksam)
	\end{tabular}
}

\section{CVS-Kommandos (2)}
\frame
{
	\frametitle{CVS-Kommandos (2)}
	
	\begin{tabular}{lcl}
		\texttt{cvs release} & - & Prüfung ob alle lokalen Änderungen in \\
		& & das CVS-Archiv übernommen wurden \\
		& & (wenn nicht, wird eine Warnung ausgegeben; \\
		& & mit einer speziellen Option kann man den \\
		& & Arbeitsbereich löschen) \\
		\texttt{cvs update} & - & Arbeitsverzeichnis auf den neusten Stand bringen \\
		\texttt{cvs edit} & - & Meldet eine Datei zum Bearbeiten an; gleichzeitig \\
		& & wird der Benutzer als Beobachter der Datei \\
		& & eingetragen
	\end{tabular} \\[0.5cm]
	Auf den nächsten Folien folgen Beispiele an Hand eines Projektes \glqq Taschenrechner\grqq\ für die Nutzung von CVS mit den Entwicklern Paul und Tom.
}

\section{Beipiel 1: cvs checkout}
\frame
{
	\frametitle{Beispiel 1: cvs checkout}
	
	Entwickler Paul kopiert das CVS-Archiv in seinen Arbeitsbereich: \\[0.2cm]
	\texttt{paul\$} \textbf{cvs checkout rechner} \\
	\texttt{cvs checkout: Updating rechner} \\
	\texttt{U rechner/Makefile} \\
	\texttt{U rechner/calc.h} \\
	\texttt{U rechner/add.cpp} \\
	\texttt{U rechner/sub.cpp} \\
	\texttt{paul\$ \_}
	\bild{5}{paul_checkout}
}

\section{Beispiel 2: cvs commit}
\frame
{
	\frametitle{Beispiel 2: cvs commit}
	
	Entwickler Paul will eine Änderung in das CVS-Archiv kopieren. Mit dem folgenden Befehl kopiert er die neue Revision: \\[0.2cm]
	\texttt{paul\$} \textbf{cvs commit -m "'Korrektur einer Berechnung"' add.cpp} \\
	\texttt{Checking in add.cpp;} \\
	\texttt{/usr/share/CVS/rechner/add.cpp,v <-- add.cpp} \\
	\texttt{new revision: 1.3; previous revision: 1.2} \\
	\texttt{done} \\
	\texttt{paul\$ \_}
	\bild{5}{paul_commit}
}

\section{Beispiel 3: cvs update}
\frame
{
	\frametitle{Beispiel 3: cvs update}
	
	Entwickler Tom macht nun \texttt{checkout}. Paul arbeitet an der Datei \texttt{sub.cpp} und Tom beginnt seine Arbeit an \texttt{calc.h}. Paul macht einen \texttt{commit}. Wenn Tom danach ebenfalls einen \texttt{commit} machen will, stellt CVS fest, dass die Datei \texttt{sub.cpp} in Toms Arbeitsbereich nicht mehr aktuell ist. Der \texttt{commit}-Befehl schlägt fehl. Um dem \texttt{commit}-Befehl gerecht zu werden, muss Tom seinen Arbeitsbereich auf den neusten Stand bringen. Dazu gibt er \texttt{cvs update} ein. Der \texttt{update}-Befehl bringt sein Arbeitsverzeichnis auf den neusten Stand.
	\bild{5}{tom_update}
}

\section{Beispiel 3: cvs update (2)}
\frame
{
	\frametitle{Beispiel 3: cvs update (2)}
	
	Nach der Aktualisierung seines Arbeitsbereiches kann Tom mit \texttt{commit} seine Änderungen in das CVS-Archiv kopieren. Paul muss dann - genau wie Tom vorher - seinen Arbeitsbereich mit \texttt{update} aktualisieren, um wieder einen \texttt{commit} zu machen.
	\bild{5}{tom_commit-paul_update}
}

\section{Beispiel 4: cvs tag}
\frame
{
	\frametitle{Beispiel 4: cvs tag}
	
	Das Produkt soll in der jetzigen Konfiguration an den Kunden ausgeliefert werden. Dazu kann Paul ihr einen Namen geben, damit sie später wiederhergestellt werden kann (z.B. zur Fehlersuche). \\[0.2cm]
	Paul wählt den Namen \texttt{rechner1} für die aktuelle Konfiguration: \\[0.2cm]
	\texttt{paul\$} \textbf{cvs tag rechner1} \\
	\texttt{cvs tag: Tagging.} \\
	\texttt{T Makefile} \\
	\texttt{T calc.h} \\
	\texttt{T add.cpp} \\
	\texttt{T sub.cpp} \\
	\texttt{paul\$ \_}
}

\section{Wichtige Hinweise zum Umgang mit CVS}
\frame
{
	\frametitle{Wichtige Hinweise zum Umgang mit CVS}
	
	\begin{itemize}
		\item Die Entwickler sollten sich absprechen und die Arbeit aufteilen, um das Risiko eines Konfliktes zu verhindern.
		\item Jeder Entwickler sollte regelmäßig seinen Arbeitsbereich mit dem CVS-Archiv abgleichen. Je länger kein Abgleich stattgefunden hat desto größer die Unterschiede zwischen den einzelnen Arbeitsbereichen und desto höher die Wahrscheinlichkeit eines Konfliktes.
	\end{itemize}
}

\section{Konflikte und Absprachen}
\frame
{
	\frametitle{Konflikte und Absprachen}
	
	Haben zwei Entwickler nicht nur in der gleichen Datei, sondern auch an der gleichen Stelle was geändert, kommt es zu einem Konflikt. CVS fügt dann beide Änderungen in die betreffende Datei ein und markiert die Konfliktstelle. Der Konflikt muss nun von Hand aufgelöst werden. \\[0.5cm] \pause
	In der Praxis treten solche Konflikte selten auf, wenn die Entwickler koordiniert vorgehen und ihre Arbeit untereinander absprechen. \\[0.3cm] \pause
	\texttt{edit} stellt eine Vorbeugemaßnahme von CVS dar. Durch den \texttt{edit}-Befehl meldet der Benutzer zum einen an, die angegebene Datei bearbeiten zu wollen, zum anderen wird er auf die Liste der Benutzer gesetzt, die diese Datei beobachten. Wendet man nun mit \texttt{commit} eine Änderung an, so wird man von CVS automatisch als Beobachter ausgetragen. Alle anderen Beobachter werden benachrichtigt, dass die Datei geändert wurde.
}

\section{Zusammenfassung}
\frame
{
	\frametitle{Zusammenfassung}
	
	CVS bietet gegenüber der bisherigen Arbeitsweise einige Möglichkeiten, die das Arbeiten an Projekten erleichtern (können). Hier noch einmal kurz die Vorzüge:
	\begin{itemize}
		\item<2->Änderungen von mehreren Entwicklern an einer Datei gehen nicht verloren, d.h. mehrere Entwickler können parallel an einem Projekt arbeiten
		\item<3->es lässt sich ohne viel Mühe jede Änderung rückgängig machen
		\item<4->man kann Konfigurationen unter einem Namen ablegen; dies ist z.B. hilfreich, wenn eine bestimmte Konfiguration an einen Kunden ausgeliefert wird und nachher für eventuelle Fehlersuche wiederhergestellt werden soll
	\end{itemize}
}

\section{Zusammenfassung (2)}
\frame
{
	\frametitle{Zusammenfassung (2)}
	
	\begin{itemize}
		\item<2->ein CVS-System ermöglicht die Versionierung von kompletten Dateibäumen, d.h. CVS berücksichtigt auch das Anlegen und Löschen von Dateien
		\item<3->ein Entwickler kann eine oder mehrere Dateien beobachten und wird informiert, sobald Änderungen in das CVS-Archiv eingeflossen sind
		\item<4->man kann dem CVS-System auch mitteilen, dass man gerne eine Datei bearbeiten möchte; dabei werden alle anderen Entwickler, die diese Datei beobachten, informiert
	\end{itemize}
}

\section{CVS im Internet}
\frame
{
	\frametitle{CVS im Internet}
	
	\begin{itemize}
		\item \Link{http://www.nongnu.org/cvs/}{http://www.nongnu.org/cvs/}
		\item \Link{http://de.wikipedia.org/wiki/CVS}{http://de.wikipedia.org/wiki/CVS}
		\item \Link{http://en.wikipedia.org/wiki/Concurrent_Versions_System}{http://en.wikipedia.org/wiki/Concurrent\_Versions\_System}
	\end{itemize}
}

\end{document}