devel-environment: added description for eclipse and some basics, but still

incomplete...

Signed-off-by: Manuel Traut <manut@linutronix.de>

1 files changed, 334 insertions, 7 deletions

diff --git a/application-devel/devel-environment/handout_devel-environment_de.tex b/application-devel/devel-environment/handout_devel-environment_de.tex
index 64a858b..6e51dda 100644
--- a/application-devel/devel-environment/handout_devel-environment_de.tex
+++ b/application-devel/devel-environment/handout_devel-environment_de.tex
@@ -1,18 +1,77 @@
 \documentclass{lxarticle}
 \usepackage{german}
 \usepackage[utf8]{inputenc}
+\usepackage{lxheaders}
+\usepackage{lxextras}
 
 \begin{document}
 
 \section*{Entwicklungsumgebung}
 
-\subsection*{textbasierte Editoren (vim, emacs, ctags)}
+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
 
-blubb
+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.
 
-\subsection*{grafische Editoren (Kate, Eclipse)}
+In diesem Block wird auf die verschiedenen Komponenten einer
+Entwicklungsumgebung eingegangen und Eclipse als prominenter Vertretter der
+integrierten Entwicklungsumgebungen n\"ahers vorgestellt.
 
-\subsubsection*{Kate}
+\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}
+
+alt+x compile, ctrl-o jump to buffer, tab next error, return: jump to source
+line
 
 \subsubsection*{Eclipse}
 
@@ -58,7 +117,7 @@ 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 Montaviste DevRocket
+	\item Montavista DevRocket
 		(http://www.mvista.com/product\_detail\_devrocket.php)
 	\item SAP Netweaver (http://www.sap.com/platform/netweaver/index.epx)
 \end{itemize}
@@ -106,11 +165,50 @@ unterst\"utzung in folgenden Punkten:
 		\end{itemize}
 \end{itemize}
 
-Es wird nun am Beispiel einer simplen 'Hallo Welt' Applikation die grundlegende
-Eclipse Bedienung erlkl\"art.
+\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.
@@ -122,4 +220,233 @@ alle Projektdateien abgelegt.
 \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}