Programmiertools

Einige Tools und Prozesse sind unabhängig von der Programmiersprache wichtig und empfehlenswert für alle Programmierprojekte. Die hier angeführten Werkzeuge und Techniken sind nur exemplarisch, dafür können und sollten sie in jedem Projekt verwendet werden sollten.

Texteditor - GNU Emacs

Ein Texteditor ist eines der grundlegendsten Werkzeuge eines Programmierers. Die Entscheidung, ob für unterschiedliche Sprachen jeweils spezialisierte Editoren verwendet werden sollen bzw. ein möglichst mit allen Sprachen zurechtkommender Editor verwendet wird, sei jedem selbst überlassen. Wählt man letztere Alternative, so ist besondere Sorgfalt bei der Entscheidung angebracht. Im Folgenden schildere ich einige Funktionen des Editors meiner Wahl - GNU Emacs. Die Schilderungen dienen als Follow-up eines Vortrages, in welchem ich im Zuge der Grazer Linuxtage 2011 ein ausgewähltes Subset an Features des Editors vorgestellt habe. Das Thema des Vortrags war Emacs als IDE, wobei besonders auf Webentwicklung inklusive Python und Django eingegangen wurde. Dazu wurden 4 hilfreiche Pakete vorgestellt, welche hier kurz erklärt werden.

Gnuserv und Gnuclient

Beschreibung

Ermöglichen einen schnellen Start des Editors, wenn Emacs als Serverprozess läuft.

Installation und Konfiguration

Falls nicht ohnehin in der verwendeten Version von Emacs vorhanden, können die relevanten Pakete mittels

sudo aptitude install gnuserv

installiert werden. Danach ist ein aktivieren des Servermodus in .emacs erforderlich

;; Start GNUServe process when starting up.  This lets us send new files
;; to previously spawned emacs process.
(load "gnuserv-compat")
(load-library "gnuserv")
(gnuserv-start)

Um Emacs danach automatisch nur dann als Client zu starten, wenn bereits ein Server läuft, hilft folgendes Mini-Script

#!/bin/bash

RUNNING=`lsof /usr/bin/emacs | grep $USER`

if [ -z "$RUNNING" ]; then
    echo "starting emacs server"
    /usr/bin/emacs $* &
else
    echo "starting emacs client"
    /usr/bin/gnuclient $* &
fi

Autocomplete

Beschreibung

Ermöglicht automatische Vervollständigung von Code, die auch auf noch nicht in der Datei vorhandene Schlüsselwörter etc. anwendbar ist.

Installation und Konfiguration

Da das Paket sehr aktiv entwickelt wird, empfiehlt es sich, es nicht aus dem Paketmanager zu installieren, sondern direkt von der Projekthomepage herunterzuladen: http://cx4a.org/software/auto-complete/. Informationen zur Konfiguration sind in den Hilfedateien des Download-Archivs vorhanden. Weitere Informationen und Tips sowie ein Vergleich zu Alternativen findet sich auf http://www.emacswiki.org/emacs/AutoComplete.

Yasnipped

Beschreibung

Yasnipped - yet another snippet extension for Emacs. Hervorragendes Snippetsystem, welches viel Zeit und Tipparbeit erspart.

Installation und Konfiguration

Die im Paketmanager vorhandene Version ist in gut verwendbarem Zustand, also reicht

sudo aptitude install yasnipped

Erstellen eigener Snippets

Um neben den im Paket vorhandenen auch eigene Snippets definieren zu können, muss deren Verzeichnis mittels yas/load-directory geladen werden. Speichert man eigene Snippets zum Beispiel in ~/.yasnippet, so ist .emacs wie folgt zu editieren

