\documentclass{lxarticle}
\usepackage{german}
\usepackage[utf8]{inputenc}
\usepackage{lxheaders}
\usepackage{lxextras}

\begin{document}

\section*{Entwicklungsumgebung}

Eine Entwicklungsumgebung besteht mindestens aus einem Editor und einem
Buildsystem. Eine Entwicklungsumgebung kann aber durchaus weitere Komponenten
beinhalten, z.B. zur Versionskontrolle, Projektmanagment, GUI Design,
Modelierung, Bug Reporting, \dots

So genannte integrierte Entwicklungsumgebungen integrieren alle f\"ur die
Entwicklung n\"otigen Tools in eine Oberfl\"ache. H\"aufig k\"onnen integrierte
Entwicklungsumgebungen mit Plugins auf die eigenen Bed\"urfnisse angepasst
werden.

In diesem Block wird auf die verschiedenen Komponenten einer
Entwicklungsumgebung eingegangen und Eclipse als prominenter Vertretter der
integrierten Entwicklungsumgebungen n\"ahers vorgestellt.

\subsection*{Editoren}

Prinzipiell kann man zwischen textbasierten und grafischen Editoren
unterscheiden. Ein textbasierter Editor ist in der Regel nicht so intuitiv zu
bedienen, als ein Grafischer. Textbasierte Editoren werden in der Regel
ausschliesslich per Tastatur bedient, was zu dem Vorteil f\"uhrt, dass diese
schneller bedienbar sind, als grafische Editoren, bei denen oft die Hand
zwischen Tastatur und Maus bewegt werden muss.

Ein weiterer Vorteil von textbasierten Editoren ist, dass Sie sich problemlos
remote bedienen lassen. Aber auch grafische Editoren lassen sich normalerweise
per ssh und X-Forwarding remote bedienen.

H\"aufig eingesetzte textbasierte Editoren unter Linux sind:
\begin{itemize}
\item vim
\item nano
\item joe
\item microemacs (linus editor)
\item yed
\end{itemize}

bei den grafischen Derivaten wird oft:
\begin{itemize}
\item gedit
\item kate
\item nedit
\end{itemize}
verwendet.

\subsection*{Versionskontrolle}