;; yasnippet
(setq yas/root-directory (cons yas/root-directory '("~/.yasnippet")))
(mapc 'yas/load-directory yas/root-directory)

Möchte man ein neues Snippet für das HTML input Element erstellen, so ist dieses innerhalb des mit yas/load-directory geladenen Verzeichnisses unter text-mode/html-mode/input zu speichern. Eine tolle Referenz für das Erstellen von neuen Snippets sind die mit yasnippet mitgelieferten Beispiele. Deren Speicherort ist mit

dpkg -L yasnippet | grep snippets

einfach zu ermitteln.

Ropemacs

Beschreibung

Rope ist eine Refactoring Bibliothek für Python, welche von unterschiedlichen Editoren verwendet werden kann. Rope ermöglicht unter anderem automatische Code-Vervollständigung via Code-Introspection. In Emacs kann Rope mittels Ropemacs verwendet werden.

Installation und Konfiguration

Leider ist Ropemacs erst in der Version 0.1 und daher noch nicht ausgereift - diese steht aber bereits als Debian Packet zur Verfügung.

sudo aptitude install python-ropemacs

Die notwendige Aktivierung erfolgt wieder in .emacs

;; enable pymacs and ropemacs
(require 'pymacs)
(pymacs-load "ropemacs" "rope-")

Shortcuts

Code-Vervollständigung wird mittels M-/ ausgelöst. Darüberhinaus bietet Ropemacs auch andere Shortcuts, wovon

C-c d

zeige den Docstring für das Element unter dem Cursor

C-c g

springe zur Definition des Elements unter dem Cursor

C-c f

durchsucht das gesamte Projekt nach dem Element unter dem Cursor, wobei Strings, Docstrings und Kommentare ignoriert werden

die wichtigsten sind.

Texteditor - Vi(m)

Aufgrund seiner ebenfalls großen Beliebtheit ist auch vi (bzw. die verbesserte Version vim) hier kurz erwähnt. Dieser Editor verfügt über zwei grundsätzlich getrennte Modi - den Eingabemodus und den Kommandomodus. Beim Start des Editors befindet man sich in letzterem. Möchte man vom später vom Eingabemodus in den Kommandomodus wechseln, reicht ein Druck auf Esc.

Vi ist auch deshalb wichtig, weil man viele Programme in KDE so konfigurieren kann, dass sie ein Subset der Befehle von vi verwenden (dazu zählen kwrite, kate, kdevelop und kile). Der vi input mode kann in diesem Programmen mit der Tastenkombination [Ctrl]+[Meta]+v aktiviert bzw. deaktiviert werden. Mehr Informationen zu diesem Thema findet man auf http://kate-editor.org/kate-vi-mode/.

Umgekehrt kann man den Eingabemodus mit i, I, a, A, r, R starten.

i/ I

einfügen (insert) vor dem Cursor/ am Anfang der Zeile

a/ A

einfügen (append) nach dem Cursor/ am Ende der Zeile

r/ R

ersetze (replace) ein/ mehrere Zeichen

Dateien werden mit :w, :wq, :r gespeichert

:w <filename>

schreiben des aktuellen Buffers in die angegebene Datei (oder in die aktuelle Datei, falls kein Name gegeben ist)

:wq

speichern der aktuellen Datei und verlassen von vi

:w >> <filename>

hänge den aktuellen Buffer ans Ende der angegebenen Datei

:r <filename>

füge den Inhalt der gegeben Datei hinter der aktuellen Zeile ein

:r !<program>

füge die Ausgabe des angegebenen Programms hinter der aktuellen Zeile ein

Die Befehle zum Ausschneiden und Einfügen sind x, X, D, dd, dw, yy, p, P.

x/ X

schneidet das Zeichen unter dem/ links vom Cursor aus

D

schneidet den Rest der Zeile (ab dem Cursor) aus

dd

schneidet die aktuelle Zeile aus

dw

schneidet den Rest des aktuellen Wortes aus

yy

kopiert die aktuelle Zeile

p/ P

fügt den Inhalt der Zwischenablage vor/ nach dem Cursor ein (paste)

Der Cursor kann im Kommandomodus neben den Cursortasten mit w, W, (, ), [n]G, G, H, M, L bewegt werden.

w/ W

gehe zum nächsten /nächsten mit Leerzeichen getrennten Wort

(/ )

gehe zum letzten/ nächsten Satz

[n]G/ G

gehe zum Anfang der [n]-ten/ letzten Zeile

H/ M/ L

gehe an den Anfang der obersten/ mittleren/ untersten Zeile in der aktuellen Bildschirmansicht

Zum Suchen und Ersetzen verwendet man /, ?, n, :s

/

suche ab dem Cursor vorwärts

?

suche ab dem Cursor rückwärts

n

geh zum nächsten Suchergebnis

:s/pattern/string/flags

ersetze pattern (ein regulärer Ausdruck) durch string

mögliche flags sind zum Beispiel g (global, in der aktuellen Zeile), c (vor dem Ersetzen fragen)

Sonstige Befehle

J

verschiebe die nächste Zeile ans Ende der aktuellen Zeile (dabei wird bei Bedarf ein Leerzeichen eingefügt)

.

wiederhole die letze Veränderung durch den Texteingabemodus

u

(undo) mache die letzte Änderung rückgängig

Versionskontrolle

Eines der häufigsten Probleme von Entwicklern, ganz gleich ob es sich um eine einzelne Person oder ein ganzes Team handelt ist, dass Fehler und Bugs nicht immer sofort sichtbar werden. Will man später herausfinden, welche Änderung einen Fehler hervorgerufen hat, braucht man Zugriff auf alle Änderungsschritte in der Vergangenheit. Genau diese Möglichkeit bietet Software zur Versionskontrolle (generell als Version-Control System oder VCS bekannt). Bei der Zusammenarbeit in einem Team werden VCS Systeme natürlich noch viel wichtiger. Es gibt zahllose gute System zur Verwaltung von Sourcecode. Drei der besonders gängigen und qualitativ hochwertigen Open Source VCS sind Mercurial, Git und Subversion (SVN). Die ersten beiden sind verteilte VCS, welche ihre Vorteile besonders dann zeigen, wenn Teams eine gewisse Größe übersteigen, ohne aber Probleme oder Schwierigkeiten für einzelne Entwickler zu machen. Ein weiterer entscheidender Vorteil von verteilten VCS ist, dass eine Verbindung zum Internet nicht notwendig ist, um Versionskontrolle zu verwenden.

Mercurial

Im Folgenden stelle ich ganz kurz Mercurial (Mercury ist englisch für Quecksilber, dessen chemisches Symbol HG ist) vor, weil es besonders für Anfänger einfach zu verwenden ist. Zuerst muss es installiert werden.

sudo aptitude install mercurial

Daraufhin empfiehlt es sich, eine minimale Konfigurationsdatei (~/.hgrc) anzulegen und darin seinen Benutzernamen darin einzutragen.

cat >> ~/.hgrc << EOF
[ui]
username = Gerald Senarclens de Grancy

[extensions]
fetch =
EOF

Möchte man für ein bereits existierendes Projekt, welches aus lediglich einer Datei hello.py besteht, Mercurial verwenden, so genügt es

• das Projekt zu initialisieren,
• die Datei der Versionierung hinzuzufügen und
• das Hinzufügen zu bestätigen.

Die dafür notwendigen Schritte im Verzeichnis des Projektes sind.

hg init
hg add hello.py
hg commit -m "initial commit"

Verändert man daraufhin den Inhalt von hello.py indem zum Beispiel ein Kommentar hinzugefügt wird, so müssen die Änderungen auch mit Mercurial bestätigt werden, um zu diesem neuen Zustand zurückkehren zu können.

hg commit -m "added comment"

Die Option -m ist dabei nicht zwingend nötig, sie ermöglicht lediglich, einen Kommentar zu den Änderungen direkt auf der Kommandozeile einzugeben. Falls sie weggelassen wird, so startet der Standard-Texteditor und der Kommentar zur Änderung muss dort eingegeben werden. Alle bisherigen Versionen können über den Log von Mercurial eingesehen werden.

hg log

Will man schließlich zur ersten Version der Datei (Version 0; im Log ist die Version die Zahl vor dem Doppelpunkt im Changeset) zurückkehren, genügt ein simples revert.

hg revert -r 0 hello.py

Es ist ebenfalls möglich, die Unterschiede zwischen verschiedenen Revisionen anzuzeigen oder auf eine neuere Version zu "reverten".

hg diff -r 0 -r 1 hello.py
hg revert -r 1 hello.py

Ausführliche englische Dokumentation, gute Einsteigertutorials und sogar ein ganzes Buch zur Benutzung gibt es auf der Homepage von Mercurial. Die Verwendung von GUI Programmen kann einem das Leben auch erleichtern

sudo aptitude install tortoisehg

Git

Git setzt sich vor allem im Open Source Bereich immer mehr gegen alle anderen Versionskontrollsysteme durch. Es kann von git-scm.com heruntergeladen werden. Dort findet sich auch die Dokumentation und das Buch Pro Git. Die Installation unter Linux erfolgt via

sudo aptitude install git git-gui

Die folgenden Befehle reichen für eine minimale Konfiguration (statt dem Editor jed kann natürlich auch jeder andere Editor gewählt werden)

git config --global user.name "${YOUR_NAME}"
git config --global user.email "${YOUR_EMAIL_ADDRESS}"
git config --global color.ui auto
git config --global core.editor jed

Die eben erstellte Konfiguration befindet sich in ~/.gitconfig und kann mittels

git config --global -e

angesehen bzw. editiert werden. Um eine optimale Integration in die Bash Shell zu aktivieren, sind folgende Einträge in .profile vor dem inkludieren der .bashrc zu ergänzen

## GIT #########################
# these need to be set before PS1
export GIT_PS1_SHOWDIRTYSTATE=1
export GIT_PS1_SHOWSTASHSTATE=1
export GIT_PS1_SHOWUNTRACKEDFILES=1
export GIT_PS1_SHOWUPSTREAM="auto verbose"

In der .bashrc muss dann noch der Prompt angepasst werden (die genaue Konfiguration steht jedem User frei - der für Git relevante Teil is $(__git_ps1 "git:%s")

export PS1='\@ \033[1m[\u@\h] $(__git_ps1 "git:%s")\033[0m\n\w >'

Die dadurch aufgerufene Funktion fügt dem Prompt den Text "git:" gefolgt von dem Namen der aktuellen Branch hinzu, sobald man sich innerhalb eines git repositories befindet. Durch die Einträge in .profile werden hinter dem Namen der Branch gegebenenfalls folgende Zeichen eingefügt

*

Veränderungen, die noch nicht im Index sind

+

Veränderungen, die im Index sind

$

Mindestens ein Stash ist vorhanden

%

Es existieren unbekannte (untracked) Dateien

u±X

Upstream ist um X commits vor/ hinter dem lokalen Repository

Es ist möglich, seinen Code in einem online Repository zu speichern und ihn in der Folge einfach gemeinsam in einem Team zu verwenden oder auch nur zwischen verschiedenen Computern aktuell zu halten - ohne sich mit der Serverkonfiguration auseinander setzen zu müssen. Ein bekanntes derartiges Hostingservice für Mercurial und GIT Repositories ist ist Bitbucket.

Bitbucket

Für Einzelpersonen oder kleinere Firmen zahlt es sich in der Regel nicht aus, einen eigenen Server zur Versionskontrolle zu betreiben. Will man einen Account auf einem der bestehenden Services anlegen, ist jedoch ein wenig Konfiguration notwendig. Zur Verwendung von ssh muss zum Beispiel ein Schlüsselpaar (public + private) angelegt werden:

ssh-keygen -t rsa

Bei der Aufforderung, ein Passwort einzugeben, empfehle ich, unbedingt ein mind. 8 Zeichen langes sicheres Passwort. Mit der erstellten privaten Schlüsseldatei ist schließlich je nach Verwendung der öffentlichen Datei Vollzugriff auf Rechner möglich. Nachdem das Schlüsselpaar erstellt ist, kann der öffentliche Schlüssel mit

cat ~/.ssh/id_rsa.pub

im Terminal angezeigt werden. Danach markiert und kopiert man den gesamten Schlüssel (ein solcher Schlüssel könnte (gekürzt) wie folgt aussehen: ssh-rsa AAAAB3NzaC1yc2E...8COHdD gerald@panoramix). In der Account-Verwaltung auf Bitbucket gibt es einen Punkt "SSH keys" bei unter dem der neu erstellte Key eingefügt werden kann. Wichtig: NIEMALS DEN PRIVATEN KEY WEITERGEBEN! Der öffentliche Teil (Dateiendung .pub) kann jedoch getrost verbreitet werden.

Erst das Vorhandensein eines solchen Schlüssels erlaubt es, mit privaten Repositories zu kommunizieren (sofern die Userrechte passend vergeben sind). Selbst für öffentliche Repos muss ein Schlüssel vorhanden sein.

Einer der vielen Vorteile der Verwendung von SSH liegt darin, nicht bei jeder Serverkommunikation (pull/ push oder dgl.) seine Benutzerdaten angeben zu müssen. Damit das funktioniert, kann in einer laufenden Benutzer-Session der private SSH-Schlüssel einem Authentifizierungs-Agenten übergeben werden. Unter *Ubuntu reicht es, nach dem einloggen

ssh-add

zu tippen und das Passwort des privaten Schlüssels einzugeben. Danach sind bis zum Ausloggen Verbindungen mit Hilfe des Schlüssels möglich, ohne das Passwort erneut eingeben zu müssen. Diese erhöhten Rechte machen es aber noch wichtiger als sonst, seinen Computer zu sperren, wenn man ihn nicht verwendet.

Build Tools

Um Sourcecode von Sprachen wie C, C++ oder Java in Maschinencode oder Bytecode zu übersetzen, muss dieser kompiliert werden. Da dies aber bei vorhandensein von vielen Dateien kompliziert ist und nicht bei jeder Änderung alle Dateien neu kompiliert werden müssen, empfiehlt sich die Verwendung von Build Tools. Die klassischen Tools sind GNU Make für C und C++ sowie Apache Ant für Java. Da das Erstellen von Makefiles aber alles andere als trivial ist und besonders bei Plattformunabhängigkeit Schwierigkeiten macht, gibt es eine Reihe von Generatoren für Makefiles. Derzeit besonders weit verbreitet und von mir empfohlen ist CMake. Die Konfiguration der zu kompilierenden Software erfolgt dabei in CMakeLists.txt Dateien. Das Übersetzen von Quellcode unter Verwendung von CMake benötigt zwei Schritte. Zuerst wird das Makefile generiert und danach wird dieses zum Kompilieren der Sourcen verwendet. Die übersetzten Dateien werden dabei in der Regel in einem eigenes Verzeichnis generiert, welches per Konvention build genannt wird. Ein typischer Kompiliervorgang von frisch heruntergeladenem Quelltext sieht dann in der Regel so aus

mkdir build  # erstelle Verzeichnis, in dem übersetzte Dateien erstellt werden
cd build     # gehe in dieses Verzeichnis
cmake ..     # generiere Makefile
make         # kompiliere Dateien

Etwas einfacher für Beginner, dafür aber weniger mächtig ist qmake. Dabei werden ${PROJECT}.pro Dateien zur Konfiguration verwendet. Bei einfacheren Projekten hat man dabei die Möglichkeit, die Konfiguration automatisch erstellen zu lassen. Dies geschieht mit

qmake -project

Danach kann das Projekt mittels

qmake        # generiere Makefile
make         # kompiliere Dateien

übersetzt werden.

Copyright © 2009-2023 Gerald Senarclens de Grancy
Das Anfertigen von Kopien, deren Verwendung und Verteilung sind erlaubt und erwünscht, solange dieses Copyrightstatement in allen Kopien angefügt bleibt.
Die vorliegende Dokumentation wurde ausschließlich in meiner Freizeit als Service für ehemalige Seminarteilnehmer erstellt. Daher wird sie lediglich so wie sie ist zur Verfügung gestellt, ohne jegliche vertragliche oder gesetzliche Gewährleistung und ohne den Anspruch auf Korrektheit oder für irgendeinen Zweck geeignet zu sein.

Haftungsausschluss: Da ich keinerlei Einfluss auf den Inhalt der Seiten, zu denen ich von meiner Homepage linke, habe, übernehme ich auch keinerlei Haftung für diese Seiten.