Sinn einer Versionskontrolle ist die zentrale Verwaltung des Quellcodes (und
evt. der dazugeh\"origen Dokumentation) und ein Tracking der \"Anderungen.

\begin{description}
\item[Subversion] ist ein freies, ziemlich einfach zu bedienendes
Versionsverwaltungssystem. Es st\"o\ss t an seine Grenzen, wenn viele Entwickler
gleichzeitig die selben Dateien editieren.
\item[Git] wurde speziell zur Unterst\"utzung der Linux Kernel Entwicklung
entwickelt und eignet sich deshalb perfekt f\"ur die verteilte Entwicklung und
gro\ss e Teams.
\end{description}

\subsection*{Integrierte Entwicklungs Umgebungen}

\subsubsection*{Emacs}

Die GNU Emacs IDE kann in zwei verschiedenen Modi gestartet werden. Mit dem
Befehl \cmd{emacs} wird eine grafische Umgebung gestartet (Abbildung
\ref{img:emacs_bunt.png}). Der Befehl \cmd{emacs -nw} startet emacs im Textmodus
(Abbildung \ref{img:emacs.png}). Beide Modis akzeptieren die Selben
Tastenkombinationen.

Als \"Ubung kann ein kleines C Programm und ein passendes Makefile in emacs
erstellt werden.

\begin{enumerate}
\item \cmd{emacs -nw}
\item \cmd{Ctrl+x, Ctrl+w} (Speichern als\dots) -  als Makefile abspeichern
\item Makefile erstellen
\item \cmd{Ctrl+x, Ctrl+s} (Speichern)
\item \cmd{Ctrl+x, Ctrl+c} (Schlie\ss en)
\item \cmd{emacs -nw}
\item \cmd{Ctrl+x, Ctrl+w} (Speichern als\dots) - z.B. als hello.c speichern
\item Quellcode eingeben (Fehler einbauen!!)
\item \cmd{Ctrl+x, Ctrl+s} (Speichern)
\item \cmd{alt+x compile} Software \"ubersetzen
\item \cmd{Ctrl+x, o} In den unteren Tab springen
\item \cmd{TAB} zum n\"achsten Fehler springen
\item \cmd{Return} in die entsprechende Codezeile springen
\item Quellcode fixen, speichern, compilieren, \dots
\end{enumerate}

\subsubsection*{Eclipse}

Dieses Kapitel beschreibt die Entstehung und Prinzipien von Eclipse. An einigen
kurzen Beispielen, wird die grundlegende Bedienung einer Eclipse IDE
vorgestellt.

\paragraph*{Allgemeines}

Eclipse wurde urspr\"unglich von IBM entwickelt und im November 2001 als
open source offen gelegt. Eclipse ist in JAVA implementiert und arbeitet mit
SWT als GUI frontend. Diese Kombination erlaubt den Einsatz auf allen g\"angigen
Betriebssystemen.

Seit Version 3.0 ist Eclipse nur noch ein Equinox OSGi Kern. Der Eclipse Kern
bietet keine Funktionalit\"aten f\"ur den Endbenutzer. Funktionalit\"aten werden
in Form von Plugins in den Kern integriert. Der Eclipse Kern bietet die
M\"oglichkeit Plugins von so genannten 'update-sites' nach zu installieren.

Freie oder kommerzielle Eclipse Plugins gibt es f\"ur viele Aufgaben:
\begin{itemize}
	\item Versionskontrolle: cvs, git, svn, \dots
	\item Programmiersprachen: java, C, C++, Python, \dots
	\item Workflows: UML, Modelling, bugzilla, JIRA, Remote Target Management,
		\dots
	\item Frameworks: QT, CORBA, Eclipse Plugin Development, \dots
	\item \dots
\end{itemize}

Aus einer Zusammenstellung von Plugins entstehen die sogenannten 'Eclipse
basierten Entwicklungsumgebungen' die wiederum teilweise frei oder kommerziell
erhaeltlich sind.

Freie Eclipse basierte IDEs:
\begin{itemize}
	\item Eclipse IDE for JAVA Developers (http://www.eclipse.org/downloads)
	\item Eclipse IDE for C++ Developers (http://www.eclipse.org/downloads)
	\item Eclipse Modeling Tools (http://www.eclipse.org/downloads)
	\item Pydev for Python Developers (http://pydev.sourceforge.net)
\end{itemize}

Kommerzielle Eclipse basierte IDEs:
\begin{itemize}
	\item Windriver Workbench (http://www.windriver.com/products/workbench)
	\item IBM Rational/Websphere Suites (http://www.ibm.com)
	\item Montavista DevRocket
		(http://www.mvista.com/product\_detail\_devrocket.php)
	\item SAP Netweaver (http://www.sap.com/platform/netweaver/index.epx)
\end{itemize}

Es besteht auch die M\"oglichkeit, sich eine Eclipse IDE selber zusammen zu
stellen und eigene Eclipse Plugins zu entwickeln um die IDE optimal an die
Infrastruktur des Entwicklungsteams an zu binden.

Die hier n\"ahers vorgestellte Eclispe basierte IDE wurde von Linutronix
speziell f\"ur die embedded Anwendungsentwicklung zusammengestellt und bietet
unterst\"utzung in folgenden Punkten:
\begin{itemize}
	\item Programmiersprachen:
		\begin{itemize}
			\item C
			\item C++
			\item JAVA / Open JDK 1.6
		\end{itemize}
	\item Versionskontrolle:
		\begin{itemize}
			\item Subversion
			\item CVS
			\item git
		\end{itemize}
	\item Profiling mit valgrind:
		\begin{itemize}
			\item memory leak detection
			\item heap analyzation
		\end{itemize}
	\item QT 4.5 Integration
	\item Remote Target Managment
		\begin{itemize}
			\item Target File Explorer
			\item Target Process Viewer
			\item Remote Debugging
			\item Target Monitoring
		\end{itemize}
	\item ARM Device Emulation
	\item Bugzilla Bugtracking Integration
	\item Modelierungswerkzeuge
		\begin{itemize}
			\item UML2
			\item Eclipse Modeling Framework
			\item Graphical Modeling Framework
		\end{itemize}
\end{itemize}

\paragraph{Bedienoberf\"ache}

\begin{figure}
\centering
\includegraphics[width=\textwidth]{images/eclipse_overview.png}
\caption{Eclipse IDE Komponenten}
\label{img:eclipse_ide}
\end{figure}

Die Entwicklungsumgebung (Abbildung \ref{img:eclipse_ide}) ist in verschiedene
Bereiche eingeteilt, welche frei platziert werden k\"onnen. Es besteht auch die
M\"oglichkeit, das Docking auf zu l\"osen, um die Bereiche auf mehreren
Monitoren zu verteilen. Nachfolgend sind die Bereiche, wie Sie in der Default
Einstellung vor zu finden sind beschrieben.

\begin{description}
\item[Perspective Selection (orange)] Eclipse kann zwischen verschiedenen
Perspektiven umgeschaltet werden. Die Perspektiven werden von den Plugins zur
Verf\"ugung gestellt. Die weiteren Komponenten der Umgebung werden durch die
gew\"ahlte Perspektive definiert. Die hier beschriebenen Komponenten sind
teilweise nur in der C/C++ Perspektive verf\"ugbar.
\item[Project Explorer (rot)] Hier werden alle Projekte des w\"ahrend des
Startups gew\"ahlten workspaces und derren Dateien aufgelistet.
\item[Editor (gr\"un)] In diesem Bereich werden die Quelldateien, welche mittels
Doppelklick im \cmd{Project Explorer} ge\"offnet werden angezeigt. Am linken
Rand k\"onnen Marker und Breakpoints gesetzt werden. Sind mehrere Dateien
gleichzeitig ge\"offnet werden am oberen Rand weitere Tabs generiert. Per Drag
and Drop k\"onnen auch mehrere Source Tabs neben- oder untereinander platziert
werden.
\item[Outline View (blau)] Alle Symbole des aktuell ge\"offneten Source Files
werden hier gelistet. Mit Doppelklick auf ein Symbol wird an die entsprechende
Stelle im Source gesprungen.
\item[Problems (gelb)] Compile Fehler und Warnungen werden hier aufgelistet.
Mit Doppelklick auf einen Eintrag wird an die entsprechende Zeile im Source Code
gesprungen.
\item[Console (lila)] Wird die eigene Applikation innerhalb Eclipse ausgef\"uhrt
wird stdout und stderr auf dieser Console dargestellt.
\end{description}

\paragraph{Projekt anlegen}

Es wird nun am Beispiel einer simplen 'Hallo Welt' Applikation die grundlegende
Eclipse Bedienung erlkl\"art.

W\"ahrend der Eclipse Initialisierung muss ein workspace ausgew\"ahlt werden
(Abbildung \ref{img:select_workspace}). Unterhalb diesem Verzeichnis werden
alle Projektdateien abgelegt.

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/select_workspace.png}
\caption{Auswahl des Arbeitsverzeichnisses}
\label{img:select_workspace}
\end{figure}

\"Uber die Men\"upunkte \cmd{File}, \cmd{New}, \cmd{C Project} (Abbildung
\ref{img:new_c_project} wird der Wizard (Abbildung \ref{img:project_properties})
zur Erstellung eines neuen C Projekts ge\"offnet. Dort kann gew\"ahlt werden,
ob ein \cmd{Executable}, eine \cmd{Static Library} oder \cmd{Shared Library},
ein \cmd{GNU Autotools} Projekt oder ein \cmd{Makefile Project} angelegt werden
soll. F\"ur dieses Beispiel wird \cmd{Executable}, \cmd{Empty Project}
ausgew\"ahlt. Der Projektname definiert normalerweise den Ordnername unterhalb
des workspaces. Mit \cmd{Finish} wird die Projekterstellung abgeschlossen.

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_new_c_project.png}
\caption{Neues C Projekt anlegen}
\label{img:new_c_project}
\end{figure}

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_new_hallo_welt.png}
\caption{Projekteigenschaften einstellen}
\label{img:project_properties}
\end{figure}

Als n\"achstes wird dem Projekt ein neues C Source File hinzugef\"ugt. Hierzu
wird \cmd{File}, \cmd{New}, \cmd{Source File} (Abbildung \ref{img:new_src}
ausgew\"ahlt. Im n\"achsten Dialog (Abbildung \ref{img:new_src_properties})
wird ein Dateiname eingegeben und als Template \cmd{Default C source template}
ausgew\"ahlt. \cmd{Finish} legt die neue Datei an und \"offnet diese im Editor
bereich.

Nun wird die Applikation implementiert. Danach sollte sicher gestellt werden,
dass \cmd{Project}, \cmd{Build Automatically} gesetzt ist und die Datei via,
\cmd{File}, \cmd{Save} abgespeichert wird. Werden im \cmd{Problems} Tab
Fehler angezeigt, so m\"u\ss en diese behoben werden.

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_new_src_file.png}
\caption{Neues Source File anlegen}
\label{img:new_src}
\end{figure}

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_new_hallo_c.png}
\caption{Source File Eigenschaften}
\label{img:new_src_properties}
\end{figure}

\paragraph{Build Einstellungen}

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_c_build_props.png}
\caption{Build Einstellungen}
\label{img:build_properties}
\end{figure}

Unter \cmd{Project}, \cmd{Properties} erscheint ein Dialog in dem alle
projektspezifischen Einstellungen vorgenommen werden (Abbildung
\ref{img:build_properties}. Im Unterpunkt \cmd{C/C++ Build}, \cmd{Settings}
werden die Einstellungen f\"ur den Compiler, Linker und Assembler vorgenommen.

\paragraph{Projekt ausf\"uhren}

Eclipse bietet verschiedene M\"oglichkeiten die eigene Applikation aus zu
f\"uhren. Zum Beispiel lokal, in einem Debugger oder auf dem Remote Target. Die
verf\"ugbaren Ausf\"uhrungsumgebungen werden von den installierten Plugins
zur Verf\"ugung gestellt. Zun\"achst legen wir eine Umgebung an um das oben
beschriebene Beispiel lokal aus zu f\"uhren.

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_select_run_config.png}
\caption{neue Ausf\"uhrungsumgebung ausw\"ahlen}
\label{img:new_run_config}
\end{figure}

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_run_config.png}
\caption{Ausf\"uhrungsumgebung definieren}
\label{img:run_config_properties}
\end{figure}

Hierzu w\"ahlt man \cmd{Run}, \cmd{Run configurations\dots} (Abbildung
\ref{img:new_run_config}). Es \"offnet sich ein Dialog, in dem eine neue
Ausf\"uhrungsumgebung angelegt werden kann (Abbildung
\ref{img:run_config_properties}). Mit Doppelklick auf \cmd{C/C++ Local
Application} wird eine neue Konfiguration erzeugt. Unter \cmd{Search
Project\dots} werden alle Binaries des darueber selektierten Projekts
aufgelistet. Es wird das aus zu f\"uhrende Binary ausgew\"ahlt und mit \cmd{OK}
best\"atigt. Ein weiterer Klick auf \cmd{Run} f\"uhrt das Programm aus. Die
Ausgaben sind im unteren Bereich der Entwicklungsumgebung im \cmd{Console} Tab
zu sehen.

Zuk\"unftig kann die Ausf\"uhrung auch mit dem Button \cmd{Run} (gr\"un
ausgef\"ullter Kreis mit wei\ss em Dreiek) in der Buttonleiste oben in der
Entwicklungsumgebung gestartet werden.

\paragraph{Debuggen}

\begin{figure}
\centering
\includegraphics[width=\textwidth]{images/eclipse_debug.png}
\caption{Eclipse Debug Perspektive}
\label{img:run_config_properties}
\end{figure}

Debugging der aktuellen Ausf\"uhrungskonfiguration wird mit einem Klick auf den
gr\"unen K\"afer in der Buttonleiste gestartet. Sollte eine Meldung aufpoppen ob
in die Debug Perspektive gewechselt werden soll, so wird diese mit \cmd{Yes}
best\"atigt. Es wird in die Debug Perspektive gewechselt (Abbildung
\ref{img:eclipse_debug}) welche in folgende Bereiche eingeteilt ist:

\begin{description}
\item[Task Viewer (orange)] Alle am Debugging beteiligten Prozesse und Threads
werden hier aufgelistet. Am oberen Rand befinden sich Buttons um durch die
Applikation zu springen.
\item[Variable Viewer (blau)] Hier werden die im aktuellen Kontext verf\"ugbaren
Variablen und derren Werte gelistet.
\item[Source Viewer (gr\"un)] Mittels Doppelklick am linken Rand k\"onnen
Breakpoints gesetzt werden. L\"auft der Debugger in einen Breakpoint, wird die
entsprechende Zeile farbig hinterlegt.
\item[Console (lila)] Ausgaben der Applikation
\end{description}

\paragraph{Profiling}

F\"ur Profiling wird wieder die C/C++ Perspektive ausgew\"ahlt. F\"ur Profiling
mit Valgrind wird unter \cmd{Run}, \cmd{Profile Configurations\dots} per
Doppelklick auf \cmd{Profile With Valgrind} eine neue Profiling Konfiguration
erstellt. F\"ur jede Konfiguration muss ein eindeutiger Name vergeben werden.

Im Tab \cmd{Main} wird das aktuelle Projekt und die zu profilende Applikation
ausgew\"ahlt. Im Tab \cmd{Valgrind Options} wird das Tool (z.B. memcheck)
ausgew\"ahlt und dessen Optionen eingestellt (z.B. leak resolution: high).

Das Tool memcheck dedektiert memory leaks (Abbildung \ref{img:valgrind},
massif \ref{img:massif} analysiert den heap Speicher.

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_memcheck.png}
\caption{Profiling mit dem valgrind Tool memcheck}
\label{img:valgrind}
\end{figure}

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_massif.png}
\caption{Profiling mit dem valgrind Tool massif}
\label{img:massif}
\end{figure}

\paragraph{Versionsverwaltung mit egit}

Um f\"ur das Projekt ein lokales git Repository an zu legen mit der rechten
Maustaste auf das Wurzelverzeichnis des Projekts und w\"ahlt \cmd{Team},
\cmd{Share Project\dots}. Im darauf folgenden Dialog wird \cmd{Git} selektiert
und mit \cmd{Next} best\"atigt. Im n\"achsten Dialog wird \cmd{Create a new Git
repository for this project} ausgew\"ahlt und mit \cmd{Finish} best\"atigt.

Als n\"achstes werden alle Dateien, welche in das git Repository commited werden
sollen mit Rechtsklick, \cmd{Team}, \cmd{Add} getracked (Abbildung
\ref{img:git_track}).

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_egit.png}
\caption{Eclipse egit Plugin}
\label{img:git_track}
\end{figure}

Nun werden die neuen Dateien oder \"Anderungen in das git Repository commited.
Hierzu wird im Project Explorer mit der rechten Maustaste auf das Projekt
geklickt und \cmd{Team}, \cmd{Commit} ausgew\"ahlt. Im commit Dialog wird ein
Commit Kommentar und Author eingetrage (Abbildung \ref{img:git_commit}).

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_egit_commit.png}
\caption{Eclipse egit Plugin - commit Dialog}
\label{img:git_commit}
\end{figure}

Jetzt wird ein neues Feature implementiert, welches wieder commited werden soll.
Hierzu wird nachdem die \"Anderungen durchgef\"uhrt wurden auf \cmd{Team},
\cmd{Commit} geklickt. Und im folgenden Dialog ein entsprechender Commit
Kommentar verfasst.

Mit einem Rechtsklick auf das Projekt im Project Explorer, \cmd{Team}, \cmd{Show
in Resource History}, wird ein History Tab (Abbildung \ref{img:git_history})
eingeblendet.

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_egit_history.png}
\caption{Eclipse egit Plugin - Project History}
\label{img:git_history}
\end{figure}

Wird in der History ein Commit selektiert sieht man rechts, welche Dateien durch
den Commit modifiziert wurden. Ein Doppelklick auf eine Datei \"offnet eine
Vergleichsansicht der Datei (Abbildung \ref{img:git_diff}). Links ist die Datei
vor dem Commit zu sehen, rechts die Datei nach dem Commit.

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_egit_diff.png}
\caption{Eclipse egit Plugin - Compare View}
\label{img:git_diff}
\end{figure}

Um die \"Anderungen am lokalen Git repository in ein remote Repository zu pushen
w\"ahlt man nach einem Rechtsklick auf das Projekt, \cmd{Team}, \cmd{Push
to\dots}. Im darauf folgenden Dialog (Abbildung \ref{img:eclipse_git_push.png})
werden die Informationen zum Remote Repository eingetragen.

\begin{figure}
\centering
\includegraphics[width=0.8\textwidth]{images/eclipse_egit_push.png}
\caption{Eclipse egit Plugin - Compare View}
\label{img:git_diff}
\end{figure}

Analog zu push funktioniert der \cmd{Fetch From\dots} Dialog um von einem Remote
Repository \"Anderungen in den lokalen Tree zu mergen.

\end{document}
