PC Games Hardware Sonderheft: Raspberry Pi. Das erweiterte Handbuch Raspberry Pi. Das erweiterte Handbuch (Vorschau)

www.pcgameshardware.de • www.pcghx.de
DAS HARDWARE-MAGAZIN FÜR PC-SPIELER
PC Games Hardware Guide präsentiert:
Raspberry Pi
Das erweiterte Handbuch
Der Mini-Computer für unter 40 Euro!
Alles zur Hard- und Software des Raspberry Pi!
Einstieg
Projekte
Coding
Lernen
Linux für Einsteiger
mit Praxis-
Beispielen
So wählen Sie das
ideale
Betriebssystem
Erste Schritte für
eigene
Programme
Klassische und
moderne
Programmiersprachen
Expertenwissen für Einsteiger und Fortgeschrittene
PCGH GUIDE 02/14
€ 9,99
Österreich 11,- Euro
Schweiz 17,- sfr
Benelux 11,50 Euro

ALLE PREMIUM-BOOKAZINES IM ÜBERBLIcK
NEU
NEU
NEU
Bequem online bestellen:
shop.computec.de/edition
Jetzt auch für
das iPad in der
Computec-Kiosk-App

www.pcgameshardware.de • www.pcghx.de
Intro
DAS HARDWARE-MAGAZIN FÜR PC-SPIELER
Guide Raspberry Pi
Das erweiterte Handbuch
Willkommen!
Ein Unternehmen der MARQUARD MEDIA INTERNATIONAL AG
Verleger Jürg Marquard
Verlag
Geschäftsführer
Chefredakteur PCGH GUIDE (V.i.S.d.P.)
Redakteur für besondere Aufgaben PCGH GUIDE
Layoutkoordination PCGH GUIDE
Übersetzung, Layout, Lektorat
Chefredakteur PC Games Hardware
Product Manager
Computec Media GmbH
Dr.-Mack-Straße 83, 90762 Fürth
Telefon: +49 911 2872-100
Telefax: +49 911 2872-200
redaktion@pcgameshardware.de
www.pcgameshardware.de | www.pcghx.de
Rainer Rosenbusch, Ingo Griebl, Hans Ippisch
Christian Müller, verantwortlich für den redaktionellen Inhalt,
Adresse siehe Verlagsanschrift
Lars Craemer
Albert Kraus
MDV Textdienste, Harald Wagner, Christiane Scholz, Ina Hulm
Thilo Bayer (tb)
Daniel Waadt (dw)
Vertrieb, Abonnement
Marketing
Produktion
www.pcgameshardware.de
Werner Spachmüller (Ltg.),
Jeanette Haag
Martin Closmann (Ltg.), Jörg Gleichmar
Chefredakteur Online Thilo Bayer
Redaktion Andreas Link, Marco Albert, Frank Stöwer,
Carsten Spille, Marc Sauter,Raffael Vötter,
Stephan Wilke
Entwicklung Markus Wollny (Ltg.), René Giering, Aykut Arik, Tobias Hartlehnert
Webdesign Tony von Biedenfeld, Emanuel Popa
Anzeigen
CMS Media Services GmbH, Dr.-Mack-Straße 83, 90762 Fürth
Anzeigenleiter
Gunnar Obermeier, verantwortlich für den Anzeigenteil. Adresse siehe Verlagsanschrift
Anzeigenberatung Print:
Bernhard Nusser: Tel.: 0911-2872-254; bernhard.nusser@computec.de
René Behme: Tel.: 0911-2872-152; rene.behme@computec.de
Alto Mair: Tel.: 0911-2872-144; alto.mair@computec.de
Anne Müller: Tel.: 0911-2872-251; anne.mueller@computec.de
Anzeigenberatung Online:
freeXmedia GmbH
Ein Unternehmen der freenet Group
Deelbögenkamp 4c, 22297 Hamburg
Tel.: +49 (0) 40-513 06-650
Fax. +49 (0) 40-513 06-960
Mail: werbung@freeXmedia.de
www.freeXmedia.de
Anzeigendisposition: anzeigen@computec.de
Datenübertragung: via E-Mail: anzeigen@computec.de
Es gelten die Mediadaten Nr. 27 vom 01.01.2014
Abonnement – http://abo.pcgameshardware.de
Die Abwicklung (Rechnungsstellung, Zahlungsabwicklung und Versand) erfolgt über unser Partner unternehmen DPV Direct GmbH:
Post-Adresse: Leserservice Computec, 20080 Hamburg, Deutschland
Ansprechpartner für Reklamationen ist Ihr Computec-Team unter:
Deutschland: E-Mail: computec@dpv.de, Tel.: 0911-99399098, Fax: 01805-8618002*
Support: Montag 07:00–20:00 Uhr, Dienstag–Freitag 07:30–20:00 Uhr, Samstag 09:00–14:00 Uhr
* (14 Cent/Min. aus dem dt. Festnetz, max. 42 Cent/Min. aus dem dt. Mobilfunk)
Österreich, Schweiz und weitere Länder: E-Mail: computec@dpv.de,
Tel: +49-911-99399098, Fax: +49-1805-8618002
Support: Montag 07:00–20:00 Uhr, Dienstag–Freitag 07:30–20:00 Uhr, Samstag 09:00–14:00 Uhr
Abonnementpreis für 12 Ausgaben: PCGH Magazin € 47,88 (€ 51,60 Österreich, € 59,88 Ausland), PCGH DVD € 60,- (€ 67,20
Österreich, € 72,- Ausland)
Einzelversand/Nachbestellung
Online: www.pcgh.de/go/shop, E-Mail: computec@dpv.de, Tel.: 0911-99399098 , Fax: 01805-8618002*
* (0,14 €/Min. aus dem dt. Festnetz, max. 0,42 €/Min. aus dem dt. Mobilfunk)
Druck: RR Donnelley Europe, ul. Obroncow Modlina 11, 30-733 Krakau, Polen
COMPUTEC MEDIA ist nicht verantwortlich für die inhaltliche Richtigkeit der Anzeigen und übernimmt keinerlei Verantwortung für in
Anzeigen dargestellte Produkte und Dienstleistungen. Die Veröffentlichung von Anzeigen setzt nicht die Billigung der angebotenen
Produkte und Service-Leistungen durch COMPUTEC MEDIA voraus. Sollten Sie Beschwerden zu einem unserer Anzeigenkunden, seinen
Produkten oder Dienstleistungen haben, möchten wir Sie bitten, uns dies schriftlich mitzuteilen. Schreiben Sie unter Angabe des
Magazins, in dem die Anzeige erschienen ist, inkl. der Ausgabe und der Seitennummer an: CMS MEDIA SERVICES GmbH, Annett
Heinze, Anschrift siehe oben.
Einsendungen, Manuskripte und Programme:
Mit der Einsendung von Manuskripten jeder Art gibt der Verfasser die Zustimmung zur Veröffentlichung in den von der Verlagsgruppe
herausgegebenen Publikationen. Urheberrecht: Alle in PC Games Hardware veröffentlichten Beiträge bzw. Datenträger sind
urheberrechtlich geschützt. Jegliche Reproduktion oder Nutzung bedarf der vorherigen, ausdrücklichen und schriftlichen
Genehmigung des Verlags.
Lizenz
Artikel in dieser Ausgabe sind übersetzt oder reproduziert aus „Raspberry Pi: Beyond the Manual“ und
unterliegen dem Copyright von Future plc, UK 2012. Inhalte wurden als Lizenz erworben. Alle Rechte vorbehalten.
„Bookazines and Masterclass series“ ist ein eingetragenes Warenzeichen von Future Publishing Limited. Weitere
Informationen über diese und andere Zeitschriften der Future plc Gruppe:
http://www.futureplc.com
Licence
Articles in this issue are translated or reproduced from „Raspberry Pi: The Essential Manual“ and are the
copyright of or licensed to Future Publishing Limited, a Future plc group company, UK 2012. Used under licence.
All rights reserved. „Bookazines and Masterclass series“ is the trademark of or licensed to Future Publishing
Limited, a Future plc group company. Used under licence.
http://www.futureplc.com
Der Raspberry Pi ist ein kompletter Mini-Computer und
darüber hinaus auch noch sehr günstig. Wer sich nicht
von dem Betriebssystem auf Linux-Basis und der
scheinbaren Basteloptik abschrecken lässt, wird mit
dem Raspberry Pi viel Spaß haben. Der Raspberry Pi ist nämlich
nicht nur ein mächtiges Werkzeug für versierte Schrauber,
sondern dank der einfachen Struktur des Betriebssystems und
den unzähligen Foren mit projektbezogenen Hilfestellungen auch
für Anfänger perfekt geeignet. Wer also ein neues und zudem
auch günstiges Hobby sucht, kann mit dem Raspberry Pi für sich
eine völlig neue Technik-Welt entdecken.
In unserem Handbuch gehen wir auf die Geschichte des
Raspberry Pi ein und erklären Ihnen Schritt für Schritt, wie Sie den
kleinen Computer an Ihre Bedürfnisse anpassen. Auch
Programmierer (und solche die es werden wollen) finden bei uns
praktische Tipps und viele Ansätze, auf deren Basis Sie zukünftig
sogar eigene Projekte entwickeln können.
Wussten Sie übrigens, dass der Raspberry Pi bereits über die
Weltmeere schippert, sogar auf den Spuren von Captain Kirk
wandert und den Weltall erobert hat? Dies sind nur zwei Beispiele,
für die praktisch unbegrenzten Einsatzmöglichkeiten des
Rechenzwergs.
MARQUARD MEDIA INTERNATIONAL AG
Deutschsprachige Titel: SFT, WIDESCREEN, PC GAMES, PC GAMES MMORE, PC GAMES HARDWARE, N-ZONE,
GAMES & MORE, BUFFED, GAMES AKTUELL, PLAY 3, PLAYBLU, XBG GAMES
Internationale Zeitschriften: Ungarn: JOY, SHAPE, ÉVA, IN STYLE, PLAYBOY, CKM, MEN’S HEALTH
Polen: COSMOPOLITAN, JOY, SHAPE, HOT, PLAYBOY, CKM, VOYAGE, HARPER’S BAZAAR
3

Inhalt
Grundlagen
Was ist Linux?.......................................................................................8
E wie Eben.........................................................................................................16
Ursprünge: Wie der Pi entstand........................................................20
Richtig verbinden: Peripherie...............................................................22
Fehlerbehebung: Booten........................................................................26
Befehlszeile: Erste Schritte...................................................................28
Das Dateisystem: Speichergeräte..................................................32
Pakete: Software sicher im Griff......................................................34
Add-ons für den Raspberry Pi.............................................................36
Projekte
Betriebssysteme für den Raspberry Pi.......................................42
Betriebssystem: Raspbian....................................................................48
Zünde den Raspberry-Booster...........................................................54
Arch Linux...........................................................................................................62
System: Eigene Distribution.................................................................66
XBMC enthüllt.................................................................................................70
Auto-Backups per Bash-Skript............................................................74
dnsmasq: DNS servers...........................................................................78
Syslog: Loggen per E-Mail.....................................................................80
Desktop: Eigene Schreibtische.........................................................82
4

Inhalt
Coding
Generation CODE........................................................................................88
Raspberry Jams...........................................................................................92
Geany: Editor de luxe...............................................................................96
Code-Konzepte: Datentypen...........................................................100
Designkonzepte: Komplexe Typen.............................................102
Designkonzepte: Abstraktion.........................................................104
Designkonzepte: Dateien und Module...................................106
Python: So fangen Sie an.................................................................108
Designkonzepte: Eine IDE nutzen...............................................112
Designkonzepte: Ein Unix-Tool.......................................................114
Designkonzepte: Ein echter Klon................................................116
Designkonzepte: Klassenobjekte.............................................. 118
Designkonzepte: Module...................................................................120
Designkonzepte: Massenspeicher.............................................122
Designkonzepte: Datenorganisation........................................124
GUI-Code: Mit Clutter hantieren...................................................126
Python: Clutter-Animationen...........................................................130
Programmiersprachen
Andere Sprachen...........................................................................................136
Begeisterung für OpenEuphoria...................................................138
Ein kurzer Lehrgang in Go.................................................................142
Listig mit Lisp..............................................................................................146
C++: So geht’s...........................................................................................150
Fortan Fortran.............................................................................................154
Lua: Erste Schritte..................................................................................158
5

Grundlagen
6

Grundlagen
Grundlagen
Der Raspberry Pi setzt an sich eine gewisse
Kenntnis von Linux voraus, die Sie zum Teil
sicherlich nicht vorweisen können. Lesen Sie
sich daher in die Grundlagen rund um den Mini-
Computer ein und machen Sie sich mit dem
Betriebssystem vertraut.
Was ist Linux?....................................................................................................8
E wie Eben.........................................................................................................16
Ursprünge: Wie der Pi entstand........................................................20
Richtig verbinden: Peripherie...............................................................22
Fehlerbehebung: Booten........................................................................26
Befehlszeile: Erste Schritte...................................................................28
Das Dateisystem: Speichergeräte..................................................32
Pakete: Software sicher im Griff......................................................34
Add-ons für den Raspberry Pi.............................................................36
7

Grundlagen
Was ist
Linux?
Hier bekommen Sie eine erste Einführung
in das – wie seine Fans sagen –
beste Betriebssystem der Welt.
Was ist eigentlich Linux? Auf diese Frage bekommt man
unterschiedliche Antworten, je nachdem, wem man
sie stellt: Der Purist sagt, dass der Begriff einzig für
den Kernel steht, für den GNU-Verfechter ist Linux nur ein Teil von
GNU/Linux, und der Einsteiger denkt womöglich, es wäre lediglich
ein anderer Name für Ubuntu.
Je nachdem, aus welchem Blickwinkel man die Sache betrachtet,
trifft all das mehr oder minder zu. Ganz streng genommen
bezieht sich der Begriff Linux nur auf den Kernel
des Betriebssystems, während GNU/Linux das gesamte Betriebssystem
bezeichnet, das den Linux-Kernel zusammen
mit den GNU-Werkzeugen enthält – das Eine wäre nutzlos
ohne das Andere (oder eine der Alternativen).
Fügt man dem Betriebssystem noch eine Sammlung
von Anwendungsprogrammen hinzu sowie ein paar
Tools, um das Ganze zu verwalten, so hat man eine sogenannte
Distribution. Ubuntu ist beispielsweise eine
Distribution, ebenso wie das speziell für den Raspberry
Pi entwickelte Raspbian. Aber beide Programmpakete
sind ebenfalls immer noch Linux.
Die Einzelteile, aus denen das Betriebssystem zusammengesetzt
ist, sind sehr zahlreich, aber sie passen doch
alle zusammen und sind aufeinander abgestimmt. Auf den
folgenden Seiten erklären wir Ihnen die Funktion der wichtigsten
dieser Einzelteile. Die Informationen sind sowohl für
alle Desktop-Varianten von Linux als auch für die Raspberry-Pi-Distributionen
gültig.
Betriebssystem und Distribution
Man kann ein Betriebssystem als
diejenige Software definieren, die
es Anwendungen ermöglicht, auf
einer bestimmten Hardware zu
laufen. Betriebssysteme bestehen
aus mehreren überlappenden
Schichten. In der untersten Ebene
haben wir den Kernel, der mithilfe
von Treibern direkt mit der Hardware
interagiert. Andere Schichten
setzen auf dieser Basis auf – zum
Beispiel solche, die Eingabegeräte,
Audio- und Video-Ausgabe oder
Netzwerkverbindungen verwalten.
Sie brauchen nicht zwangsläufig
etwas über diese Dinge zu wissen.
Da Sie jedoch gerade dieses Handbuch
lesen, stehen die Chancen
gut, dass Sie sich auch für die Vorgänge
„da unten“ interessieren.
Darum versuchen wir, Ihnen einen
kleinen Überblick zu geben.
Eine Linux-Distribution ist
genau das, was der englische
Begriff „to distribute“ bedeutet:
das Verteilen eines linuxbasierten
Betriebssystems zusammen mit
weiterer Software. Anfangs handelte
es sich lediglich um die
Dateien, die das Betriebssystem
benötigt, zusammen mit einer
Methode, das Ganze auf einem
Computer zu installieren. Mit der
Zeit wurden die Distributionen um
Paketmanager, Update-Tools,
Oberflächen zur Konfiguration
und etliche andere Annehmlichkeiten
erweitert. Unter der Haube
sind jedoch alle Distributionen
nach wie vor Linux.
8

Grundlagen
Der Kernel
Das Kontrollzentrum des Linux-Betriebssystems.
Der Kernel ist das Herz des Systems. Er kommuniziert im
Namen der gesamten auf dem Computer installierten
Software mit dem Prozessor, dem Speicher und allen
anderen Geräten. In dieser Rolle ist der Kernel die am tiefsten
gelegene und gleichzeitig wichtigste Software-Schicht. Falls der
Kernel ein Problem hat, überträgt sich dieses auf die gesamte
Software auf dem Rechner.
Der Linux-Kernel ist monolithisch aufgebaut. Das bedeutet,
dass alle Kerndienste des Betriebssystems im Kernel
laufen. Die Alternative ist ein Micro-Kernel, der einen Großteil
der Arbeit auf externe Dienste auslagert und selber kaum
mehr macht, als die Aufgaben zu koordinieren.
Während ein reinrassiger monolithischer Kernel in den
Anfangstagen der Betriebssysteme gut funktionierte, ist das
Prinzip in Reinform heute nicht mehr praktikabel: Aufgrund
der riesigen Hardwarevielfalt wäre ein Kernel, der alle denkbaren
Kombinationen komplett abdeckt, viel zu groß. Deswegen
ist der Linux-Kernel von heute modular aufgebaut. Die
Kernfunktionen befinden sich in der Kernel-Datei (zu finden
in /boot als vmlinuz-version), während sich die optionalen
Treiber als separate Module im Verzeichnis /lib/modules
befinden.
Ziehen wir als Beispiel für den Speicherbedarf die Distribution
Ubuntu 12.10 heran: Während deren 64-Bit-Kernel nur
5 MB groß ist, belegen die zusätzlichen 3.700 Moduldateien
100 MB. Da auf jedem Computer nur ein Bruchteil dieser
Dateien benötigt wird, wäre es unsinnig, sie alle zusammen
mit dem Kernel zu laden. Stattdessen ermittelt der Kernel,
welche Module er benötigt. Diese werden geladen
und bilden daraufhin im Hauptspeicher einen Teil
des Kernels. Im Betrieb ist der Kernel somit noch
immer monolithisch, auch wenn er über Tausende Dateien
verteilt ist. So ist es dem System möglich, auf eine sich
verändernde Hardware zu reagieren. Wenn Sie beispielsweise
einen USB-Stick einstöpseln, lädt das usb-storage-Modul
zusammen mit dem Dateisystem-Modul, das Sie benötigen,
Beim Eigenbau eines Kernels steht Ihnen eine überwältigende Anzahl von
Optionen zur Verfügung, wobei die meisten mit der Hardwareunterstützung zu tun
haben. Zum Glück nehmen uns die Distributoren diese Arbeit ab, wenn wir möchten.
um den Stick mounten zu können. Wenn Sie einen 3G-Dongle
einstecken, werden die Treiber für das serielle Modem
geladen. Das ist der Grund, warum Sie so selten neue Treiber
installieren müssen, wenn Sie neue Hardware mit dem Computer
verbinden: Die meisten Treiber sind bereits vorhanden
und warten nur darauf, dass Sie ein passendes Gerät
an schließen. Computer, die auf einer spezifischen, sich nicht
verändernden Hardware laufen – wie etwa Server – nutzen
meist einen Kernel, der mit allen nötigen Treibern kompiliert
wurde. So kann das Nachladen von Modulen deaktiviert werden,
was die Sicherheit ein wenig erhöht.
Falls Sie Ihren eigenen Kernel kompilieren, gilt die Faustregel,
dass Sie alle Treiber für jene Hardware integrieren sollten,
die ständig im Gebrauch sein wird, wie etwa für Netzwerkschnittstellen
und Dateisysteme. Für alles andere greifen
Sie besser auf Module zurück.
Obwohl Linux eine extrem gute Hardwareunterstützung
bietet, fehlt mitunter ein passendes Kernel-Modul für ein
Gerät, insbesondere wenn der Code sehr neu ist oder aus
lizenzrechtlichen Gründen. Die darum fehlenden Treiber werden
meist als Drittanbieter-Module (bei Ubuntu als „restricted
drivers“) bezeichnet. Falls diese von Ihrer Distribution
unterstützt werden, lassen sie sich oft per Paketmanager installieren.
Andernfalls müssen sie ausgehend vom Quellcode
kompiliert werden, und zwar jedes Mal, wenn Sie Ihren Kernel
aktualisieren, denn die Treiber sind hierbei an den Kernel
gebunden, für den sie kompiliert wurden. Um den Aufwand
zu verringern, gibt es automatisierte Lösungen wie DKMS
(Dynamic Kernel Module Support), das bei einer Neuinstallation
des Kernels alle Drittanbieter-Module neu kompiliert.
Damit wird das Aktualisieren des Kernels fast genauso einfach
wie ein Update eines Anwendungsprogramms.
Kernel-Space und User-Space
Im Zusammenhang mit Kernels werden häufig die Begriffe
„Kernel-Space“ und „User-Space“ verwendet.
Beim Kernel-Space handelt es sich
um einen für den Kernel reservierten
Speicherbereich. Auf diesen haben
nur der Kernel selbst sowie seine
Module Zugriff, nicht aber Anwendungsprogramme.
Damit soll verhindert
werden, dass Amok laufende
Programme die Arbeit des Kernels
stören.
Dem gegenüber steht der User-
Space, der von jedem Programm
angesprochen werden kann, sofern es
die entsprechenden Berechtigungen
dazu besitzt. Diese Aufteilung trägt
viel zur Stabilität von Linux bei, da
dadurch kein Programm die Arbeit
des Kernels direkt beeinflussen und
dadurch Schaden anrichten kann,
selbst wenn es mit Root-Privilegien
ausgestattet ist.
9

Grundlagen
Die Startreihenfolge
Das mysteriöse Piepsen und Flackern beim Bootvorgang.
Wenn Sie den
Splash-Screen
wie im Text beschrieben
deaktivieren,
können
Sie die Abläufe
beim Booten des
Computers in
Gänze zusammen
mit dem
Status der startenden
Dienste
verfolgen.
Beim Systemstart springen die meisten Distributionen
direkt zu einem Splash-Screen, sodass nicht zu sehen ist,
was im Hintergrund abläuft. Dabei passiert schon eine
ganze Menge, bevor der Splash-Screen überhaupt auftaucht, und
dann im Hintergrund des Splash-Screens.
Zuerst startet das BIOS in der Hardware des Motherboards.
Es sieht sich nach einem bootbaren Gerät um, von
dem es Code laden kann.
Dieser befindet sich im Falle
eines Festplattenlaufwerks
mit klassischem DOS-Partitionssystem
im nur 512 Byte
großen Master Boot Record
(MBR). Davon sind 64 Byte
zur Speicherung der Partitionstabelle vorgesehen (diese kleine
Datenmenge ist der Grund, warum nur maximal vier primäre
Partitionen möglich sind). Die restlichen 448 Byte beinhalten
den Code für den Bootloader, im Falle von Linux meist
GRUB. 448 Byte erlauben natürlich keinen überbordenden
Funktionsumfang, weshalb dieser Code nichts weiter tut, als
den Bootloader von irgendwo anders auf der Festplatte zu
laden. Von wo genau, wird festgelegt, wenn der MBR auf die
Festplatte geschrieben wird.
Der Bootloader liest anschließend seine Konfigurationsdatei
ein, im Falle von GRUB /boot/grub2/grub.cfg. Darin ist
eine Liste von Boot-Optionen gespeichert. Diese wird je nach
Konfiguration entweder dem Nutzer angezeigt, oder es wird
„Falls Sie sehen möchten,
was passiert, können Sie den
Splash-Screen deaktivieren.“
sofort der als Standard markierte Eintrag gestartet. Zu diesem
Zeitpunkt ist Linux noch in keiner Weise in den Betrieb
des Rechners involviert, bis jetzt wurde nur Code des Bootloaders
ausgeführt. Der genannten Konfigurationsdatei entnimmt
der Bootloader nun die Informationen zu den Speicherorten
des Linux-Kernels und gegebenenfalls der
initramfs-Archivdatei (siehe unten) sowie bestimmte Einstellungen
wie etwa die Root-
Partition. Außerdem informiert
er sich, ob das Ganze
hinter einem Splash-Screen
versteckt werden soll. Falls
Sie sehen möchten, was von
jetzt an passiert, können Sie
den Splash-Screen bei den meisten Distributionen deaktivieren.
Drücken Sie hierzu die Taste E, um im GRUB-Menüeintrag
alle Quiet- und Splash-Parameter zu entfernen. Ein
Druck auf die Taste F10 führt zur Fortsetzung des Bootvorgangs.
Das initramfs-Archiv
Die meisten Distributionen benutzen eine initramfs-Datei.
Der Hauptgrund dafür ist, dass bestimmte Treiber zusammen
mit dem Kernel geladen werden müssen (etwa SATA-
Controller oder Dateisystem-Code). Würde man alle denkbaren
Optionen direkt in den Kernel integrieren, wäre dieser für
eine gewöhnliche Distribution unhandlich groß. Deshalb ist
alles in Form von Modulen hinterlegt, und diejenigen, die zum
Booten benötigt werden, sind in der initramfs integriert. Dies
ist eine Art von RAM-Disk, die vom Bootloader (mithilfe der
BIOS-Funktionen zum Lesen der Festplatte) geladen wird
und alle Dateien beinhaltet, die zum Mounten der Root-Partition
notwendig sind. Die Geräteerkennung des Kernels entscheidet
dabei, welche Dateien gebraucht werden. Anschließend
wird die Kontrolle an die eigentliche Festplatte über -
geben. Die initramfs lädt auch potentielle Splash-Screens,
sodass sie am Beginn des Startvorganges richtig dargestellt
werden.
Sobald die Root-Partition gemountet ist, beginnt erst die
Das GNU in GNU/Linux
Das GNU-Projekt ist knapp ein
Jahrzehnt älter als Linux. Im
Rahmen dieses Projekts wurden
die meisten der grundlegenden
Werkzeuge und Programme
geschaffen, die für einen Computer
der frühen 1980er Jahre
benötigt wurden: Compiler, Text-
Editoren, Kommandos zum Bearbeiten
von Dateien und Verzeichnissen
und vieles mehr. Doch
leider fehlte dem Projekt ein
benutzbarer Kernel. Nachdem
Linus Torvalds 1991 an seinem
kleinen Projekt herumzubasteln
begann, hatte er bald einen
Kernel, allerdings fehlten ihm die
Werkzeuge, um diesen laufen zu
lassen. GNU und Linux wurden
schließlich zusammengefügt,
und GNU/Linux war geboren
– ein Betriebssystem, das den
Linux-Kernel und die GNU-
Werkzeugsammlung vereint.
Es sind nicht nur die Programme
in /bin und /usr/bin,
die von GNU stammen – auch
glibc, die C-Kernbibliothek in
Linux, rührt von GNU her. Jedes
Mal, wenn Sie etwas an Ihrem
Computer machen, immer wenn
Sie ein Icon anklicken oder ein
Kommando eintippen, hilft GNU-
Software an irgendeiner Stelle
der Befehlskette. Kein Wunder
also, dass es die GNU-Verfechter
immer auf die Palme treibt, wenn
das Betriebssystem nur Linux
und nicht GNU/Linux genannt
wird. Aus Gründen der Bequemlichkeit
und Lesefreundlichkeit
wird dies dennoch häufig getan,
auch in diesem Handbuch (wofür
wir die GNU/Linux-Verfechter
um Entschuldigung bitten).
Richard Stallman hat das GNU-
Projekt 1983 ins Leben gerufen.
10

Grundlagen
richtige Startsequenz, entweder direkt oder über die initramfs.
Im Normalfall wird /sbin/init ausgeführt, was wiederum
die in /etc/inittab festgelegten Prozesse startet. Auch
alle Startmeldungen der Dienste werden von Ersterem kontrolliert.
Diese Ausgaben ermöglichen es Ihnen auch zu erkennen,
wo der Startvorgang hängt, falls er einmal scheitern
oder unverhältnismäßig viel Zeit in Anspruch nehmen sollte.
Alternativen
Im Laufe der Zeit sind die Komponenten stetig modernisiert
worden. Auf aktueller Hardware wurde das BIOS durch UEFI
ersetzt. Sobald aber der Bootloader installiert wurde, werden
Sie keine Unterschiede zwischen
beiden Systemen bemerken. Es gibt auch Bestrebungen, das
klassische SysVinit-System zu ersetzen, woran schon lange
gearbeitet wird. So hat Ubuntu Upstart eingeführt, während
Fedora und Red Hat zu systemd greifen. Der größte Unterschied
ist, dass SysVinit sequenziell vorgeht: Ein Dienst muss
starten, bevor der nächste auf der Liste angestoßen wird. Ist
ein langsam startender Dienst dabei, hält dieser alle anderen
auf. Upstart und systemd starten die Dienste hingegen parallel
und vermeiden so diesen Flaschenhals. Natürlich gibt es
Leute, die behaupten, dass Linux so stabil sei, dass die Startzeiten
eh nicht ins Gewicht fielen – wenn Sie den Ruhezustand
statt Herunterfahren nutzen, wird ein Reboot in der Tat
zu einem seltenen Ereignis.
Bibliotheken
Warum Programme sich Funktionen teilen.
Mithilfe sogenannter Bibliotheken wird bei Linux Code
zwischen mehreren Programmen geteilt. Falls beispielsweise
ein Programm namens foo bestimmte
Funktionen beinhaltet, die auch anderswo von Nutzen sein könnten,
werden diese in libfoo abgelegt. Wenn nun ein anderes Programm
– hier bar genannt – diese Funktionen nutzen möchte,
braucht es nur auf libfoo zu verweisen, anstatt das Rad neu zu
erfinden.
Im Idealfall befindet sich ein bestimmter Programmcode
also nur einmal auf Ihrem Rechner, und falls in dem Code ein
Fehler auftritt, genügt es, diesen in einer Bibliothek enthaltenen
Code-Abschnitt auszubessern, um den Fehler in allen darauf
verweisenden Programmen
zu korrigieren.
Dies führt auch das Konzept
der Abhängigkeiten ein: In unserem
Fall sind sowohl foo als auch
bar von libfoo abhängig und
wären ohne diese Bibliothek
nutzlos. Genau diese Abhängigkeiten sind auch für das Phänomen
der „Hölle der Abhängigkeiten“ verantwortlich, wo die
Installation eines Programmes durch nicht erfüllte Abhängigkeiten
verhindert wird und beim Nachin stallieren dieser Abhängigkeiten
sich sofort neue auftun. Heute ist das aber
meist nur noch eine unangenehme Erinnerung, weil Distributions-Repositorys
immer umfangreicher und Paketmanager
immer zuverlässiger werden.
Wenn Sie mit dem Paketmanager Ihrer Distribution arbeiten,
wird sich dieser um alle Abhängigkeiten kümmern, ohne
dass Sie einen Gedanken daran verschwenden müssen.
Paketmanager
„Mithilfe von Bibliotheken
wird Code zwischen
Programmen geteilt.“
Versuchen Sie mal, irgendwas.deb oder irgendwas.
rpm von www.irgendwas.com zu installieren, und Sie werden
früher oder später feststellen, warum es besser ist, so
etwas in Zukunft dem Paketmanager zu überlassen. Eine
mögliche Lösung für das Ganze ist es, die Programme statisch
zu kompilieren. Das bedeutet, dass beim Kompilieren
nicht auf den Code in libfoo verwiesen und während der Laufzeit
des abhängigen Programmes dynamisch darauf zugegriffen
wird, sondern dass der Compiler den Code von libfoo direkt
in die abhängigen Programme integriert. Im Falle von foo
und bar wären nach einem statischen Kompilierungsvorgang
zwei von libfoo unabhängige Programme das Ergebnis – mit
dem Nachteil, dass wenn in libfoo
ein Fehler gefunden würde, beide
Programme neu kompiliert und für
Ihre Distribution neu bereitgestellt
werden müssten. Generell ist es die
bevorzugte Methode, dynamisch
auf eine Bibliothek zu verlinken, sofern
nicht für ein Embedded-System programmiert wird.
Doch es gibt eine Situation, wo statisch verlinkte Programme
nützlich sind: in der initramfs, die beim Systemstart
geladen wird. So vermeiden Sie es, Bibliotheken in
das RAM-Disk-Abbild integrieren müssen. Falls es Sie interessiert,
welche Programme welche Abhängigkeiten aufweisen,
erfahren sie das mit dem ldd-Kommando.
ldd /usr/bin/irgendeinprogramm
zeigt alle von einem Programm benötigten Bibliotheken
sowie auch deren Abhängigkeiten an. Fast immer endet die
Aufzählung bei libc, dem Großvater aller Linux-Bibliotheken.
Dank der Flexibilität von Linux-Distributionen können die
meisten Elemente ausgetauscht werden, darunter Standardanwendungen,
Desktops und sogar der Kernel. Die einzige
Komponente, die nicht ausgetauscht werden kann, ist der
Paketmanager. Sollten Sie also einen anderen Paketmanager
ausprobieren wollen, müssen Sie die komplette Distribution
auswechseln. Wenn Sie etwa Yast von SUSE mit Synaptic von
Debian vergleichen, werden Sie feststellen, wie fundamental
sich der Paketmanager auf die Benutzererfahrung einer
Distri bution auswirken kann.
Bibliotheken machen ein System effizienter, indem sie Code anderen
Anwendungen zugänglich machen. Hier sehen Sie nur einige
von den Bibliotheken, auf die das Brennprogramm K3b verlinkt.
11

Grundlagen
Grafik
Darum sieht Ihr Linux-Betriebssystem so gut aus.
Werkzeuge wie
die Anzeigeeinstellungen
von
KDE helfen beim
Einrichten von
Multi-Monitor-
Systemen. Für
ein System mit
einem einzigen
Bildschirm muss
X jedoch in der
Regel nicht
konfiguriert zu
werden.
Das X Window System ist die Standardbasis, um unter
Linux eine grafische Benutzeroberfläche (GUI) zu ermöglichen.
Während Gnome und KDE die Benutzerschnittstelle
und die Optik zur Verfügung stellen, wird mithilfe von X die
Kommunikation mit der Hardware realisiert.
Etliche Jahre war das System eine Ansammlung kryptischer
Einstellungen und benötigte eine ellenlange Konfigurationsdatei,
in der Pixeltaktraten und Synchronisationsfrequenzen
festgelegt wurden. Heute braucht man hingegen
kaum noch Konfigurationsdateien. Dies verdanken wir vor
allem einer stark verbesserten Hardwareerkennung, sodass
Systeme mit einer einzelnen Grafikkarte und einem Monitor
ohne Konfiguration sofort funktionieren. Für die 3D-Beschleunigung
könnte ein zusätzlicher Treiber notwendig sein,
beispielsweise wenn Sie eine Grafikkarte von Nvidia nutzen.
Andernfalls starten Sie Ihren Rechner und können sofort mit
der Arbeit loslegen. X nutzt eine Client/Server-Architektur. X
selbst läuft als Server, der die Anzeige verwaltet, auf dem
System, während Client-Programme mit dem X-Server kommunizieren
und ihm mitteilen, was wo und wann dargestellt
werden soll.
Das mag ziemlich komplex erscheinen, aber das System
nutzt lokale Sockets zur Kommunikation zwischen Client und
Server, sodass es sich kaum negativ auf die Geschwindigkeit
auswirkt. Ein klarer Vorteil dieser Methode ist es, dass der
Client und der Server nicht auf demselben System laufen
müssen. Sie können sich mit einem anderen Computer via
SSH verbinden und – das Vorhandensein entsprechender
Berechtigungen voraus gesetzt – am entfernten Computer
ein Programm starten, dessen GUI auf dem lokalen Computer
angezeigt wird. Das ist ein großer Unterschied zu VNC,
weil nur ein Anwendungsfenster lokal angezeigt wird und dieses
auch nur lokal auf diesem Computer existiert. Eine VNC-
Verbindung spiegelt hingegen den gesamten Desktop auf
beiden Computern.
Wayland
Einige Leute empfinden die Client/Server-Architektur als zu
kompliziert, weshalb es Bestrebungen gibt, ein einfacheres
Grafiksystem zu entwickeln. Das am meisten fortgeschrittene
Projekt ist Wayland. Bei Wayland ist die Herangehensweise
eine andere als bei X: Nicht nur der Client/Server-Aufbau
fehlt, sondern Wayland überlässt auch das Rendern der
Fenster und anderer Elemente auf dem Bildschirm Programmen
wie OpenGL oder Cairo. Das macht Wayland wesentlich
einfacher. X beinhaltet eine große Menge Code, der der Kompatibilität
dient und von der X-Spezifikation zwar gefordert,
aber letztlich nicht genutzt wird. Indem die Kontrolle an die
Clients übergeben wird, kann Wayland viel schlanker, effizienter
und zukunftssicherer sein. Das bedeutet auch, dass die
grafische Software viel mehr Einfluss auf die Darstellung der
GUI hat.
Dämonenprozesse
Wenn Sie den Splash-Screen aktueller Distributionen
deaktivieren, werden Sie meistens
einen Bildschirm voller Informationen darüber
sehen, welche Dienste gerade starten.
Dienste sind Programme, die im Hintergrund
laufen. Einige von ihnen kümmern sich um das
Netzwerk, andere managen die Hardwareerkennung
und -konfiguration. Bei den meisten
Diensten handelt es sich jedoch um traditionelle
Software, die anderen Programmen Funktionen
zur Verfügung stellt. Diese Hintergrunddienste
heißen Daemons oder Dämonen.
Während einige davon auf fast allen Systemen
gebraucht werden – wie etwa der syslog-Dämon,
der die Log-Informationen des Systems in die
entsprechenden Dateien schreibt –, werden
viele Dienste auf dem jeweiligen System de
facto gar nicht benötigt. So gibt es beispielswiese
keinen Grund dafür, CUPS zu starten,
wenn sie keinen Drucker verwenden. Ebenso
dürfte der MySQL-Datenbankserver meist
nicht gebraucht werden, genauso wenig wie der
SSH-Dämon, wenn Ihr Computer der einzige
in einem Netzwerk ist. Eine halbe Stunde des
Herumexperimentierens könnte das Hochfahren
des PCs also eine Sekunde schneller machen.
Sie sollten allerdings nur solche Dienste
deaktivieren, die Sie sicher niemals benötigen
werden. Es ist sinnvoll, Dienste aktiviert und
sie geduldig ihren Netzwerk-Port oder -Socket
abhören zu lassen, da das die Arbeit der Client-
Software etwas effizienter macht. So müssen
Programme beispielsweise keinen eigenen Code
besitzen, um Log-Dateien öffnen, beschreiben
und wieder schließen zu können: Sie rufen einfach
die syslog()-Funktion mit dem Log-Eintrag als
Parameter auf, und der Dämon kümmert sich
um den Rest. Syslog ist ein wichtiger Dienst –
wenn irgendwas auf dem System schief läuft,
ist das oft der erste Ort, um nachzusehen, da
Die Startzeit des Computers kann durch
das Ausschalten unnötiger Prozesse verkürzt
werden.
die meisten Programme ihre Fehlerinformationen
zum System-Log senden (normalerweise
unter /var/log/messages zu finden).
Warum aber werden Hintergrunddienste
als Dämonen bezeichnet? In der griechischen
Mythologie waren Dämonen Geschöpfe, die sich
um Belange kümmerten, mit denen man Götter
nicht behelligt. Vielleicht ist das die Antwort.
12

Grundlagen
Netzwerke
Wie Ihr Computer mit anderen spricht.
Eine der Kernfähigkeiten von Linux ist die Vernetzung.
Sogar auf einem Einzel-Computer ohne Verbindung zu
einem lokalen Netzwerk werden die Netzwerkfähigkeiten
verwendet. Viele Dienste nutzen ein Client/Server-Modell, bei dem
der Server im Hintergrund läuft und auf die Anweisungen anderer
Programme wartet.
Sogar etwas so Grundlegendes wie der System-Logger
läuft als Netzwerkdienst und ermöglicht es dadurch anderen
Programmen, Log-Dateien zu schreiben. Das X-Grafiksystem
ist ebenfalls so aufgebaut: Der X-Server arbeitet im Hintergrund,
während ihm die Programme mitteilen, was er anzeigen
soll. Darum ist es so einfach, X-Programme auf einem
entfernten PC darzustellen – soweit es das System angeht,
gibt es keinen wirklichen Unterschied zwischen diesem Fall
und einem Fenster, das nur lokal angezeigt werden soll.
Wenn sie ifconfig ausführen, wird zumindest eine Netzwerkschnittstelle
mit dem Namen lo angezeigt. Diese besitzt die
Adresse 127.0.0.1 – sie wird vom Computer verwendet, um
mit sich selbst zu kommunizieren. Fast alle anderen Vorgänge
rund um das Netzwerk basieren auf TCP/IP, entweder
über verkabeltes Ethernet oder drahtlos. Aber es gibt noch
eine ganze Reihe andere Netzwerktypen, die genutzt werden.
Alle Distributionen und Desktops beinhalten gute
Werkzeuge, um TCP/IP-basierte Netzwerke zu konfigurieren
und zu verwalten, vom allgegenwärtigen NetworkManager
bis hin zu individuellen Tools wie das Netzwerk-
Konfigurationswerkzeug von Gnome oder Yast von
OpenSUSE.
Bluetooth
Neuere Entwicklungen im Netzwerkbereich
umfassen die drahtlose 3G-Kommunikation
und PAN-Technologien (Personal Area Network)
wie etwa Bluetooth. Das Verwenden
eines Breitband-Dongles für das 3G-Netz ist
recht einfach, meist genügt der NetworkManager oder die
PPP-Software Ihres Desktops.
Bluetooth wird mit der wachsenden Anzahl von Mobilgeräten
immer wichtiger, und auch die Liste der Eingabegeräte,
die das Protokoll benutzen, wird immer länger. Es sind nicht
nur die Smartphone- und Tablet-Benutzer, die davon profitieren
– eine Bluetooth-Maus und Funk-Lautsprecher können
auch den Umgang mit einem Notebook komfortabler machen.
Mit PulseAudio geht das sehr einfach, da dieses zwischen
den Ausgabegeräten umschalten kann, sobald sie erkannt
wurden.
Speicher
Das Speichern von Daten auf einer Festplatte hat mehrere
Aspekte. Alle physikalischen Speicher drehen sich bei Linux
um blockbasierte Geräte. Ein blockbasiertes Gerät wie
/dev/sda1 verweist wirklich auf Blöcke, bestimmte physisch
vorhandene Bereiche auf der Festplatte, die zu einer Partition
zusammengefasst werden. Darauf setzt das Dateisystem
auf, das bestimmt, wie die gespeicherten Daten in Strukturen
bestehend aus Dateien und Verzeichnissen organisiert werden.
Diese bestehen wiederum jeweils aus Daten und Metadaten.
Wo liegt der Unterschied zwischen Daten und Metadaten?
Angenommen, wir haben eine Datei, die etwas Text
enthält. Die Daten in dieser Datei entsprechen dem Text,
aber die Datei hat auch Attribute. Dazu gehören der Besitzer,
die Zeit der Erstellung, die Zeit, zu der die Datei zuletzt
geändert wurde, die Zeit des letzten Zugriffs sowie Informationen
darüber, wer die Datei lesen und bearbeiten darf.
Das sind die Informationen, die angezeigt werden, wenn Sie
den Befehl ls -l auf eine Datei anwenden oder sich deren
Eigenschaften im Dateimanager ansehen. Das Standard-
Dateisystem, das heute verwendet wird, ist ext4, aber es gibt
auch alternative Dateisysteme wie ext3, ReiserFS, XFS, JFS
und natürlich auch FAT und NTFS aus der Windows-Welt.
Das Netzwerk ist unerlässlich für den Betrieb eines Linux-Systems. Das Localhost-Interface
wird automatisch eingerichtet, für den Rest haben wir Programme
wie den NetworkManager.
Andere Linux-Betriebssysteme
Linux ist nicht nur ein Betriebssystem, das
auf „klassischer Hardware“ (Desktops, Notebooks,
Server) läuft, sondern es wird noch
in ganz anderen Umgebungen eingesetzt,
darunter viele Embedded-Geräte wie Router,
Videorecorder oder Set-Top-Boxen.
Falls etwa Ihr Router den Zugriff über SSH
erlaubt, werden Sie sich womöglich schnell zwar auf dem gleichen Source-Code basieren,
zu Hause fühlen, wenn Sie sich einloggen. aber alles, was darüber läuft, ist anders. Die Funktionsprinzipien
sind sich in gewisser Weise ähn-
Es gibt aber noch eine andere Klasse von Geräten,
wo Linux genutzt wird: Smartphones und lich, aber deren Ausführung unterscheidet sich
Tablets, die Android verwenden. Auch Android ist stark – auch wenn Sie ähnliche Kommandozeilenwerkzeuge
finden werden, falls Sie ein Terminal-
nämlich eigentlich Linux, es nutzt den Linux-Kernel.
Aber es ist nicht GNU/Linux. Der Kernel mag Fenster auf Ihrem Smartphone aufbekommen.
13

Grundlagen
Desktops
Gnome, KDE, Cinnamon, Unity – die Benutzerschnittstelle.
Betrachtet man den Kernel als die unterste Ebene des Systems,
stellt das Benutzerinterface die oberste dar. Der Kernel,
die Treiber, die Hardwareschnittstellen – all das wäre
nutzlos, wenn man den Computer nicht bedienen könnte.
Im Allgemeinen meint man mit dem Benutzerinterface
einen grafischen Desktop. Hier begegnen wir dann weiteren
Schichten. X (oder zukünftig vielleicht Wayland) bietet lediglich
eine blanke Fläche. Sie brauchen noch etwas, um Ihnen
die Vorzüge einer fensterbasierten Oberfläche zu bieten. Und
dieses Etwas ist der Fenstermanager.
In der Vergangenheit waren Fenstermanager Standalone-
Systeme. Von diesen gibt es immer noch eine ansehnliche
Anzahl, so wie etwa OpenBox oder Enlightenment. Heutzutage
sind die Fenstermanager jedoch oft ein Teil einer großen
Desktop-Umgebung. Ein Fenstermanager ist ein Programm,
das das Öffnen, Schließen, die Positionierung und andere
Steuerungen rund um ein Fenster verwaltet. Nach und nach
übernahmen die Fenstermanager noch weitere Funktionen
wie etwa Taskleisten oder Menüs zum Starten von Programmen,
bis schließlich daraus die heute bekannten
Desktop-Umgebungen wurden.
Softwaresammlungen
Eine Desktop-Umgebung ist im Großen und Ganzen
eine Sammlung von Werkzeugen, die nötig
sind, um einen kompletten Desktop zu betreiben.
Es laufen Programme darauf, sie steuern deren
Fenster und verfolgen, was sich auf dem System
abspielt. Im Hintergrund läuft aber
immer noch ein Fenstermanager: etwa KWin
bei KDE und Metacity bei Gnome, um nur zwei zu
nennen. Es ist die Stufe der Integration, die eine Desktop-Umgebung
von einem Fenstermanager unterscheidet.
Bei KDE, wo alles rund um einen gemeinsamen Kern arbeitet
Es gibt auch eine große Anzahl von sehr schlanken Fenstermanagern.
OpenBox, das hier gerade auf CrunchBang
läuft, ist einer davon.
und Programme nicht nur untereinander kommunizieren,
sondern eines auch in das Fenster eines anderen eingebunden
werden kann, ist das klar zu erkennen.
Während es nicht viel Sinn ergeben mag, KWin mit Gnome
zu benutzen, möchten Sie vielleicht einen der besseren Fenstermanager
ausprobieren. Oder vielleicht möchten Sie auch
eine andere Art zum Anzeigen von Fenstern verwenden. Beispielsweise
gibt es Fenstermanager, die auf das sogenannte
Tiling setzen, wie etwa awesome und xmonad. Diese skalieren
die Fenster automatisch so, dass sie alle auf den Desktop
passen. KDE hat eine eigene Option, um dieses Verhalten zu
erreichen. Es gibt Fenstermanager, die darauf ausgelegt sind,
mit der Tastatur steuerbar zu sein, genauso wie solche Exemplare,
die auf sehr spezialisierten Systemen von Nutzen
sind. Diese führen Programme im Vollbildmodus aus und
wollen nicht, dass irgendein Widget Platz verschwendet.
Gnome, KDE,
Unity, Cinnamon,
Mate – die Auswahl
ist nicht gerade
klein, wenn
es um die passende
Desktop-
Umgebung geht.
14

Grundlagen
Sound
Ein (früher) kniffliges Thema.
Das Soundausgabesystem unter Linux hat bereits einige
Anpassungen hinter sich. Über Jahre war OSS (Open
Sound System) der Standard, bevor es von ALSA
(Advanced Linux Sound Architecture) abgelöst wurde. ALSA gibt
es immer noch, inzwischen haben sich aber auch PulseAudio und
Jack hinzugesellt.
ALSA unterstützt mehrere Soundkarten, wovon jede mehrere
Ein- und Ausgänge haben kann. Sofern die Hardware
dies unterstützt, beherrscht es auch Hardware-Mixing, andernfalls
nutzt es Software-Mixing. Damit entfällt die Notwendigkeit
eines Soundmanagers, wie er in der Vergangenheit
von KDE und Gnome zur Verfügung gestellt wurde. Ein
Soundmanager wurde gebraucht, um mehr als ein Programm
gleichzeitig Sound abspielen zu lassen. ALSA arbeitet
sehr hardwarenah, um die Latenz möglichst gering zu halten.
Inzwischen wird fast jede Hardware direkt unterstützt. Die
Musikwiedergabe sollte also sofort nach der Installation der
Distribution funktionieren. ALSA ist eine Kombination aus
Kernel-Code und User-Space-Anwendungen. Es stellt auch
eine API zur Verfügung, sodass es von anderen Anwendungen
direkt kontrolliert werden kann. Dazu gehören etwa die
Lautstärkeregler, die in den meisten Desktop-Umgebungen
integriert sind.
PulseAudio
PulseAudio ist ein neueres Audio-Framework, aber kein Ersatz
für ALSA. Stattdessen setzt es auf dem Kernel-Audio-
System auf und erlaubt so eine erweiterte Kontrolle darüber.
PulseAudio arbeitet als Server, der Eingaben von den Quellen
annimmt und sie an die Ausgabe (Hardware oder eine Aufzeichnungssoftware)
weiterleitet. In vielen Fällen befindet
sich ALSA auf der Ausgangsseite, aber auch am Eingang
kann ein ALSA-Treiber aktiv sein. Das kommt beispielsweise
dann vor, wenn eine Anwendung PulseAudio nicht direkt unterstützt.
Das Funktionsprinzip lässt sich so weit treiben,
dass ein Ausgangssignal, das von einer Anwendung an ALSA
gesendet wurde, von eben jenem abgefangen und an Pulse-
Audio geleitet werden kann, welches es wieder zurück zu
ALSA sendet. Deshalb ist es keine Überraschung, dass viele
Anwender PulseAudio für zu kompliziert halten. Ein gutes Interface
sollte eine solche Verkettung aber transparent machen.
Die meisten Distributionen erfüllen diese Anforderung
auch und bieten so zusammen mit ALSA eine funktionierende
Soundlösung, die auch mit mehreren Soundausgabegeräten
zusammenarbeitet. ALSA unterstützt zwar mehrere Ausgabegeräte,
das Standardgerät ist aber systemweit als
solches festgelegt. Mit PulseAudio ist es dagegen möglich,
die Musik direkt zu den Lautsprechern zu leiten, während Sie
mit dem ebenfalls mit dem PC verbundenen Bluetooth-Headset
gerade einen VoIP-Anruf verwenden. Des Weiteren ist es
möglich, die Lautstärke einzelner Programme separat zu regeln.
PulseAudio ist außerdem netzwerkfähig. Es kann dazu
verwendet werden, andere PulseAudio-Server zu finden und
über deren Lautsprecher Sound abzuspielen.
JACK (Jack Audio Connection Kit) ist ein Sound-Server,
der für professionelle Audio-Anwendungen entworfen wurde.
Seine Stärke ist eine latenzarme Echtzeitverbindung zwischen
Anwendungen speziell für Sound- und MIDI-Daten. Die
Software ist für den täglichen Computergebrauch unnötig,
aber sehr nützlich für Nachwuchsmusiker.
Drucken
CUPS und Treiber.
Während Open Source die Wahlfreiheit fördert
und deshalb oft auch mehrere Programme die
gleiche Aufgabe auf leicht unterschiedliche
Art und Weise erledigen, gibt es einige Bereiche, wo
bestimmte Programme im Prinzip konkurrenzlos dastehen.
Was X.org für die universelle Grafikdarstellung darstellt,
ist CUPS für den Bereich des Druckens.
Wenn Sie einen Drucker an Ihrem Linux-Rechner angeschlossen
haben, brauchen Sie zwei Dinge: CUPS sowie
einen Treiber für Ihren Drucker. In vielen Fällen erhalten Sie
beides gemeinsam. CUPS ist ein Server, der im Hintergrund
auf Druckanfragen wartet. So gut wie jede Anwendung, die
das Drucken beherrscht, kennt auch das Internet Printing
Protocol (IPP), dessen Sprache auch die von CUPS ist. Wenn
Sie in Ihrer Textverarbeitung oder im Browser den Drucken-
Button betätigen, erscheint ein Fenster, das Ihre installierten
Drucker zeigt. Die Anwendung braucht nur die Druckdaten zu
senden, was normalerweise in PostScript geschieht, und
CUPS kümmert sich um alles Weitere. Es muss dabei nicht
einmal auf dem lokalen Computer laufen, denn CUPS ist ein
netzwerkbasierter Dienst und macht so den Drucker am lokalen
PC auch für jeden anderen Rechner im Netzwerk verfügbar.
Ohne Treiber, der CUPS sagt, wie mit dem Drucker
gesprochen wird, ist es aber nutzlos. Deshalb bringt CUPS
eine große Anzahl Treiber mit. Viele weitere gibt es, wenn Sie
das gutenprint-Treiberpaket installieren, und von HP gibt es
ein Treiberpaket namens hplib, das sowohl die Drucker als
auch die Scanner des Herstellers abdeckt.
Manche Hersteller bestehen aber darauf, ihre eigenen Treiber
anzubieten, anstatt sie mit CUPS zu bündeln. Meist geht
es dabei um Lizenzfragen. In diesem Fall haben Sie die Alternative,
die Internetseite des Druckerherstellers auf einen passenden
Treiber hin zu durchsuchen und diesen separat zu installieren.
Der Drucker sollte anschließend unter CUPS und
im Konfigurationsfenster ihrer Distribution auftauchen. Sie
können auch vor dem Kauf eines Druckers auf linuxprinting.
org vorbeischauen, damit Sie zu einem Modell eines kooperativeren
Druckerherstellers greifen können.
Die Verwaltung
von Druckern
über CUPS ist
so leicht wie das
Anklicken von
ein paar Links
im Browser.
Dies liegt am
eingebauten
Web-Interface.
15

Grundlagen
16

Grundlagen
Eben Upton
E wie Eben
Wir haben der Raspberry Pi Foundation einen
Besuch abgestattet und mit ihrem Gründer
über Themen wie geistiges Eigentum und
Hardware-Upgrades gesprochen.
Vermutlich gibt es wenige Menschen, die
ein so volles Programm haben wie Eben
Upton. Mit seinem Namen verbindet sich
zuallererst die Tatsache, dass er den Rasp berry Pi
entscheidend mit auf den Weg gebracht hat: Von
Beginn an stand er im Zentrum der Realisierung
des Mini-Computers, überwachte das Gerätedesign
bis ins Detail, organisierte die Herstellung und
war maßgeblich dafür verantwortlich, dass der Pi
in so unglaublicher Weise ins Zentrum des Interesses
gerückt ist. Mittlerweile hat die von Upton mitgegründete
Stiftung die Produktion des Geräts
nach Großbritannien verlagert, ein zusätzliches
Kameramodul verwirklicht und den Pi für vielfältige
neue Anwendungsbereiche fit gemacht.
Zwischen der Beantwortung von Anfragen
potenzieller Kooperationspartner und von Medien
aus aller Welt fand Eben Upton dennoch etwas Zeit
für ein Interview.
Frage: War es sehr schwierig, den großen Ansturm
auf den Raspberry Pi zu bewältigen?
Upton: Zum Glück haben uns die Pi-Hersteller
RS und element14 einen Großteil der Sorgen
über die Logistik und die hohen Stückzahlen
abgenommen.
Frage: Hatten Sie die Zusammenarbeit mit den
Dienstleistern von Anfang an geplant?
Upton: Ja, das war bereits die ursprüngliche
Idee, denn uns wurde noch vor der ersten Auslieferung
klar, dass die Nachfrage unsere eigenen
Kapazitäten höchstwahrscheinlich weit
übersteigen würde. Unsere finanziellen Mittel –
eine Viertelmillion Dollar – reichten für die Produktion
von 10.000 Exemplaren aus. Als wir
das erste SD-Karten-Image für den Raspberry
Pi veröffentlichten und plötzlich 50.000 Downloads
hatten, wussten wir, dass wir ein Problem
hatten [lacht]. Das Team, das die erste,
noch sehr fehlerhafte Version des Betriebssystems
entwickelte, wusste zu Beginn seiner
Arbeit ja nicht einmal, ob der Pi überhaupt je
gebaut werden würde, doch nun mussten wir
uns schnell etwas über legen.
Frage: Das war Ende 2011?
Upton: Richtig. Hätten wir zu diesem Zeitpunkt
das ursprüngliche Gerätedesign beibehalten,
wären die Bestellungen allein des ersten Tages
vermutlich erst nach einem Jahr abgearbeitet
gewesen. Tatsächlich hat dies nur drei oder
vier Monate gedauert, auch wenn es uns länger
vorkam. Aus eigener Kraft hätten wir selbst
im besten Fall wohl nur 100.000 Stück im ersten
Jahr verkaufen können, doch niemals eine
Million oder mehr. Das Zauberwort war daher
die Auslagerung der Massenherstellung des
Raspberry Pi an externe Dienstleister. Unsere
Partner können es in puncto Stückzahlen mit
Amazon aufnehmen. Allein RS verschickt nach
eigenen Angaben täglich 44.000 Warenpakete
– da macht der Raspberry Pi zwar einiges an
Volumen aus, doch letztlich stellt die Auslieferung
für RS kein Problem dar.
Frage: Der Startschuss für die Auslieferung war
ein denkwürdiges Ereignis, oder?
Upton: Allerdings! Wir, die Entwickler, hatten
neun Monate oder so darauf warten müssen,
die Hersteller RS und element14 nur ein, zwei
Monate.
Frage: Ihre Ehefrau Liz Upton hat als PR-Chefin der
Raspberry Pi Foundation sehr geschickt die Spannung
angeheizt.
Upton: Das hat sie in der Tat. Für unsere Produktionspartner
war die riesige Nachfrage
sicherlich eine Überraschung. Der Raspberry
Pi sichert bei beiden Herstellern einen
ansehnlichen Teil des Geschäfts und hat
ihnen deutliches Wachstum beschert. Und
für das Team bedeutete der große Erfolg eine
Veränderung der Sichtweise auf unsere Ziele
und Herausforderungen.
Frage: Auch auf einer persönlichen Ebene?
Upton: Ja. Zwar wurde der Spaß an der Sache
nicht weniger, aber das ganze Projekt wurde
dennoch auch ernsthafter, denn nun hingen
auf einmal die Jobs von Menschen davon ab.
Derzeit sichert der Raspberry Pi die Arbeitsplätze
von etwa einhundert Leuten. Das verändert
den Blick auf die Dinge. Würden wir lediglich
100 Platinen pro Woche herstellen, könnten
wir ohne großes Risiko einzelne Bauelemente
austauschen und im schlimmsten Fall
würden wir in dieser Woche einen Ausschuss
von 100 Stück produzieren. De facto sind es
aber zwischen 30.000 und 50.000 Einheiten,
die wöchentlich hergestellt werden, sodass ein
Fehler beträchtlichen Einfluss auf das Geschäft
hätte und Menschen dadurch ihren Job verlieren
könnten. Wie gesagt, es macht nach wie
vor Spaß, aber man wird etwas vorsichtiger.
Frage: Interessanterweise haben Sie das Raspberry-Pi-Projekt
sowohl als Stiftung als auch als
Geschäftstätigkeit konzipiert. Das ist eine ungewöhnliche
Kombination, nicht wahr?
Upton: Nun, gemeinhin geht man davon aus,
dass gemeinnützige Organisationen keine großen
Stückzahlen realisieren können – allerdings
ist gerade dies sehr wichtig, wenn man
nachhaltig arbeiten möchte. Wir wollten trotzdem
ge mein nützig bleiben, als Nonprofit-
Organisation. Darum stecken wir das verdiente
Geld wieder in das Projekt. Ich selbst bekomme
von der Stiftung kein Gehalt bezahlt, was
ich glücklicher weise auch nicht benötige.
Frage: Könnte sich das irgendwann ändern?
Upton: Vermutlich könnte es das eines Tages,
denn ich arbeite mehr als Vollzeit für die Stiftung,
wenn Sie so wollen, bin jedoch nach wie
vor ein Angestellter der Broadcom
17

Grundlagen
jedoch das Layout der Leiterplatte. Eine
interessante Frage. Ob wir das Layout
veröffent lichen werden? Eigentlich war das
immer so geplant und ist es noch. Allerdings
kann man die verbauten Chips in dieser
Form ja gar nicht kaufen. Das ist also ein
weiteres Problem, um das wir uns kümmern
müssen.
Corporation. Broadcom ist extrem großzügig
mir gegenüber. Ich nehme an, das Unternehmen
betrachtet das Ganze unter dem Marketingaspekt.
Wir brauchten allerdings einige
Zeit, bis wir Broadcom von der Idee überzeugt
hatten.
Frage: Lässt sich das damit vergleichen, als
Linus Torvalds bei Transmeta angestellt war?
Upton: Ja, man kann es vergleichen. Allerdings
war Torvalds anscheinend sehr stark
bei Transmeta involviert, während ich etwa
90 % meiner Arbeitszeit nicht für Broadcom,
sondern für Raspberry-Pi-Aktivitäten
aufwende.
Ob ich irgendwann direkt für meine Raspberry-Pi-Arbeit
ein Gehalt bekommen
werde? Möglicherweise wird der Tag kommen,
an dem Broadcom das jetzige Arrangement
nicht mehr vorteilhaft erscheint, das
wäre dann der richtige Zeitpunkt für einen
Wechsel. Allerdings ist es nicht so, dass
irgendwer eine Dividende aus dem Raspberry-Pi-Geschäft
erhalten würde – alle
Gewinne, die nach Abzug der Gehälter in der
Organisation verbleiben, werden wieder in
die Entwicklung des Raspberry Pi investiert.
Das ist sehr schön, denn es gibt uns die
„Wir sollten nicht unser
gesamtes geistiges Eigentum
zur Verfügung stellen, denn
es sichert die Nachhaltigkeit
des Raspberry Pi.“
Möglichkeit, nachhaltig zu arbeiten und
auch strategische Entscheidungen finanziell
zu unterfüttern. Beispielsweise können wir
uns dadurch interessante neue Projekte wie
die Entwicklung der Kamera leisten. Der Pi
ist von Pete Lomas von Norcott Technologies
entwickelt worden, wobei diese Arbeit
eine Zuwendung an die Stiftung war, zu
deren Treuhändern Lomas gehört. Die
Kameraplatine wurde als kommerzielles
Produkt entwickelt, daher haben wir in dem
Fall Leute für das Gerätedesign bezahlt.
Frage: Hat dies einen Einfluss darauf, ob die
Schaltpläne der Hardware der Öffentlichkeit
zugänglich gemacht werden?
Upton: Die Schaltpläne sind öffentlich, nicht
Frage: Ist das der Grund dafür, dass das Layout
der Leiterplatte bisher nicht öffentlicht ist?
Upton: Wenn wir das Layout des Raspberry
Pi veröffentlichen, können Sie dennoch keinen
selber bauen, denn die Chips sind nicht
als Einzelkomponenten auf dem Markt
erhältlich. Es gibt aber noch einen weiteren
Grund: Einige Leute – nicht viele – waren
sehr erbost darüber, dass wir unser geistiges
Eigentum nicht vollständig der Allgemeinheit
zur Verfügung gestellt haben. Der
Zorn dieser Leute ist bislang auf die Stiftung
gerichtet. Wenn wir nun das Layout der Leiterplatte
herausgeben würden, weiß ich, wer
stattdessen den Ärger abbekommen würde
– nämlich Broadcom, die die Chips herstellen,
und das hätten sie nicht verdient. Das
Unternehmen hat uns äußerst viel Unterstützung
gegeben, darum lasse ich einstweilen
die Kritik gerne über mich ergehen.
Ich vertrete nicht die Ideologie, dass wir
unser gesamtes geistiges Eigentum zur Verfügung
stellen sollten, denn das Geld, das
wir damit verdienen, sichert die Nachhaltigkeit
des Raspberry Pi. Ein ziemlich wichtiger
Aspekt des Pi ist es, dass es ihn wahrscheinlich
auch in fünf Jahren noch geben wird –
ein gutes Verkaufsargument. So können Sie
nämlich ein industrielles Produkt
auf Basis des Pi herstellen
oder einen Lehrplan entwickeln,
der sich auf das Gerät
stützt.
Frage: Und Sie möchten all das
nicht dadurch verwässert sehen,
dass ein anderer Hersteller einen
eigenen Raspberry Pi anbietet?
Upton: So ist es. Würden wir das
Gerätede sign herausgeben und dadurch
anderen Produzenten die Herstellung von
Raspberry-Pi-Klonen ermöglichen, würden
wir die finanzielle Grundlage unserer Arbeit
unterminieren. Es ist ja nicht so, dass wir 10
Dollar an jedem Pi verdienen würden! Unsere
Marge ist klein genug, und darum können wir
das Gerät auch so günstig anbieten. Bei Klongeräten
würde das Geld vermutlich in Form
von Dividenden in die privaten Taschen anderer
Leute fließen. Letztendlich würden wir die
Stiftung destabilisieren – ihre Möglichkeiten,
in Bildung oder Open-Source-Projekte zu
investieren, würden beschnitten.
Frage: Wird es ein Upgrade des Raspberry Pi
geben? Haben Sie die Möglichkeit eines modu-
18

Grundlagen
beeinflussen kann. Und das funktioniert
ganz gut. Der ARM bewegt Pixel für Pixel,
aber nun da wir die Sachen mit Pixmap
gemacht haben, ist es ein ARM, der die
Pixel bang!, bang!, bang! transportiert. In
dem Maße, wie ein ziemlich langsamer
ARM Pixel schnell bewegen kann, bewegen
wir jetzt die Pixel schnell. Im End effekt
haben wir uns entschieden, das mit der
X-Beschleunigung sein zu lassen. Stattdessen
sollten wir uns in die schöne neue Welt
von Wayland begeben.
Frage: Weil das einfacher ist?
Upton: Ja, ich glaube schon, dass es einfacher
ist. Wenn wir jede der Alternativen
„Es wäre traurig und fatal,
wenn wir 2016 noch immer
den gleichen Pi vertreiben
würden.“
lar aufgebauten Geräts in Erwägung gezogen?
Upton: Bislang haben wir keinen Platz auf
der Platine, um zusätzlichen RAM-Speicher
unterzubringen. Wir können das RAM nicht
erweitern, denn der SoC-Prozessor kann nur
den vorhandenen Speicher ansprechen. Und
den Prozessor können wir wiederum nicht
mit einer höheren Leistung ausstatten, da
diese vom SoC vorgegeben ist. Wir haben
im Grunde keinen Fahrplan für eine Hardware-Erweiterung.
Frage: Haben Sie denn noch keinen Raspberry
Pi 2 im Hinterkopf?
Upton: Es wäre traurig – und wohl auch fatal
für uns –, wenn wir im Jahr 2016 oder so
noch immer den gleichen Raspberry Pi vertreiben
würden. Wir müssen etwas tun, aber
eine konkrete Idee habe ich noch nicht. Das
Problem ist, dass ich mir zwar eine Platine
zu einem beliebigen Preis zwischen 25 und
85 Dollar ausdenken könnte, dass es jedoch
ex trem schwierig ist, etwas wirklich Attraktives
zu kreieren. Der Raspberry Pi ist so
attraktiv, weil er ein tolles Preis-Leistungs-
Verhältnis besitzt. Zu einem vergleichbaren
Preis, also etwa zwischen 25 und 35 Dollar,
könnte ich auf Grundlage der aktuell verfügbaren
Hardware keine Platine bauen, die
dem Pi das Wasser reichen würde.
Sogar in einer Preisklasse von 45 Dollar
wäre es noch schwierig, den Raspberry Pi zu
übertreffen. Mit einem 55-Dollar-Gerät wäre
das vermutlich machbar, doch ich frage
mich, warum es dann kein entsprechendes
Teil auf dem Markt gibt.
Frage: Wie halten Sie denn dann die Dynamik
aufrecht?
Upton: Mit einer Menge Softwarearbeit.
Frage: Auf der Softwareseite liegt also momentan
der gesamte Fokus?
Upton: Mit seinen 700 MHz ist der Chip des
Raspberry Pi ein extrem leistungsfähiger
Grafikprozessor. 97 % der Leistung werden
für die Grafik aufgewandt.
Frage: Was benötigt eine Standardinstallation
des Betriebssystems Raspbian?
Upton: Derzeit benutzt sie den Video-Output,
den USB-Controller – Dinge, die vor dem
ARM da waren. Der ARM hat den Chip 3 %
größer gemacht. Hauptsächlich ist der ARM
gefordert, ein bisschen von der Systeminfrastruktur,
ein SDRAM-Controller und einige
kleine Peripheriebausteine. Ein großer Teil
des Systems ist die meiste Zeit über inaktiv.
Der 700-MHz-ARM-Prozessor besitzt eine
Menge Power, aber im historischen Kontext
ist er auch ein wenig voluminös. Da wir auf
der Hardwareseite mehr oder weniger festgelegt
sind, investieren wir mehr Arbeit in
die Software, um möglichst viel von der
Leistung herauszukitzeln. Wir haben Elemente
auf der Systemebene optimiert –
Dinge wie Pixmap, memcpy und memset.
Wir hatten eine Diskussion über X-Beschleunigung.
Wir haben keine X-Beschleunigung,
wir haben keinen Beschleunigungstreiber.
Wir haben viele Komponenten auf
dem Chip, eine Menge Subsysteme, mit
denen man den X-Server-Beschleuniger
finanzieren können, würde ich das Geld
doch lieber auf die schöne neue Welt verwenden.
Der Trend geht hin zu Wayland,
daher sollten wir dort mit von der Partie
sein, und das möglichst bald. Wir haben mit
etwas herumprobiert, wo bei Ausreizung der
Speicherbandbreite eine Off-Screen-Erstellung
als Ausweichlösung fungiert. Das ist
ziemlich cool und gibt einem das reine
60-Hz-Window-Dragging. In einer Welt, wo
jedes Fenster ein Hardware-Sprite ist, werden
beim Ziehen von Fenstern keinerlei Pixel
bewegt.
Wir haben dieses Video-Scaler-Bauteil, das
größer ist als der ARM, da es eine Menge Pufferspeicher
benötigt, um die Sprites zu steuern.
Da wir also etwas haben, das sich um
Render-Hierarchien kümmert, sowie einen
Window-Manager, sollten wir die Software
entwickeln, um beides zu verbinden. Dies ist
ein gutes Beispiel dafür, wie wir mithilfe der
Software einen Mehrwert für den Benutzer
schaffen, ohne einen neuen Chip zu bauen.
Und es gibt uns Zugang zu dem wunderbaren
Wayland.
Frage: Das klingt nach der ersten hochkarätigen
Anwendung von Wayland!
Upton: Ich glaube, wir haben das erste Wayland-Backend
ohne GL. Normalerweise wird
auf GL aufgesetzt, aber GL ist lausig, wenn
der Bildaufbau darauf aufsetzt, denn die Skalierungsfilter
sind primitiv – sogar beim
Herunter skalieren muss man eine Reihe Mipmaps
generieren. Unser Backend funktioniert
jedoch anders. Wenn man beispielsweise im
Verhältnis 3:1 herunterskalieren möchte,
baut es jeden Pixel dadurch auf, dass es
Durchschnittswerte eines 3x3-Gitters von
Pixeln aus dem Originalbild verwendet.
19

Grundlagen
Ursprünge: Wie
Hier erfahren Sie etwas über die Entstehungsgeschichte des Raspberry Pi
sowie über dessen einzelne Bauteile.
Doch nicht nur die Bequemlichkeit hält die Menschen davon
ab, einen Blick unter die Haube ihrer Rechenmaschinen zu werfen,
um herauszufinden, wie sie genau funktionieren. Ein weiterer
Grund sind diverse Klauseln in den Endbenutzerverträgen
von Windows und Mac OS X, die das Modifizieren des Programmcodes
verbieten. Obwohl Sie eine ansehnliche Summe
für das Betriebssystem bezahlt haben, ist es Ihnen nicht erlaubt,
es zu „zerlegen“ und wieder „zusammenzusetzen“. Diese
beiden Faktoren sorgen in Kombination dafür, dass die Anwender
wenig Ahnung von den Funktionsabläufen innerhalb ihrer
Computern haben.
Heutzutage hält ein Computer seine Funktionsweise versteckt.
Sie öffnen ein Dropdown-Menü, klicken mit der
Maus auf ein Icon, und das Programm, das Sie gerade
benutzen, macht das, was Sie wollen. Oder zumindest das, was
es laut dem Ersteller der Software machen soll. Leider ist die
Benutzung eines Computers für die meisten Menschen nur
noch gleichbedeutend mit der Benutzung einer Software, die
jemand anders für sie geschrieben hat, und nicht mehr mit der
Entwicklung eigener Lösungen für eine Aufgabenstellung. Es
stimmt natürlich, dass grafische Benutzeroberflächen den Computer
einem weit größeren Kreis von Anwendern zugänglich
gemacht haben, als dies ohne solche Programme je möglich
gewesen wäre. Aber es stimmt genauso, dass die meisten
Anwender nur noch eine grobe Ahnung davon haben, wozu ihr
Computer eigentlich in der Lage wäre.
Die Stunde des Raspberry Pi
Hier kommt nun Eben Upton ins Spiel, Studienleiter für Informatik
am St. John’s College in Cambridge. Im Rahmen seiner Tätigkeit
ist er unter anderem am Zulassungsprozess für neue Studenten
beteiligt. Dabei stellte er über die Jahre hinweg einen
kontinuierlichen Verfall der Fähigkeiten bei den Bewerbern fest.
Je mehr Zeit Universitäten aufwenden müssen, um Bewerber
mit unterdurchschnittlichem Vorwissen auf das Standardniveau
zu heben, desto weniger Zeit bleibt, um den Studenten die wirklich
interessanten Dinge beizubringen. Dies hat natürlich zur
Folge, dass auch das Kenntnisniveau der Berufseinsteiger in
der Informatikbranche sich mit der Zeit verschlechtert und Personalchefs
es zunehmend schwerer haben, einen Bewerber mit
ausreichender Qualifikation zu finden.
Um dem entgegenzuwirken, haben Eben Upton und einige
Mitstreiter den Plan geschmiedet, ein Gerät zu entwickeln, das
„hackbar“, billig und frei von Schutzansprüchen ist sowie zu
einem Bruchteil der Kosten prinzipiell zu allem in der Lage ist,
was auch ein normaler PC kann. Das Produkt, das die Gruppe
aus dem Hut zauberte, war – na klar! – der Raspberry Pi.
Der BBC Micro
Der Raspberry Pi war nicht der erste Computer, der mit der Absicht
entwickelt wurde, das IT-Wissen der britischen Bevölkerung zu verbessern.
1981 brachte Acorn Computers in Zusammenarbeit
mit dem Computer-Kompetenz-Projekt der BBC den BBC Micro
auf den Markt. Das Gerät war in zwei Versionen – Modell A
und Modell B – erhältlich und wurde mit dem Zweck entworfen,
darauf Programme laufen zu lassen, die Jugendliche im Umgang
mit Computern trainieren sollten. Eine Fernsehsendung der BBC
begleitete das Projekt. Der größte Unterschied zwischen den beiden
Versionen war der Preis: 1981 kostete das Modell A 235 Pfund und das
schnellere Modell B stolze 335 Pfund. Der BBC Micro wurde zu einem
riesigen Erfolg und trug nicht wenig dazu bei, dass eine ganze Generation
britischer Kinder mit einem soliden Wissen darüber aufwuchs, wie man
einen Computer programmiert. Dass der Chip im Herzen des Raspberry
Pi auf dem Design einer Firma – ARM – basiert, die aus Acorn Computers
ausgegründet wurde, stellt dabei eine nette historische Fußnote dar.
Zu heutigen Preisen würde das
Modell B des BBC Micro umgerechnet
1.300 Euro kosten – der Pi
ist dagegen für 35 Dollar zu haben.
20

Grundlagen
der Pi entstand
Ein Blick auf den Raspberry Pi
Slot für die SD-Karte
Der Raspberry Pi hat keinen Speicher mit an Bord,
weshalb Sie diesen mit einer SD-Karte nachrüsten
müssen, um darauf das Betriebssystem und Ihre
Dateien zu speichern. Die Idee dahinter ist, dass
Sie nur das bezahlen müssen, was Sie brauchen:
Das kann eine 4-GB-Karte für wenige Euro oder
eine 128-GB-Karte für ein kleines Vermögen sein.
System-on-a-Chip
Dieses kleine Element ist
das Herz des Raspberry
Pi: Es besteht aus einem
700 MHz schnellen
ARM11-Prozessor
und einer Videocore-
4-Grafikeinheit. Der
Arbeitsspeicher sitzt
im System-on-a-Chip:
Modell A ist mit 256 MB
RAM, Modell B mit 512
MB RAM ausgerüstet.
RCA-Video-Ausgang
Für ältere Fernseher gibt es auch einen RCI-
Video-Anschluss. Falls Ihr Bildschirm keine
Anschlüsse für RCA oder HDMI besitzt, gibt es
Adapter auf den gängigen DVI-Anschluss.
3,5-mm-Audio-Klinke
Mit diesem Anschluss verwandeln
Sie den Raspberry Pi schnell in
ein günstiges HiFi-System.
USB-Anschlüsse
Das Modell B hat zwei USB-
Anschlüsse, die zum Betrieb
einer Maus und einer Tastatur
ausreichen. Um zusätzliche Geräte
am Raspberry Pi zu betreiben,
müssen Sie sich nach der Einrichtung
entweder über das Netzwerk
mit dem Raspberry Pi verbinden
oder einen USB-Hub anschließen.
Stromanschluss
Das Raspberry Pi erhält seinen Strom über einen
5-V-Micro-USB-Stecker. So können Sie die Platine
günstig mit Energie versorgen. Falls Sie ein
Android-Smartphone besitzen, haben Sie das
passende Netzteil wahrscheinlich schon zu Hause.
HDMI-Ausgang
Die Entwickler des Raspberry Pi gingen davon aus,
dass die meisten Nutzer das Gerät an einem Fernseher
oder einem Bildschirm verwenden würden: Deshalb
gibt es einen HDMI-Anschluss, der den Raspberry Pi
mit modernen TV-Geräten und Bildschirmen verbindet.
Ethernet
Stecker rein, und Sie sind mit dem Internet verbunden
– es sei denn, Sie haben zum Modell A
gegriffen, das keinen Ethernet-Anschluss besitzt.
In diesem Fall verwenden Sie einen WLAN-Adapter,
den Sie in einen USB-Anschluss einstöpseln.
Modell A oder Modell B?
Es gibt zwei Typen des Raspberry Pi, das Modell
A und das Modell B. Bei beiden handelt es sich
im Prinzip um den gleichen Computer. Die einzigen
Unterschiede liegen im Preis, in der Größe
des RAMs und in den vorhandenen Anschlüssen.
Während das Modell B 512 MB aufweist, hat
das Modell A nur 256 MB. Das Modell A verfügt
außerdem nur über einen USB-Anschluss,
während das Modell B derer zwei hat. Außerdem
kommt das Modell B mit Ethernet-Anschluss,
der dem Modell A komplett fehlt. Deshalb kostet
das Modell B auch 35 Dollar, das Modell A
ist dagegen schon für 25 Dollar zu haben. Das
Modell B ist aufgrund dieser Unterschiede die
vielseitigere Version der beiden und deshalb auch
die Variante, die wir empfehlen sowie für dieses
Heft verwendet haben. Falls Sie keinen Internetanschluss
brauchen – vielleicht, weil es Ihnen um
eine Möglichkeit geht, ein Embedded-System zu
betreiben – ist das Modell A immer noch eine gute
Wahl, die Ihnen hilft, die Kosten gering zu halten.
Das gilt vor allem, wenn Sie viele davon brauchen.
Trotzdem bevorzugen wir die Flexibilität des Modell
B, die für wenige Euro zusätzlich zu haben ist.
21

Grundlagen
Richtig verbinden:
Unser detaillierter Guide, wie Sie das richtige Zubehör wählen und welche
Verbindungen Sie für eine optimale Performance brauchen.
Der Raspberry Pi
kann wählerisch
sein, wenn es um
die Kompatibilität
der Speicherkarte
geht. Versichern
Sie sich daher,
dass Sie eine
Karte kaufen, die
funktioniert und
passt. Achtung:
Die Karte ganz
oben hat die
richtigen Maße!
Bevor Sie mit dem Raspberry Pi loslegen können, müssen
Sie einiges an Zubehör anschließen. Es lohnt sich, hier
mit Sorgfalt vorzugehen, denn Probleme aufgrund falscher
Verbindungen oder inkompatibler Peripherie sind im Nachhinein
oft schwer aufzuspüren. Deswegen lohnt es sich nachzuschauen,
welche Hardware am besten funktioniert – vor allem,
wenn Sie den Kauf eines neuen Raspberry Pi planen.
Am besten fangen Sie mit der SD-Karte an, denn dies ist das
vermutlich wichtigste Zubehör, das Sie für Ihren Raspberry Pi
brauchen. Die kleinen Plättchen mit der abgeschnittenen Ecke
dienen dazu, das Betriebssystem darauf zu speichern, und sind
die einzigen Einheiten, von denen Ihr Raspberry Pi booten kann.
Gerade zu Beginn müssen Speicherkarten einiges einstecken:
Ihre SD-Karte muss willkürliche Neustarts sowie ständiges Entfernen
und Einsetzen aushalten und ist ständig dem Risiko
ausgesetzt, an eine unebene Platine angeschlossen zu werden.
Aus diesen Gründen ist es ein bisschen knifflig, die richtige
SD-Karte auszusuchen. So ist es nicht empfehlenswert, eine
Karte mit zu hoher Kapazität zu kaufen: Dabei bezahlen Sie
einen hohen Preis für ein Stück Hardware, das schnell kaputtgehen
kann. Andererseits ist eine bestimmte Menge an Speicher
schon erforderlich, da Sie mindestens 2 GB benötigen, um
das Standard-Betriebssystem Raspbian zu installieren. Dafür
nicht genutzter Speicher kann dazu verwendet werden, Ihre eigenen
Dateien oder Zusatzeinheiten zu speichern, darum sollten
Sie auch wiederum nicht zu knapp kalkulieren.
Wir empfehlen Ihnen, für den Anfang eine Karte mit 4 GB
Speicher zu kaufen und bei Bedarf ein zusätzliches USB-Gerät –
etwa eine externe Festplatte – zu benutzen. Solche Geräte bieten
Ihnen erstens mehr Speicher zu einem niedrigeren Preis,
und zweitens bleiben so Ihre darauf gespeicherten Medienoder
Konfigurationsdaten erhalten, auch wenn Sie das Betriebssystem
auf der SD-Karte überschreiben. Außerdem lohnt es
sich, die Karte noch vor dem Kauf auf Kompatibilität zu überprüfen,
da es mehrere SD-Karten gibt, die mit dem Raspberry
Pi nicht funktionieren. Achten Sie des Weiteren darauf, eine SD-
HC-Karte zu kaufen („HC“ steht für „high capacity“, hohe Kapazität),
da SDSC-, SDXC- sowie SDIO-Karten dafür bekannt sind,
Probleme zu verursachen. Auf http://elinux.org/RPi_SD_cards
werden sowohl die funktionierenden als auch die fehlerhaften
Karten aufgelistet, basierend auf den Erfahrungen der
Raspberry-Benutzer. Sogar Karten von großen Herstellern wie
SanDisk oder Kingston versagen manchmal beim Pi ihren
Dienst, daher lohnt es sich auf jeden Fall, vor dem Kauf die
Kompatibilität zu überprüfen.
Falls Sie ein völliger Neuling sind, sollten Sie erwägen, sich
eine SD-Karte mit vorinstalliertem Raspbian zu besorgen. Dadurch
umgehen Sie sowohl das mögliche Problem der Inkompatibilität
als auch die Schwierigkeiten beim Installieren
des Systems auf der Karte. In der Praxis hatten wir
bei unseren Versuchen selten Probleme mit Speicherkarten
aus dem Fachhandel. Was Sie ebenfalls probieren
können, ist die Verwendung einer alten SD-Karte von einer
Kamera.
Energieversorgung
Man könnte annehmen, die Energiezufuhr für den Raspberry Pi
wäre kein größeres Thema, aber das würde täuschen. Haben
Sie nämlich nicht die richtige Versorgung für Ihre Pi-Konfiguration,
dann können Sie nur schwer bestimmen, ob eventuell
22

Grundlagen
Peripherie
Gehäuse für den Raspberry Pi
Obwohl dies nicht direkt die Leistung Ihres
Raspberry Pi beeinflussen wird, lohnt sich die
Anschaffung eines Gehäuses für die Platine. Standardmäßig
ist der Pi sehr anfällig für Einwirkungen
von außen, da die schützende Schicht sehr dünn
ist und Metallflächen einen Kurzschluss verursachen
und den Raspberry Pi beschädigen können.
Dank der „Do it yourself“-Idee des Projekts gibt
es für jedes Budget das passende Gehäuse. Wer
sich die Ausgabe ganz sparen möchte, kann einen
Gegenstand des täglichen Gebrauchs umfunktionieren,
wie etwa die Hülle einer Audiokassette,
oder sogar ein Gehäuse aus Lego-Steinen bauen
– wenn Sie dabei durchsichtige Steine verwenden,
können Sie weiterhin die Anzeigen die Status-
LEDs sehen. Wenn Sie bereit sind, ein wenig Geld
auszugeben, gibt es verschiedene bunte Acrylgehäuse
für etwa 6 Euro. Viele dieser Gehäuse
haben einen weiteren Vorteil: Sie können anmontiert
werden. Nachdem Ihr Pi also einmal eingepackt
ist, können Sie ihn überall anbringen – ob
im Inneren eines Spieleautomaten oder an einem
Regalbrett. Bedenken Sie dabei nur, dass der Pi
bei hoher Belastung viel Wärme abgeben kann.
auftretende Probleme das Resultat der Energiezufuhr oder aber
eines Softwarefehlers sind. Als wir beispielsweise am Tutorial
zum Thema Fernsehaufzeichnung mit dem Pi gearbeitet haben,
konnten wir mit unserer USB-Hardware stundenlang keinen einzigen
TV-Kanal finden, obwohl alles vollkommen fehlerfrei aussah.
Letztendlich war der von uns benutzte USB-Hub einfach
nicht leistungsfähig genug. Um ausreichend Energie für Ihren Pi
bereitzustellen, empfehlen wir Ihnen die ausschließliche Verwendung
von Micro-USB-Ladegeräten mit mindestens 1,2 A.
Mehr als 1,2 A verursachen keine Probleme, weniger kann zu
unvorhersehbarem Verhalten führen. Solche Adapter liegen einerseits
vielen modernen Mobiltelefonen bei, andererseits finden
Sie sie in den meisten Elektrofachgeschäften. Jeder Adapter
mit weniger als 1,2 A kann zu Problemen führen, wenn Ihr Pi
stärker beansprucht wird.
Für externe USB-Verbindungen empfehlen wir dringend, einen
guten USB-2.0-Hub (HiSpeed) zu verwenden. Diesen verbinden
Sie mit Ihrem Raspberry Pi über einen Standard-B-Stecker und
ein Standard-A-Kabel. Ältere 1.0-Hubs scheinen zwar zu funktionieren,
doch hatten wir Probleme bei der Hardware-Kompatibilität
– dieses Risiko sollte man lieber vermeiden. Außerdem
müssen Sie sicherstellen, dass der Hub separat und nicht nur
über den Raspberry Pi mit Strom versorgt wird. Bei vielen preisgünstigen
Hubs gehört ein Netzteil nicht zum Lieferumfang,
kann jedoch angeschlossen werden – achten Sie hierbei auf die
jeweiligen Spezifikationen. Die Hubs müssen 5 V liefern und
möglichst auch 3,5 A, damit Sie mehrere Geräte an den Pi anschließen
können. Einfacher ist es, für ein wenig mehr Geld
gleich einen Hub mit eigenem Netzteil zu erwerben. Achten Sie
darauf, sämtliches Zubehör über den Hub und nicht direkt an
den Pi anzuschließen, denn nur so profitieren Sie von der externen
Stromversorgung.
Vernetzen
Für die Installation und Konfiguration müssen Sie den Raspberry
Pi mit Ihrem Heimnetzwerk verbinden. Das erledigen Sie am
besten über den Ethernet-Port auf der Platine, den großen
RJ45-Anschluss an der Seite. Die meisten Internetverbindungen
zu Hause finden über einen Wireless-Hub statt, der außerdem
über einige RJ45-Anschlüsse verfügen sollte – falls Sie Geräte
wie Spielkonsolen oder TV-Receiver per Kabel anschließen
möchten. Der Raspberry Pi lässt sich auf die gleiche Art und
Weise verbinden: Solange Ihr Hub in Betrieb ist, müssen Sie
einfach beide Geräte per Ethernet-Kabel miteinander verbinden.
Sollte das nicht möglich sein, können Sie eine andere Option
nutzen, nämlich eine Verbindung via „Ethernet über Strom“-Adapter,
auch als Powerline-Adapter bekannt. Einen der zwei Adapter
verbinden Sie dabei mit einem freien Ethernet-Port Ihres
Sie müssen sich überlegen, wie Sie
sowohl das Raspberry Pi als auch die
daran angeschlossenen USB-Geräte mit
Strom versorgen möchten.
Ethernet-
Verbindungen sind
einfach, aber viele
USB-Geräte werden
auch dann funktionieren,
wenn Sie
einfach das Desktop-WiFi-Programm
benutzen.
23

Grundlagen
Hubs und einer Steckdose, während der andere in eine Steckdose
in der Nähe Ihres Pi gesteckt wird und über ein
Ethernet-Kabel den Raspberry Pi mit dem Netzwerk
verbindet.
Wenn Sie ein Modell A ohne
Ethernet-Schnittstelle besitzen oder
lieber eine kabellose Verbindung
nutzen möchten, dann ist der Vorgang
komplexer. Zuerst müssen
Sie sich ein kabelloses USB-Gerät
besorgen, das mit dem Raspberry Pi
kompatibel ist. Wir empfehlen Ihnen,
zuerst einen Blick auf das überprüfte
Zubehör unter elinux.org zu werfen
(http://elinux.org/RPi_VerifiedPeripherals)
und ein Gerät zu wählen, das sicher funktioniert.
Dadurch müssen Sie keine Treiber ohne Internet verbindung
installieren. Außerdem sollten Sie das Gerät über einen USB-
Hub mit eigener Stromversorgung verbinden und nicht direkt an
den Pi anschließen, da kabellose Verbindungen beträchtliche
Mengen Strom verbrauchen können. Das Einzige, das Sie danach
noch zur Herstellung einer kabellosen Verbindung tun
müssen, ist es, auf die Schaltfläche zur WiFi-Konfiguration auf
dem Raspbian-Desktop zu klicken. Falls Ihr WiFi-Gerät richtig erkannt
wird, sehen Sie „wlan0“ als Adapternamen und müssen
nur noch auf die Scan-Schaltfläche klicken. Mit etwas Glück
wird Ihr Heimnetzwerk erkannt und Sie müssen es nur noch
doppelklicken, um das Konfigurationsfenster zu öffnen. Geben
Sie das Netzwerk-Passwort ein und klicken Sie auf „Hinzufügen“.
Schließen Sie das Fenster mit den Scan-Ergebnissen; die
Statusseite sollte Ihnen anzeigen, dass Ihr Pi mit dem Netzwerk
verbunden ist. Sie können die Netzwerk-Einstellungen jederzeit
über die Netzwerkverwaltung ändern. Vor dem Schließen des
Programms oder dem Neustart Ihres Raspberry Pi sollten Sie
immer Ihre Konfiguration speichern.
HDMI lässt sich einfach in DVI konvertieren, um das Pi
zusammen mit den meisten Flachbildschirmen zu benutzen.
USB-Tastatur und -Maus
Wenn Sie über eine funktionierende Netzwerk-Verbindung verfügen,
brauchen Sie nicht unbedingt eine Tastatur oder eine
Maus. Ist das Raspbian-System installiert, können Sie sich per
Fernsteuerung mithilfe eines Protokolls namens SSH mit Ihrem
Pi verbinden. Installieren Sie über einen Windows-Rechner den
kostenlosen Putty-Client. OS-X- und Linux-Nutzer verfügen über
einen eingebauten SSH-Client: Tippen Sie ssh, gefolgt von pi@
und der IP-Adresse Ihres Pi in die Kommandozeile (Ihr Router
oder Hub hat eine Konfigurationsseite mit den IP-Adressen aller
angeschlossenen Geräte). Das Passwort für den Standard-Account
(„pi“) ist „raspberry“. Wenn Sie verbunden sind, können
Sie tippen und Ihren Raspberry Pi direkt konfigurieren, ohne
eine Maus, Tastatur oder einen Bildschirm anschließen
Per Fernsteuerung
können Sie
Maus, Tastatur
und Bildschirm
eines anderen
Geräts mit Ihrem
Pi verwenden.
24

Grundlagen
Programmierbare Schnittstelle
Eine Anschlussart des Raspberry Pi unterscheidet
sich deutlich von den anderen: Es handelt sich
dabei um die Pins auf der Oberseite der Platine.
Das sind die Allzweckeingabe- und Allzweckausgabe-Anschlüsse
oder programmierbaren
Schnittstellen (engl.: General Purpose Input Output
Connectors, kurz GPIO), die etwa für spezielle
Hardwareprojekte oder zur Verbindung mit Zubehör
niedriger Stufe gedacht sind. Jeder Pin hat eine
eigene Funktion und kann über die Entwicklungsumgebung
oder mittels Programmiersprache
gesteuert werden. Sie können die Pins etwa dafür
benutzen, LEDs zu steuern oder Motoren, wenn
der Pi die Steuereinheit eines Roboters bildet.
Auf der Platine befinden sich 26 Pins (mit „P1“
gekennzeichnet), deren Funktion sich einhergehend
mit der Überarbeitung des Pi leicht verändert
hat. Daher müssen Sie wissen, welche Raspberry-
Revision Sie haben – falls Sie etwa vorhaben,
eine Tochterplatine zu kaufen, die direkt über die
GPIO-Pins angeschlossen wird. Jeder Raspberry
Pi, der Ende 2012 oder später hergestellt wurde,
gehört zur Revision 2. Die bekannteste Erweiterungsplatine
ist das Gertboard, das
dem Pi alle möglichen Arten von
programmierbarer Funktionalität
einbringt – etwa Motorsteuerung,
Digital-/Analog-Umwandler, zwölf
LED-Leuchten oder auch neue
Brücken und Anschlüsse. Allerdings
benötigen Sie zu Beginn
keine zusätzliche Platine, da die
Pins auch ohne Modifikationen zu
verschiedenen Zwecken genutzt
werden können. Das neueste
Update fügt der Platine eine
P5-Stiftleiste direkt neben den
P1-GPIO-Pins hinzu. Die acht
Pins sorgen für mehr Energie
sowie für vier zusätzliche
GPIO-Funktionen, die vor allem für die Bereitstellung
eines sekundären I 2 C-Kanals genutzt
werden können; I 2 C ist ein serieller Datenbus.
Sie können Platinen wie das Gertboard benutzen, die sich
über die GPIO-Pins mit dem Raspberry Pi verbinden lassen.
zu müssen. Wenn Sie ein grafisches Interface haben wollen,
können Sie auch ein Paket namens tightvncserver installieren
und den Befehl vncserver :1 ausführen, um einen ferngesteuerten
Desktop zu starten. Benutzen Sie einfach einen beliebigen
kostenlosen VNC-Client auf einem anderen Gerät, um sich mittels
der IP-Adresse und des Ports 5901 Ihres Raspberry Pi zu
verbinden. Danach können Sie Ihre Tastatur und Maus per Fernsteuerung
nutzen.
Falls Sie jedoch eine Maus und eine Tastatur direkt an den Pi
anschließen möchten,
„Falls Sie eine Tastatur anschließen
möchten, dürften Sie keine
großen Schwierigkeiten haben.“
dürften Sie keine allzu
großen Schwierigkeiten
haben. Die meisten
Modelle benutzen einen
USB-Standard, weswegen
Maus und Tastatur einfach
funktionieren werden – es sei denn, Sie kaufen etwas Exotisches
wie die neuesten kabellosen Microsoft- oder Logitech-
Modelle. Sie müssen allerdings – wie bereits gesagt – beide
Geräte über einen Hub mit externer Stromversorgung anschließen,
sodass sie nicht zu viel Energie vom Raspberry ziehen.
Falls Sie die Tastaturbelegung anpassen möchten, tippen Sie
sudo dpkg-reconfigure keyboard-configuration in die Kommandozeile
ein. Damit stellen Sie sicher, dass die Tasten Ihrer
Tastatur mit denen beim Pi übereinstimmen.
Display und Sound
Das Modell B des Raspberry Pi verfügt über zwei Anschlüsse,
über die man Videosignale zu einem Display senden kann. Der
gelbe Klinkenstecker dient zur Übertragung des zusammengesetzten
Videosignals (Composite Video) und kann an einer
großen Anzahl an Fernsehern angeschlossen werden, die normalerweise
einen gelben Anschluss für externe Kameras oder
Rekorder besitzen. Der gelbe Stecker befindet sich oft in der
Nähe eines roten und eines weißen Steckers, die zur Audioübertragung
(links/rechts) dienen. Versichern Sie sich, dass der
HDMI-Port frei ist, falls Sie den Composite-Video-Anschluss nutzen
wollen: Der Raspberry Pi stellt immer bevorzugt eine HDMI-
Verbindung her, wenn er eine entdeckt, und schaltet erst auf
Composite-Übertragung um, wenn er keine HDMI-Verbindung
findet.
Allerdings ist der gelbe Stecker nicht die erste Wahl – es sei
denn, Sie haben keine andere Option. Der moderne HDMI-
Anschluss ist viel besser für die Übertragung geeignet, und Sie
brauchen noch nicht einmal einen HDMI-Port an Ihrem Display,
um ihn zu benutzen. Der Videoteil des Signals, der über HDMI
übertragen wird, ist genau der gleiche wie das Videosignal, das
etwa über das übliche DVI-Kabel eines PC-Monitors übertragen
wird. Daher können Sie
einfach ein Kabel mit
einem männlichen DVI-
Anschluss der Variante
24+1 auf der einen Seite
und einem männlichen
19-Pin-HDMI-Stecker auf
der anderen nutzen. Oder Sie wählen einen Adapter mit einem
männlichen 19-Pin-HDMI-Stecker für den Raspberry Pi und
einem weiblichen DVI-Anschluss für die Verbindung über ein übliches
DVI-Kabel. Das alles mag jetzt sehr technisch und kompliziert
klingen, doch handelt es sich sowohl beim DVI- als auch
beim HDMI-Kabel und dem Adapter um übliche Teile, die Sie in
jedem Elektronikgeschäft günstig besorgen können. Da die
Kabel digitale Signale übertragen, lohnt sich die Investition in
spezielle Adapter oder Umwandler nicht – es gibt kaum Anhaltspunkte
dafür, dass solche Geräte die Signalstärke verbessern.
Ein weiterer Vorteil des HDMI-Anschlusses: Sie können darüber
auch die digitalen Audiodateien von Ihrem Raspberry Pi
übertragen. Ihr Fernseher oder Verstärker muss dieses Feature
unterstützen, damit es funktioniert, und Sie werden ein bisschen
an der Pi-Konfiguration herumspielen müssen, aber es ist
eine gute Lösung, wenn Sie Ihren Raspberry als Medienhub
benutzen wollen.
Ein HDMI-zu-DVI-Umwandler bringt Ihnen bei der Soundübertragung
nichts, da die Soundkomponente bei der Umwandlung
weggelassen wird, aber Sie haben immer noch den analogen
Audioanschluss zur Verfügung. Dessen Ausgabe ist zwar mit
Nebengeräuschen verbunden, aber immerhin gut genug, um
Videos zu einem Fernseher zu streamen.
25

Grundlagen
Fehlerbehebung:
In den allermeisten Fällen werden Sie diese beiden Seiten gar nicht benötigen
– Ihr Pi wird einfach starten. Falls es dennoch nicht klappen sollte, finden Sie
hier einige Hinweise zur Fehlerbehebung.
mit der richtigen Menge Strom versorgt wird. Selbst wenn Sie
keine Netzwerkverbindung haben oder die SD-Karte nicht angeschlossen
ist, sollte die LED während des gesamten Betriebs
leuchten. Im Falle eines Flackerns oder sogar eines Verlöschens
haben Sie ein Problem mit der Stromversorgung Ihres Geräts.
Überprüfen Sie in diesem Fall sowohl Stromkabel als auch
Netzteil. Ist Ihre SD-Karte angeschlossen, so sollte die äußerste
LED auf der linken Seite aufleuchten. Mit ihr wird die
Zugriffsaktivität auf der SD-Karte signalisiert.
Der große Unterschied zwischen Ihrem Raspberry Pi und
einem herkömmlichen PC ist die Tatsache, dass das Pi
kein BIOS besitzt. Das BIOS ist das Erste, was Sie beim
Start Ihres PCs sehen. In einem teilweise an vergangene DOS-
Zeiten erinnernden Bildschirm werden Ihnen Informationen über
Speicher, CPU und angeschlossene Festplatten angezeigt, allerdings
in einem kaum lesbaren Tempo. Dennoch spielt das BIOS
eine große Rolle bei der Suche nach Fehlern wie etwa einer
schadhaften CPU. Ein modernes BIOS meldet solche Probleme
nicht nur via Bildschirmtext, sondern auch über akustische
Signale und blinkende LEDs auf dem Motherboard. Ohne das
BIOS fehlt Ihnen beim Raspberry Pi also ein wichtiges Werkzeug
zum Erkennen von vermeintlichen Fehlern. Auch wenn Ihr Pi
beim ersten Mal ohne Weiteres booten wird, so steigt die Wahrscheinlichkeit
eines Problems während eines Startvorgangs,
je mehr Sie an der Funktionalität Ihres Geräts basteln. Und für
genau solche Probleme gibt es hier einige Lösungen.
Was die LEDs bedeuten
Die einzigen Hinweise, wie weit der Bootvorgang vorangeschritten
ist, erhalten Sie von einer Reihe LEDs neben dem Soundausgang
und dem USB-Port. Während das Modell B über fünf
LEDs verfügt, hat das Modell A nur zwei.
LED 1: Grün, „ACT“: SD-Kartenzugriff
LED 2: Rot, „PWR“: 3,3-Volt-Stromversorgung vorhanden
LED 3: Grün, „FDX“: LAN-Kabel angeschlossen
LED 4: Grün, „LNK“: Netzwerkaktivität
LED 5: Gelb, „100“: Mit 100-Mbit-Netzwerk verbunden
Da das Modell A über keine Netzwerkfunktionen verfügt, sind
die letzten drei LEDs auf dessen Platine nicht vorhanden. Auch
ist es möglich, dass bei älteren Modellen der B-Reihe die Bezeichnungen
der LEDs ein wenig anders lauten. Die Funktionen,
die sie beschreiben, bleiben trotzdem gleich.
Wenn Sie Ihr Pi an eine Stromquelle anschließen, sollte die
zweite LED rot aufleuchten. Dies zeigt Ihnen an, dass Ihr Gerät
Startvorgang
Beim Start Ihres Geräts wird diese LED kurz aufleuchten, verlöschen
und dann wieder flackern, während das Pi den Boot-Code
von der SD-Karte einliest. Passiert dies nicht, so ist es sehr
wahrscheinlich, dass entweder Ihr Boot-Code nicht richtig auf
die Speicherkarte geschrieben wurde oder aber die Speicherkarte
nicht mit Ihrem Pi funktioniert. Überprüfen Sie, ob Ihre
SD-Karte richtig angeschlossen ist und ob jeder SD-Mikroadapter,
den Sie benutzen, richtig mit der Karte verbunden ist.
Prüfen Sie auch, ob die Anschlüsse zwischen SD-Kartenadapter
und Konnektor des Pis identisch aussehen, da es hier in
seltenen Fällen zu Kompatibilitätsproblem kommt.
Weiterhin ist es auch möglich festzustellen, an welcher Stelle
des Bootvorgangs das Raspberry Pi abbricht. Im Anschluss
finden Sie eine Übersicht der verschiedenen Blinkmuster der
„ACT“/„OK“-LED und deren Bedeutungen. Beachten Sie jedoch,
dass diese Liste eine Firmware von mindestens Mitte 2012
voraus setzt und wir diese Informationen den Raspberry Pi-Foren
entnommen haben.
3-maliges Aufleuchten: loader.bin nicht gefunden
4-maliges Aufleuchten: loader.bin nicht geladen
5-maliges Aufleuchten: start.elf nicht gefunden
6-maliges Aufleuchten: start.elf nicht geladen
Im Rahmen eines Firmware-Updates vom Oktober 2012
wurden die Signale wie folgt neu zugeordnet:
3-maliges Aufleuchten: start.elf nicht gefunden
4-maliges Aufleuchten: start.elf nicht gestartet
7-maliges Aufleuchten: kernel.img nicht gefunden
Es ist möglich, diese Probleme dadurch zu beheben, dass
Sie auf ihrer Speicherkarte nach den oben genannten Dateien
schauen und sie auf ihre Richtigkeit überprüfen. Suchen Sie
nach etwas mit dem Namen Checksum und überzeugen Sie
sich davon, dass die Dateien auf der SD-Karte den gleichen
Checksum-Wert haben wie die Originaldateien.
Da aber solche Zugriffsfehler eher ein Hinweis darauf sind,
dass entweder die SD-Karte nicht richtig ausgelesen werden
kann oder aber das Betriebssystem Ihres Raspberry Pi nicht
richtig auf diese geschrieben wurde, empfehlen wir Ihnen, dass
Sie mit einer anderen Karte und einer anderen Methode der
Image-Erstellung – unsere Installationsanleitung beschreibt
Ihnen hierfür drei verschiedene Betriebssysteme – einen Versuch
wagen. Während unserer Installation stießen wir jedoch
26

Grundlagen
Booten
Die hellen LEDs
des Raspberry Pi
sehen nicht nur
schön aus, sondern
können auch bei
der Fehlerbehebung
wichtige
Hinweise liefern.
Die Abbildungen
zeigen eine ältere
Version der Platine,
auf der noch die
Bezeichnungen
„OK“ statt „ACT“
und „10M“ statt
„100“ neben den
entsprechenden
LEDs aufgedruckt
sind.
mit verschiedenen Kartenlesern auf Probleme. In vielen Fällen
handelte es sich hierbei um solche, die in Laptops oder Notebooks
verbaut waren. Daher empfehlen wir Ihnen, auf ein Einzelgerät
umzusteigen. Sollten Sie Ihr Pi an einen Bildschirm
angeschlossen haben, zeigen Ihnen aktuelle Versionen der
Firmware einen kaleidoskopartigen Startbildschirm. Sollte der
Startvorgang über diesen Bildschirm hinausgehen, aber nichts
weiter passieren, liegt das Problem wiederum bei Ihrer
Stromversorgung.
Netzwerk
Falls sich Ihr Raspberry Pi erfolgreich durch den initialen Startvorgang
gearbeitet hat, wird nun Ihr Betriebssystem von der
SD-Karte geladen. Hierbei sollte wegen des umfangreichen
Datentransfers die erste LED die meiste Zeit leuchten. Die
Geschwindigkeit des Bootvorgangs hängt zum größten Teil von
der Geschwindigkeit der SD-Karte ab. Kurz nachdem Linux beginnt
hochzufahren, blinkt zunächst die vierte LED („LNK“) und
leuchten etwa eine halbe Sekunde später auch die anderen
Netzwerk-LEDs. Dies zeigt an, dass die Netzwerkfunktionen
aktiviert sind und sich das Gerät an Ihrem Netzwerk anmeldet.
Die Netzwerk-LEDs sind vergleichbar mit denen auf der Netzwerkkarte
Ihres PCs und weisen somit eher auf Probleme Ihres
LAN-Netzwerks hin als auf Probleme mit der Konfiguration ihres
Raspberry Pi.
Die orangene LED signalisiert eine Full-Duplex-Verbindung.
Ob es sich bei Ihrer Netzwerkverbindung um eine Full- oder
Half-Duplex-Verbindung handelt, wird in dem Zusammenhang
wichtig, ob Ihr Raspberry Pi gleichzeitig senden und empfangen
kann. Auch wenn dies heutzutage in modernen Netzwerken nur
noch selten ein Problem darstellt, hat dies natürlich Auswirkungen
auf die Geschwindigkeit Ihres Geräts im Netzwerkverbund.
Die „LNK“-LED ist in Bezug auf das Netzwerk das Äquivalent
zu Ihrer „ACT“-LED für den SD-Karten-Zugriff, da diese durch
Blinken den Transfer von Daten im Netzwerk signalisiert. Sollte
diese LED aufleuchten, können Sie davon ausgehen, dass Ihr
Raspberry Pi in der Lage war, eine Verbindung zwischen Ihrem
Router und sich selber herzustellen. Allerdings nur mit einer
geringen Bandbreite, daher muss Ihre Netzwerkverbindung
noch keine ausreichende Funktionalität für das Surfen im Internet
und das Abrufen von E-Mails haben. Es ist durchaus möglich,
dass trotz offensichtlicher Aktivität Ihres Raspberry Pi das
Gerät selbst kein aktiver Bestandteil des Netzwerks ist. Sollten
Sie trotz blinkender LED keine wirklich funktionierende Verbindung
zu Ihrem Netzwerk aufbauen können, sollten Sie sich mit
der Konfiguration Ihres Netzwerks befassen. Überprüfen Sie
zuerst, ob Ihr Pi eine IP-Adresse von ihrem Router zugeteilt bekommen
hat und wiederholen sie den Vorgang im Betriebssystem
Ihres Raspberry Pi. In vielen Fällen kann das Betriebssystem
die Konfiguration selber vornehmen. In manchen
komplexeren Netzwerken, mit verschiedenen Domains oder
mehreren Routern, können aber durchaus Probleme auftauchen.
Versuchen Sie in diesem Fall zuerst, die direkteste und
einfachste Verbindung zu Ihrem Netzwerk aufzubauen, und
dann, sich in die komplexeren Bereiche vorzuarbeiten, bis Sie
die gewünschte Konfiguration gefunden haben.
Die letzte LED zeigt Ihnen die Geschwindigkeit Ihres Netzwerks
an. Sollte sie aufleuchten, erreicht Ihr Pi eine Geschwindigkeit
von 100 Mbps. Anders ausgedrückt sind das
100.000.000 Datenbits pro Sekunde. Dies ist natürlich bereits
ein gewaltiger Unterschied zu den 10 Mbps, mit denen Ihr Pi
läuft, wenn diese LED nicht leuchtet, doch arbeiten moderne
Netzwerke mittlerweile mit bis zu 1.000 Mbps. Der Grund,
warum Ihr Raspberry Pi nicht in der Lage ist, eine solche Gigabitverbindung
aufzubauen, ist die Tatsache, dass Ihr Ethernetadapter
über einen USB2-Port implementiert wird, welcher
die Transferrate auf 100 Mbps begrenzt. Dennoch reicht diese
Verbindungsgeschwindigkeit für die gängigsten Anwendungen
vollkommen aus. Ihr Raspberry Pi wird allerhöchstens an seine
Grenzen im Netzwerkbereich stoßen, wenn Sie ihn als Hochleistungs-NAS
oder zum gleichzeitigen Streamen mehrerer HD-
Filme benutzen wollen. Andernfalls wird Ihnen der Unterschied
in der Netzwerkgeschwindigkeit nicht auffallen und Sie können
Ihr Raspberry Pi einfach genießen.
27

Grundlagen
Befehlszeile: Erste
Lernen Sie die Befehlszeile Ihres Raspberry Pi kennen und entfesseln Sie
seine volle Funktionalität, ohne die Maus zu benutzen.
Interaktive Programme
Die meisten der Befehle, die wir hier
behandeln, sind nicht interaktiv. Das
bedeutet, man startet sie und wartet, bis
sie fertig ausgeführt sind. Es funktionieren
jedoch nicht alle Befehlszeilenprogramme
auf diese Weise. Als Sie beispielsweise
anfangs Raspbian hochgefahren haben,
wurde ein Config-Tool, das im Terminal
läuft, gestartet. Es gibt noch ein paar Programme,
die ähnlich funktionieren, dazu
zählen insbesondere die Texteditoren. Sie
ermöglichen ein Bearbeiten von Dateien
Wie Sie sicherlich schon festgestellt haben, hat das Pi-
Betriebssystem Raspbian eine mit Windows oder Mac
OS X vergleichbare Benutzeroberfläche. Die meisten
alltäglichen Aufgaben kann man innerhalb dieser Benutzeroberfläche
erledigen. Es gibt einen Dateimanager, Webbrowser, Texteditor
und viele weitere nützliche Anwendungen. Manchmal benötigt
man allerdings eine leistungsfähigere Zugriffsmöglichkeit,
und hier kommt die Befehlszeile – auch Kommandozeile, Terminal
oder Shell genannt – ins Spiel.
Die Befehlszeile ist eine komplett textbasierte Benutzerschnittstelle,
in die man Kommandos eingibt und daraufhin eine
Ausgabe erhält. Das mag für den Neuling zunächst etwas verwirrend
aussehen, doch so schlimm ist es gar nicht. Es lohnt
sich, ein wenig Zeit in das Erlernen dieses Steuerungsprinzips
zu investieren, denn dies wird sich später bezahlt machen.
Als Erstes muss man ein Terminal öffnen. Hierzu klickt man
auf LXTerminal auf dem Raspbian Desktop.
Die folgende Zeile sollte jetzt erscheinen:
pi@raspberrypi ~ $
ohne grafisches Benutzerinterface. Es gibt
einige recht komplizierte, die schwierig zu
erlernen sind, die aber wirklich interessant
werden, wenn man viel von der Befehlszeile
aus arbeitet. Es gibt aber auch einen
einfach zu bedienenden terminalbasierten
Texteditor namens Nano. Geben Sie im Terminal
nano ein, gefolgt von einem Dateinamen.
Dann können Sie im ausgegebenen
Text navigieren und Änderungen durchführen.
Speichern Sie alles mit Ctrl+X, und
kehren Sie zur Eingabeaufforderung zurück.
Das ist die Eingabeaufforderung. Wenn sie erscheint, heißt
das so viel wie: Das System ist startklar für Eingaben.
Geben Sie das Kommando pwd ein, und drücken Sie die
Enter-Taste. Folgendes sollte zu sehen sein:
/home/pi
Falls man seinen Benutzernamen geändert hat, sieht man
eine andere Zeile. Der eher kryptisch benannte pwd-Befehl
steht für „print working directory“ und gibt ganz einfach das
Verzeichnis aus, in dem man sich gerade befindet. Wenn Sie
das Terminal öffnen, startet es in Ihrem Home-Verzeichnis
(mehr dazu auf Seite 32 in diesem Heft).
Nun wissen wir also, wo wir uns befinden. Der nächste logische
Schritt ist, sich durch die Verzeichnisstruktur zu bewegen.
Hierzu verwendet man das Kommando cd („change directory“).
Geben Sie Folgendes ein:
cd ..
pwd
Das System sollte zu /home zurückkehren. Das kommt
daher, dass wir in das „ ..“-Verzeichnis gewechselt haben. Zwei
Punkte verweisen immer auf das übergeordnete Verzeichnis.
Um zum Home-Verzeichnis zurückzukehren, kann man cd pi eingeben.
Hierfür gibt es auch noch einen anderen Weg. Die Tilde
(das Zeichen „~“) verweist immer auf Ihr Home-Verzeichnis.
Wo auch immer man sich im Verzeichnisbaum befindet, gelangt
man über die Eingabe von cd ~ dorthin zurück.
Geben Sie nun ls ein, und drücken Sie die Enter-Taste. Dies
listet alle Dateien im aktuellen Verzeichnis auf. Einer der großen
Vorteile von Befehlen ist, dass wir festlegen können, wie
sie ausgeführt werden. Dies geschieht mit der Hilfe von Parametern,
die man nach dem Befehl setzt und die mit einem „-“
beginnen. Wenn man zum Beispiel alle Dateien im aktuellen
Verzeichnis auflisten möchte (einschließlich der versteckten,
die bei unixbasierten Systemen mit „.“ beginnen), nutzen wir
den Parameter -a. Schreiben Sie in Ihrem Terminal also ls -a.
Jetzt sollten mehr Dateien erscheinen. Ein anderer Parameter
für ls lautet -l. Dieser gibt uns weitere Informationen zu jeder
Datei. Man kann sogar Parameter kombinieren wie zum Beispiel
ls -al.
Welche Befehle sollte man kennen?
Sie fragen sich jetzt vielleicht, woher um alles in der Welt Sie
wissen sollen, welche Befehle und Parameter Sie für eine bestimmte
Aufgabe verwenden können. Es gibt eine gute und eine
schlechte Nachricht. Die gute ist, dass es normalerweise nicht
allzu schwierig ist, die Parameter für einen Befehl herauszufinden,
in aller Regel geht dies mittels -h oder --help. Wenn man
beispielsweise ls --help ausführt, erhält man eine lange Liste
von Parametern und deren Bedeutung, einschließlich der
folgenden:
-a, --all Auch mit Punkt beginnende Dateien anzeigen
…
-l Alle Dateidetails anzeigen
Die zweite Möglichkeit, Informationen zu einem Befehl zu
28

Grundlagen
Schritte
bekommen, ist die Verwendung von man. Dies ist die Abkürzung
für Handbuch (engl.: manual). Man gibt man gefolgt von dem jeweiligen
Befehlsnamen ein und erhält die Hilfe zu diesem Befehl.
Um die Hilfe für ls zu sehen, geben Sie man ls ein. Zum
Navigieren auf der Seite verwendet man die Aufwärts- und Abwärts-Pfeiltasten
oder – zum schnelleren Scrollen – die Bildnach-oben-
und Bild-nach-unten-Tasten. Um nach einem Wort
oder einer Formulierung auf der Handbuchseite zu suchen,
geben Sie / und dann den jeweiligen Suchbegriff ein. Mit den
Kommando /-l lassen Sie sich beispielsweise alle Stellen anzeigen,
wo -l vorkommt. Mit der N-Taste und Shift+N kann man
zwischen den Treffern vor und zurück navigieren.
Da wir noch weitere Befehle einführen, wäre es gut, wenn Sie
sich die Hilfe und die Handbuchseite ansehen und sich mit
ihnen vertraut machen. Natürlich können Sie auch immer einen
Befehl bei Google nachschlagen, falls Ihnen der Umgang mit
der textbasierten Hilfe nicht so sehr liegt. Allerdings werden Sie
schneller mit der Befehlszeile vertraut, wenn Sie mit dem Terminal
arbeiten.
Hilfefunktionen
Nun kommt aber noch die schlechte Nachricht. Es kann nämlich
manchmal knifflig sein, die richtigen Befehle zu finden,
wenn man nicht weiß, wie sie heißen. Dann ist die man-Stichwortsuche
eine nützliche Anwendung. Hierzu verwendet man
den Parameter -k („keyword“).
Um zum Beispiel nach allen Programmen zu suchen, die mit
dem Browser Ihres Systems zu tun haben, führen Sie man -k
browser aus. Sie werden sehen, dass dieser Befehl sowohl Programme
der grafischen Oberfläche als auch Befehlszeilenkommandos
auflistet. Das liegt daran, dass zwischen den beiden
kein wirklicher Unterschied besteht. Sie können Fenster vom
Terminal aus starten und manchmal sogar steuern.
Falls Sie Iceweasel (eine spezielle Version von Firefox) auf
Ihrem Pi installiert haben (dies gehört nicht zu den
Man kann sich sogar Filme in der Befehlszeile ansehen. Um
ein paar Klassiker zu streamen, geben Sie einfach telnet towel.
blinkenlights.nl ein und holen Sie sich Popcorn.
Tabulator-Vervollständigung
Wenn man mit langen Dateinamen
arbeitet, ist es anstrengend, sie jedesmal
neu zu schreiben, wenn man einen
Befehl mit Ihnen ausführen möchte.
Um das zu erleichtern, gibt es im Terminal
die Tabulator-Vervollständigung.
Wenn man also mit der Eingabe eines
Dateinamens beginnt und die Tabulator-
Taste drückt, versucht das System, den
restlichen Dateinamen zu ergänzen. Falls
es nur einen Dateinamen gibt, der mit
dem übereinstimmt, was bisher eingegeben
wurde, wird der restliche Dateiname
automatisch ergänzt (geben Sie cd /h
ein, und drücken Sie die Tabulator-Taste).
Falls es mehrere Dateinamen gibt,
erfolgt die Vervollständigung nur so
weit, wie diese übereinstimmen. Ein
wiederholtes drücken der Tabulator-
Taste zeigt die möglichen Optionen an
(geben Sie cd /m ein, und drücken
Sie die Tabulator-Taste zweimal).
vorinstallierten Programmen), dann können Sie TuxRadar.com
in einem neuen Reiter im geöffneten Iceweasel-Fenster mit dem
Befehl iceweasel - -new-tab www.tuxradar.com öffnen.
Hier noch in aller Kürze ein paar weitere nützliche Befehle:
rm löscht eine Datei. mkdir erzeugt ein neues Verzeichnis. Mit
cp kann man eine Datei an einen anderen Speicherort kopieren.
Dieser Befehl benötigt zwei Parameter (für die Originaldatei
und die neue Datei). cat gibt den Inhalt von einer oder mehreren
Textdateien aus. Der Befehl nimmt beliebig viele Parameter
und zeigt die Ausgabe direkt im Terminal an. less ist eine benutzerfreundlichere
Möglichkeit, sich Texte anzusehen, man
kann mit den Pfeiltasten rauf und runter scrollen. Um vom Programm
zurück zur Befehlszeile zu gelangen, drücken Sie die
Q-Taste. find ist ein nützliches Kommando, um Dateien auf
Ihrem Computer zu suchen. Sie verwenden ihn im Format find
location flags. Wenn Sie zum Beispiel alle Dateien auf Ihrem
Computer finden möchten, die tags zuvor geändert wurden,
führen Sie folgenden Befehl aus:
find / -mtime 1
Auf Seite 27 in diesem Heft finden Sie weitere Informationen
zur Benutzung dieses und der anderen genannten Befehle.
Mächtigere Funktionen
Bis hierher hätte man die entsprechenden Funktionen auch mit
der grafischen Benutzeroberfläche nutzen können, ohne sich
Befehle und Parameter merken zu müssen, doch jetzt kommen
wir zu den speziellen Stärken der Eingabe per Kommandozeile.
Wir beginnen mit den sogenannten Wildcards. Das sind Platzhalter,
die für beliebige andere Zeichen stehen können. Am besten
lässt sich dies an einigen Beispielen veranschaulichen.
Als Erstes erstellen wir dazu ein neues Verzeichnis und legen
darin ein paar leere Dateien an (Letzteres geht ganz einfach mit
dem Befehl touch, der eine leere Datei mit dem Namen eines
jeden angehängten Parameters erzeugt).
mkdir wildcards
cd wildcards
touch one two three four
touch one.txt two.txt three.txt four.txt
29

Grundlagen
sudo
Führen Sie ls aus, und schauen Sie nach, welche Dateien
sich in der neuen Verzeichnisstruktur befinden. Es sollten acht
sein.
Die erste Wildcard, die wir verwenden, ist „*“. Dieser Platzhalter
steht für eine beliebige Zeichenkette von null oder mehreren
Zeichen. Verwendet man ihn alleine, zeigt er alle Dateien in
der Verzeichnisstruktur auf. Probieren Sie es aus:
ls *
Das ist noch nicht besonders nützlich, doch wir können noch
weitere Zeichen hinzunehmen. Was denken Sie? Wird *.txt
funktionieren? Testen Sie, ob Sie richtig liegen:
ls *.txt
Was ist mit one*? Probieren Sie es auch hiermit.
ls one*
Die Wildcards können mit allen Befehlen der Kommandozeile
verwendet werden. Sie sind besonders nützlich zum Sortieren
von Dateien. Um alle .txt-Dateien in ein neues Verzeichnis zu
kopieren, könnten Sie folgende Befehle ausführen:
mkdir text-files
cp *.txt text-files
Ob alles geklappt hat, können wir folgendermaßen
überprüfen:
ls text-files/
Der zweite Platzhalter, den wir kennenlernen ist „?“. Er steht
für ein beliebiges einzelnes Zeichen. Was ergibt wohl:
ls ???
Raten Sie, und probieren Sie es einfach aus.
Wir können auch Platzhalter für bestimmte Zeichen festlegen.
[abc] steht für ein kleingeschriebenes A, B oder C. Was,
denken Sie, zeigt uns der Befehl ls [ot]* an? Versuchen Sie es!
ls [!ot]*
Welchen Unterschied hat das Ausrufezeichen ausgemacht?
Alles, was nicht mit einem kleingeschriebenem O oder T beginnt,
sollte aufgelistet werden.
man ist wahrscheinlich der wichtigste Befehl in jedem unixähnlichen System. Wenn man
ihn versteht, versteht man auch jeden anderen Befehl. Nehmen Sie sich Zeit, um mit seinem
Aufbau und seiner Sprache vertraut zu werden. Das wird Ihnen das Leben leichter machen.
Verwenden Sie den sudo-Befehl, um zwischen dem normalen
Benutzer „pi“ und dem Super-Anwender „root“ zu wechseln.
Ausgabeumlenkung
Die Befehle, die wir bisher verwendet haben, haben die entsprechenden
Ergebnisse im Terminal angezeigt. Meistens ist das
auch genau das, was wir beabsichtigen. Doch manchmal ist
eine andere Ausgabeform hilfreicher. Unter Linux hat man noch
zwei weitere Ausgabemöglichkeiten: in eine andere Datei oder
ein anderes Programm.
Um die Ausgabe in eine andere Datei umzulenken, verwendet
man das Zeichen „>“, gefolgt von dem Dateinamen. Führen Sie
folgende Befehle aus:
ls > files
cat files
Sie werden sehen, dass eine neue Datei namens files erzeugt
worden ist, die die Ergebnisse von ls enthält.
Die Möglichkeit, die Ergebnisse an ein anderes Programm zu
senden, ist eine weitere, wirklich nützliche Anwendung der
Linux-Befehlszeile, da man hier eine Reihe von Befehlen zusammenfassen
kann. Es gibt Befehle, die darauf ausgelegt sind,
auf diese Art verkettet zu werden. Hier ein einfaches Beispiel
dafür: Wenn Sie find / ausführen würden, würde Ihnen jede
Datei Ihres Systems aufgelistet. Dies wäre eine sehr lange
Liste von Dateinamen, die nicht auf eine Bildschirmseite passt.
Statt uns das Ergebnis direkt auf dem Bildschirm ausgeben zu
lassen, können wir jedoch die Liste an einen anderen Befehl
senden, der sie lesefreundlicher darstellt. Hierzu können wir
den less-Befehl verwenden, den wir weiter oben bereits kennengelernt
haben. Führen Sie Folgendes aus:
find / | less
Weiterführende Quellen
Sie kennen nun die Grundlagen der Eingabe per Befehlszeile.
Dieses Rüstzeug sollte Ihnen für den Anfang genügen, und wir
hoffen, dass Sie mit der Zeit die vielfältigen Möglichkeiten des
Terminals für sich entdecken.
Falls Sie mehr über die Benutzung der Befehlszeile erfahren
möchten (was wir natürlich sehr empfehlen), gibt es hierzu eine
Vielzahl von Quellen sowohl in gedruckter Form als auch online.
Eine gute Einstiegsmöglichkeit bietet www.linuxcommand.org.
Dort ist auch ein Link zu einer kostenlosen PDF-Version des
Buches The Linux Command Line zu finden.
Für die meisten Anwendungsfälle ist es für
Rasperry-Pi-Nutzer ausreichend, im Home-Verzeichnis
zu arbeiten (z.B. /home/pi). Man kann auch
die meisten anderen Dateien ansehen, aber nicht
ändern. Das Installieren von Software ist ebenfalls
nicht möglich. Linux beinhaltet nämlich ein
Berechtigungssystem, welches gewöhnliche
Nutzer davor bewahrt, versehentlich Systemeinstellungen
zu ändern. Möchte man jedoch
Systemeinstellungen ändern, kann man
/sudo nutzen und einen Befehl als Super-
User (manchmal auch als „root“ bezeichnet)
ausführen. Ein Super-User kann so ziemlich
alles ausführen. Sie müssen einfach nur
sudo vor den Befehl setzten. Zum Beispiel:
sudo apt-get install synaptic
Mit diesem Befehl wird das Paket synaptic installiert
und für alle Benutzer zugänglich gemacht.
30

Grundlagen
Die wichtigsten Befehle im Überblick
Navigation und Dateien
df -h zeigt die freie Speicherkapazität des Gerätes an.
pwd zeigt das Verzeichnis an, in dem man sich gerade
befindet.
cd Verzeichniswechsel. cd movies navigiert zum Verzeichnis
movies, mit cd ~ gelangen Sie in Ihr Home-Verzeichnis, mit cd /
zum Hauptverzeichnis und mit cd .. in die nächsthöhere
Verzeichnisebene.
ls Dateiliste für das aktuelle oder per Parameter angegebene
Verzeichnis. ls movies listet die Dateien des Verzeichnisses
movies auf, ls -a zeigt alle Dateien (auch die versteckten) an,
und ls -l zeigt zusätzliche Informationen zu jeder Datei an.
cp Kopieren. cp orig-file new-file kopiert orig-file zu new-file.
wget Download von Dateien aus dem Internet. Um die
Google-Homepage herunterzuladen, verwendet man
wget www.google.com
Dateien suchen
find . Nützliche Parameter sind:
-mtime zeigt alle Dateien an, die in den letzten
Tagen geändert wurden. Anstelle von kann
beispielsweise 2 (vor genau 2 Tagen), -2 (vor weniger als zwei
Tagen) oder +2 (vor mehr als zwei Tagen) stehen.
-name sucht Dateien mit dem Namen
.
-iname findet Dateien namens
ohne Beachtung der Groß- und Kleinschreibung.
-writable sucht alle Dateien, die beschreibbar sind.
Es können auch Parameter kombiniert werden. Zum Beispiel
listet find / -mtime -2 -writeable alle Dateien im Dateisystem
auf, die vor weniger als 2 Tagen geändert wurden und für den
aktuellen Benutzer beschreibbar sind.
Fernzugriff
ssh Loggen Sie sich auf einem entfernten Rechner über
Secure Shell (SSH-Protokoll) ein. ssh pi@192.168.1.2 wird
sich als Anwender „pi“ auf dem Computer mit der IP-Adresse
192.168.1.2 einloggen. Beachten Sie, dass dies nur funktioniert,
wenn auf dem Remote-Rechner ein SSH-Server läuft.
scp Secure Copy. scp pi@192.168.1.2:/home/pi
kopiert in das Verzeichnis /home/pi auf dem Rechner
192.168.1.2, und scp pi@192.168.1.2:/home/pi/
kopiert /home/pi/ von dem Rechner 192.168.1.2 in
das aktuelle Verzeichnis. Achtung, dies ist nur möglich, wenn
auf dem Remote-Rechner ein SCP-Server läuft.
Wildcards
* ist Platzhalter für eine beliebige Zeichenkette (auch leere).
? ist Platzhalter für ein einzelnes Zeichen.
[abc] ist Platzhalter für a, b oder c.
[!abc] ist Platzhalter für alle Zeichen außer a, b oder c.
[A-Z] ist Platzhalter für einen Buchstaben von A-Z
(großgeschrieben).
[A-z] ist Platzhalter für einen Buchstaben von A-z
(klein- oder großgeschrieben).
[eins, zwei] ist Platzhalter für die Wörter eins und zwei.
Informationen über den Computer
top zeigt das Programm an, das gerade die meiste CPU- und
Speicherkapazität benötigt.
uname zeigt Informationen zum Kernel an. uname -m zeigt
Informationen zur Hardware an.
lscpu gibt Informationen über die CPU aus.
dmesg gibt Kernel-Meldungen über den Bildschirm aus (und
kann hilfreich sein, um Hardwareprobleme zu identifizieren).
Textdateien
head gibt die ersten 10 Zeilen einer Textdatei auf dem Bildschirm
aus. Mit dem Parameter -n kann man die Anzahl 10
ändern Beispielsweise zeigt dmesg | head -n 15 die ersten
15 Zeilen einer Kernel-Meldung an.
tail zeigt die letzten 10 Zeilen einer Textdatei auf dem Bildschirm
an. Der Parameter -n kann wie gehabt verwendet werden.
Man kann auch Dateiänderungen mit dem Parameter -f („follow“)
verfolgen. So zeigt tail -n 15 -f /var/log/syslog die letzten 15
Zeilen der Log-Datei des Systems an und aktualisiert laufend die
Ausgabe bei Änderungen.
less ermöglicht das Scrollen innerhalb einer Textdatei.
cat gibt den Inhalt einer Textdatei im Terminal aus.
nano Das Programm Nano ist ein benutzerfreundlicher
Befehlszeilen-Texteditor (Ctrl+X schließt das Programm
und fragt ab, ob Änderungen gespeichert werden sollen).
Besondere Tastenkombinationen
Ctrl+C beendet jegliches Programm, das gerade im Terminal
läuft.
Ctrl+D sendet das Dateiendezeichen an jegliches Programm,
das gerade im Terminal läuft.
Ctrl+Shift+C kopiert ausgewählten Text in die Zwischenablage.
Ctrl+Shift+V fügt den Text aus der Zwischenablage ein.
Software installieren
./configure Wenn man den Quellcode eines Programms entpackt,
wird gewöhnlich ein neues Verzeichnis, das das Programm
beinhaltet, erstellt. Wechseln Sie in dieses Verzeichnis und führen
Sie ./configure aus, um zu kontrollieren, ob Ihr System über
alles Nötige zum Kompilieren der Software verfügt.
make kompiliert die Software.
make install (benötigt sudo) verschiebt die gerade kompi lierte
Software an einen geeigneten Ort im System, sodass man sie
wie einen normalen Befehl ausführen kann.
apt-get kann dazu verwendet werden, Software zu installieren
oder zu deinstallieren. So wird per sudo apt-get install iceweasel
das Programm Iceweasel (eine Variante von Firefox) installiert
und per sudo apt-get purge iceweasel wieder entfernt.
Mit apt-get update rufen Sie eine aktuelle Liste aller Datenpakete
von der Repository-Datenbank ab (eine gute Idee, bevor Sie irgendetwas
unternehmen), und apt-get upgrade führt ein Upgrade
aller Datenpakete aus, die in der Repository-Datenbank eine neuere
Version beinhalten.
apt-cache search sucht in der Repository-Datenbank
nach allen Paketen, die ein bestimmtes Stichwort
enthalten.
31

Grundlagen
Das Dateisystem:
Lernen Sie, wie Linux Dateien verwaltet und wie Sie zusätzliche Speichergeräte
zu Ihrem Raspberry Pi hinzufügen.
Mit dem nützlichen
Befehl df -h
kann man sich
anzeigen lassen,
welche Laufwerke
gerade an den
Raspberry Pi angeschlossen
sind.
Das Linux-Dateisystem ist unter dem Wurzelverzeichnis
(engl. root directory) aufgehängt, welches durch einen
Schrägstrich (/) symbolisiert wird. Wenn man das Dateisystem
mit einem Haus vergleicht, dann entspricht / der Haustüre,
durch die man ins Haus gelangt. Wir probieren das mal
aus. Hierzu öffnen wir ein Terminal und geben Folgendes ein:
cd /
ls
Uns werden daraufhin einige Dateien und Verzeichnisse ausgegeben.
In unserer Metapher entsprechen die Verzeichnisse
Türen zu weiteren Räumen. Der wichtigste Raum ist für die
meisten Anwender ihr Home-Verzeichnis, das wir uns ansehen
können, wenn wir folgende Befehle eingeben:
cd /home
ls
Haben Sie den / vor home bemerkt? Dieser bedeutet, dass
home sich im Wurzelverzeichnis (/) befindet. Dateipfade, die
mit / beginnen, werden als absolute Pfade bezeichnet. Über
den Befehl ls werden uns dann alle Dateien in /home angezeigt.
Für jeden angelegten Benutzer auf Ihrem Raspberry Pi
sollte es hier ein eigenes Verzeichnis geben. Zum Verzeichnis
des Benutzers pi gelangt man mit dem Befehl:
cd pi
Diesmal haben wir vor den Verzeichnisnamen kein / gesetzt.
Das heißt, dass sich das Verzeichnis des Benutzers pi im aktuellen
Verzeichnis befindet. In diesem Fall spricht man von
einem relativen Pfad. Wir hätten auch den absoluten Pfad mit
cd /home/pi aufrufen können.
Wenn wir uns das Dateisystem als Gebäudekomplex mit vielen
Zimmern vorstellen, so ist es wichtig zu wissen, dass sich
nicht alle Verzeichnisse auf demselben Speichergerät befinden.
Wir haben es also mit Zimmern in unterschiedlichen Gebäuden
zu tun, die durch Gänge miteinander verbunden sind. Für den
ungeübten Benutzer ist dies nicht zu erkennen. Im Fall eben
hätte sich das Benutzerverzeichnis pi auf einem physisch anderen
Laufwerk als home befinden können, und wir hätten es niemals
bemerkt. Wem die Verzeichnisstruktur von Windows mit
den getrennten Laufwerken vertraut ist, dem mag dies seltsam
vorkommen, doch es sorgt für deutlich mehr Flexibilität.
Um anzuzeigen, welche Geräte gerade an Ihr System
angeschlossen sind, geben Sie Folgendes ein:
df -h
Es werden eine paar Zeilen ausgegeben, deren erste Spalte
anzeigt, wo sich das Dateisystem befindet (dies ist nicht der
Pfad, an dem das Speichergerät eingebunden wird – also die
Tür in unserem Vergleich –, sondern die Datei für das interne
Dateisystem). Es gibt zwei unterschiedliche Typen: diejenigen,
die mit /dev/ beginnen, und welche, die anders anfangen.
Die Letzteren stellen keine echten Geräte dar, sondern vom
Betriebssystem erzeugte virtuelle Geräte, die virtuelle Dateien
mit Systeminformationen beinhalten. Schauen Sie sich zum
Beispiel einmal an, was sie unter /dev finden: für jede Hardware
Ihres Systems eine Datei, einschließlich aller Laufwerke.
Daher haben die Ausgabezeilen, die sich auf physische Geräte
beziehen, alle ein /dev/ in der ersten Spalte.
Die Geräte, die mit /dev/ beginnen, werden wiederum in
zwei Kategorien eingeteilt: solche, die mit /dev/mmcblk beginnen
(das sind die auf einer SD-Karte), und solche, die mit
/dev/sd beginnen (das sind die auf zusätzlichen Geräten).
Da wir die SD-Karte belassen, wie sie von Raspbian eingestellt
wurde, schauen wir uns einmal nur die mit /dev/sd Beginnenden
an (Achtung, Sie finden nur Einträge, wenn Sie zusätzliche
Speicher angeschlossen haben). Jedem Laufwerk wird
ein Buchstabe, bei A beginnend, zugeordnet. /dev/sda ist demnach
das erste Laufwerk, /dev/sdb das zweite usw. Zusätzlich
wird jede Partition eines Laufwerks durchnummeriert.
/dev/sda1 ist somit die erste Partition auf dem ersten Laufwerk
und /dev/sdb3 ist die dritte Partition auf dem zweiten
Laufwerk usw.
Speicher hinzufügen
Man kann seinen Raspberry Pi um zusätzlichen Speicher in so
ziemlich jeder Form ergänzen, sofern der neue Speicher über
einen USB-Anschluss verfügt. USB-Memory-Sticks und externe
32

Grundlagen
Speichergeräte
Man kann alle möglichen
externen Speichergeräte
an den Raspberry
Pi anschließen, doch sie
haben jeweils unterschiedliche
Einschränkungen.
Festplatten sind am gängigsten. Externe Festplatten sollten
allerdings über eine eigene Stromversorgung verfügen, da der
Raspberry Pi nicht dafür konzipiert ist, so viel Strom wie ein normaler
Computer über USB zu liefern. Wenn die externe Festplatte
also nur über einen USB-Anschluss und keinen externen
Stromanschluss verfügt, wird sie wahrscheinlich nicht funktionieren.
Mit einem USB-Hub mit externer Stromzufuhr kann man
sich hier wiederum behelfen. Ein Speicherstick benötigt nicht
so viel Strom und sollte über den USB-Anschluss des Pi funktionieren.
Wenn Sie jedoch auch noch eine Maus und eine Tastatur
verwenden möchten, benötigen Sie dennoch einen Hub, da
es nur zwei USB-Anschlüsse gibt.
Hier müssen wir jedoch darauf hinweisen, dass die USB-Anschlüsse
des RPi langsamer sind als bei den meisten Computern
und man nicht die gleiche Übertragungsgeschwindigkeit erwarten
darf. Besonders auffallen wird das bei USB 3.0-Geräten,
die bei einem RPi nur das Leistungsniveau von USB 2.0 erreichen
und darum weit langsamer funktionieren. Das ist der
Nachteil, der in Kauf genommen werden musste, um das Board
so klein und preiswert gestalten zu können.
Daten-Layout
Bisher haben wir das Wort Dateisystem verwendet, um damit
die Verzeichnisstruktur auf dem Computer zu benennen. Es gibt
jedoch noch eine weitere Bedeutung: die Art und Weise, wie
Daten physisch auf einem Speichermedium gespeichert werden.
Das ist wichtig, da jedes Laufwerk mit einem bestimmten
Dateisystem formatiert werden muss, bevor es funktioniert. Es
gibt eine Reihe verschiedener Dateisysteme: die einen werden
von Windows verwendet, die anderen von Mac OS X, und die
nächsten von anderen Systemen. Die gute Nachricht ist, dass
Linux mit fast allen kompatibel ist. Wenn man also ein Speichermedium
sowohl mit dem Pi als auch mit einem anderen
Computer, auf dem kein Linux läuft, verwenden möchte, so formatiert
man den Speicher am besten auf dem anderen Computer.
Wenn man es andersherum macht, muss man darauf achten,
den richtigen Dateisystemtyp für den Computer zu wählen.
Die meisten Speichergeräte sind mit FAT32 vorformatiert, was
von fast allen Geräten gelesen werden kann. Hierbei besteht
allerdings das Problem, dass sehr große Dateien nicht verwaltet
werden können (die Grenze liegt bei 4 GB). Wenn Sie jedoch
das Speichermedium nur mit Ihrem Raspberry Pi und anderen
Linux-Geräten verwenden wollen, dann erhalten Sie die beste
Leistung, wenn Sie es mit einem Linux-Dateisystem formatieren.
Das bekannteste Format ist ext4.
Wenn Sie das Speichergerät formatiert und angeschlossen
haben, öffnen Sie ein Terminal und geben Sie folgenden Befehl
ein:
df -h
Wurde eine Zeile ausgegeben? Wahrscheinlich nicht. Das
liegt daran, dass das Gerät zuerst eingebunden werden muss.
Dies können wir im Terminal erledigen. Als Erstes benötigen
wir einen „Mount-Point“. Das ist einfach ein Verzeichnis, das wir
als „Eingangstür“ zu unserem Speichergerät benutzen. Es kann
überall im Dateisystem liegen. Um die erste Partition des ersten
Geräts in dem Verzeichnis data im Home-Bereich des
Benutzers einzubinden, geben Sie folgende Befehle ein:
cd ~
mkdir data
sudo mount /dev/sda1 data
Natürlich wollen wir das nicht bei jedem Neustart unseres Pi
wiederholen, besonders dann nicht, wenn wir ihn ohne Tastatur
und Monitor verwenden möchten. Daher automatisieren wir die
Durchführung. Es gibt eine Datei, die Linux vorgibt, was es wo
einbinden soll. Diese heißt fstab und befindet sich in /etc. Um
sie in einem einfachen Befehlszeilen-Texteditor zu öffnen, geben
Sie im Terminal Folgendes ein:
sudo nano /etc/fstab
Die Datei beinhaltet eine Zeile für jede Partition auf jedem
eingebundenen Gerät. Jede Zeile besteht aus einer Serie von
durch einen Tabulator getrennten Werten, die dem System vorgeben,
was es ausführen soll. Damit unser Speichergerät beim
Neustart automatisch eingebunden wird, geben Sie in einer
neuen Zeile am Ende von fstab Folgendes ein (Achtung, das Verzeichnis
data muss wie im Beispiel zuvor bereits angelegt sein):
/dev/sda1 /home/pi/data
33

Grundlagen
Pakete: Software
Erfahren Sie hier, wie der Paketmanager von Raspbian, apt-get, von Online-
Repositorys Software herunterlädt und diese auf Ihrem System verwaltet.
Falls Sie an das Windows-Betriebssystem gewöhnt sind, ist
es für Sie vermutlich selbstverständlich, dass jede Software
ihren eigenen Installer mitbringt, der die richtigen
Dateien an die richtigen Orte kopiert. Linux arbeitet jedoch normalerweise
nach einem anderen Prinzip. Unter Linux gibt es
eine Systemkomponente, die man gemeinhin als Paketmanager
bezeichnet. Der Paketmanager holt und verwaltet die Software,
die Sie brauchen. Er verlinkt auf ein Repository („Lagerstätte“),
von wo er alle Programme herunterlädt. Da Linux auf Open-
Source-Software baut, werden Sie fast alles, was sie benötigen,
kostenlos in diesen Repositorys finden. Sie müssen sich auch
nicht darum kümmern, wo genau Sie die Installationsdateien
finden: Das alles erledigt der Paketmanager für Sie.
Es gibt mehrere Paketmanager für Linux. Raspbian benutzt
apt-get, Arch hingegen einen anderen. Falls Sie also letztere
Distribution auf Ihrem Raspberry Pi ausprobieren möchten,
müssen Sie sich mit der Software pacman auseinandersetzen,
die wir hier aber nicht behandeln.
Bevor wir anfangen, weisen wir darauf hin, dass Sie Ihren
Raspberry Pi mit dem Internet verbinden müssen. Da wir Software
aus dem Internet herunterladen werden, ist eine Verbindung
zum Internet für das Befolgen dieser Anleitung zwingend
notwendig.
apt-get ist ein Kommandozeilenprogramm, für das Sie ein
Terminal verwenden müssen (mehr zur Kommandozeile auf
Seite 24). Da die Verwaltung von Softwarepaketen das gesamte
System betrifft, müssen alle Befehle mit einem vorangestellten
sudo ausgeführt werden. Stellen Sie zunächst sicher, dass Sie
die aktuelle Software in Ihrer Paketliste zur Verfügung haben.
Führen Sie dazu folgenden Befehl aus:
sudo apt-get update
Da die gesamte Software über den Paketmanager verwaltet
wird, kann er alle Programme auf dem Rechner aktualisieren.
Sie müssen sich also nicht für jede Anwendung einzeln damit
befassen. Um alle Updates für die gesamte installierte Software
herunterzuladen und zu installieren, verwenden Sie den Befehl:
sudo apt-get upgrade
Das könnte ein Weilchen dauern, da Open-Source-Software
dazu neigt, recht oft aktualisiert zu werden.
Bei Linux installiert man – um in der Terminologie zu bleiben
– keine Anwendungen, sondern sogenannte Pakete. Diese
bestehen jeweils aus einem Satz Dateien, der zwar meistens
einem Anwendungsprogramm entspricht, jedoch nicht immer.
Ebenso gut kann es sich bei einem solchen Paket um Daten
für ein Spiel, eine Dokumentation oder ein Plug-in handeln.
Um mit apt-get Software zu installieren, müssen Sie den
Namen des Pakets kennen, das Sie installieren möchten.
Meist ist dieser offensichtlich, er muss aber vollständig richtig
sein, damit das Paket heruntergeladen werden kann. Falls Sie
sich nicht sicher sind, können Sie alle zur Verfügung stehenden
Pakete mit apt-cache durchsuchen. Probieren Sie beispielsweise
folgenden Befehl aus:
apt-cache search iceweasel
Diese Eingabe wird eine Liste von Paketen auswerfen, die mit
dem gesuchten Webbrowser (Iceweasel ist eine spezielle Version
von Firefox) zu tun haben. Um Iceweasel zu installieren, verwenden
Sie folgendes Kommando:
sudo apt-get install iceweasel
Sie werden feststellen, dass apt-get Sie um die Zustimmung
zur Installation einer Anzahl von Paketen fragt. Dabei handelt es
sich um die sogenannten Abhängigkeiten. Iceweasel benötigt
den Inhalt dieser Pakete, um zu funktionieren. Normalerweise
müssen Sie sich über die angezeigten Abhängigkeiten nicht den
Kopf zerbrechen – bestätigen Sie deren Installation einfach nur
mit „Y“, und der Paketmanager wird alles andere für Sie erledigen.
Allerdings gibt es Pakete, die eine große Anzahl von Abhängigkeiten
aufweisen und somit viel Speicherplatz benötigen.
Falls Ihre SD-Karte bereits relativ voll ist, sollten Sie gegebenenfalls
vor der Installation Platz schaffen.
Falls Sie Iceweasel und alle zugehörigen Pakete (sofern diese
nicht von anderen Paketen benötigt werden) wieder deinstallieren
möchten, erledigen Sie dies mit dem Befehl:
sudo apt-get purge iceweasel
Oft begegnen Sie Paketen, die ein -dev am Ende ihres Namens
aufweisen. Diese brauchen Sie nur, wenn Sie planen,
die Software selbst zu kompilieren. Normalerweise können Sie
solche Pakete ignorieren. apt-get ist ein großartiges Werkzeug,
lässt jedoch etwas an Benutzerfreundlichkeit zu wünschen
übrig. Es gibt aber auch grafische Tools zur Paketverwaltung.
Zwei davon sind Synaptic sowie der Raspberry Pi App Store
(siehe auch Seite 37). Synaptic funktioniert wie apt-get, hat
aber eine grafische Benutzeroberfläche. Sie können das Programm
mit sudo apt-get install synaptic installieren und mit
--where is synaptic starten. Im Raspberry Pi App Store finden
Sie nicht nur freie Software wie mit apt-get und Synaptic, sondern
auch kommerzielle Pakete, die Sie kaufen müssen. Der
App Store ist auf Raspbian vorinstalliert und kann über das entsprechende
Icon auf dem Desktop aufgerufen werden.
34

Grundlagen
sicher im Griff
Weitere Informationen
Synaptic
Mit Synaptic können Sie alles erledigen, was Sie auch mit dem
Kommando apt-get tun können, allerdings ist das grafische Interface
etwas einfacher zu verwenden. Das zeigt sich vor allem
beim Suchen von Paketen, da das Fenster die Ergebnisse übersichtlicher
als das Terminal aufbereitet.
Raspberry Pi App Store
Der Raspberry Pi App Store erlaubt es den Anwendern, die Software
zu bewerten. So sehen Sie sofort, wie gut sie von anderen
Nutzern eingeschätzt wird. Allerdings hat der App Store bei weitem
nicht den Umfang von apt-get oder Synaptic.
Software kompilieren
Manchmal benötigen Sie Pakete, die Sie nicht in einem Repository
finden und damit auch nicht mit apt-get installieren können.
In diesem Fall müssen Sie die Software selbst kompilieren.
Verschiedene Projekte verpacken ihre Software auf
verschiedenen Arten, aber normalerweise funktioniert folgende
Anleitung: Laden Sie sich den Quellcode von der Website des
Projekts herunter und entpacken Sie ihn. Meist endet der Dateiname
mit .tar.gz oder .tgz. Falls das zutrifft, entpacken Sie die
Datei mit:
tar zxvf
Falls der Name der Datei mit .tar.bzip2 endet, ersetzen Sie
zxvf durch xjf. Das sollte ein neues Verzeichnis anlegen, das
Sie mit cd aufrufen. Hier hoffen wir darauf, dass eine Datei mit
dem Namen INSTALL zu finden ist, die Sie mit less INSTALL
lesen können. Das sollte Ihnen alles Nötige verraten, um mit
der Installation fortfahren zu können. Oft (aber nicht immer) ist
der Weg der folgende:
./configure
make
sudo make install
Die erste Zeile überprüft, ob auf Ihrem System alle notwendigen
Abhängigkeiten vorhanden sind. Falls die Überprüfung fehlschlägt,
müssen Sie sicherstellen, dass alle nötigen -dev-Pakete
vorhanden sind.
Falls sich alle Befehle ohne Fehler ausführen lassen, ist die
Software installiert und bereit zur Verwendung. Dieser Weg ist
aber wesentlich fehleranfälliger als die Benutzung eines Paketmanagers.
apt-cache in
einer Kommandozeile
zeigt Ihnen
eine Liste aller
erhältlichen
Pakete an.
Synaptic stellt
Ihnen ein einfach
zu verwendendes
Front-End für den
apt-Paketmanager
zur Verfügung.
35

Grundlagen
Add-ons für den
Raspberry Pi
Entdecken Sie die Extras und Erweiterungen und werden Sie zum Bastler!
Der Raspberry Pi ist vermutlich das erfolgreichste
IT-Produkt, das in den
letzten zehn Jahren aus Großbritannien
gekommen ist, allerdings wohl auch eines
der am meisten missverstandenen. Viele Leute
scheinen der Meinung zu sein, beim Raspberry
Pi handele es sich um nichts weiter als einen
preisgünstigen Desktop-Computer. Wenn man
sich allerdings die in dem Fall zusätzlich erforderliche
Peripherie wie Monitor, Tastatur,
Maus und SD-Karte zulegt, kommt man preislich
fast an einen billigen Laptop heran – und
hat dann auch noch einen Rechner mit im Vergleich
dazu wesentlich weniger Leistung.
Was ist es also, das den Raspberry Pi dennoch
zu einem Schnäppchen werden lässt?
Es ist der Formfaktor! Das Gerät ist klein, ist
mit ein paar Batterien oder Solarzellen zu betreiben
und besitzt überdies eine Reihe
GPIO-Pins (Kontaktstifte mit integrierten
Schaltkreisen zur Allzweckein- und -ausgabe).
Diese Dreierkombination hat es im Computerbereich
so noch nicht gegeben, jedenfalls nicht
zu diesem ansprechenden Preis.
Der Raspberry Pi ist also nicht einfach ein
neues Gerät, sondern eine vollkommen neuartige
Geräteklasse, und das wird der Grund
sein, dass vielen sein Zweck noch nicht so
ganz klar ist. Allerdings bessert sich die Lage
rapide, denn mit dem durchschlagenden Erfolg
des Pi werden auch seine wahren Möglichkeiten
immer mehr Menschen bewusst.
Fast täglich, so kommt es einem vor, gibt es
Meldungen über ein weiteres Gerät, das an
den Pi angeschlossen werden kann und damit
neue Funktionen und Features herauskitzelt.
Viele dieser Geräte werden nicht von großen
Firmen entwickelt, sondern von Bastlern und
Hobbyschraubern, die eine Idee haben und sie
in die Tat umsetzen.
Auf den folgenden Seiten werfen wir einen
Blick auf drei ganz besondere Add-ons: das
Multifunktions-LED-Display Pi Lite, das Pi-Kameramodul
und die GPIO-Erweiterungen von
Quick2Wire.
„Was ist es, das den Raspberry Pi zu
einem Schnäppchen werden lässt?
Es ist der Formfaktor!“
36

Grundlagen
Pi Lite
Ein Multifunktions-LED-Display.
Die Leute von Ciseco hatten einen interessanten Einfall:
Was, wenn man eine Ladung LEDs auf eine Platine
packen und eine simple Technik kreieren würde,
diese anzusprechen? Das Ergebnis ist das Pi Lite mit 126
roten Lämpchen, für die Zukunft ist auch eine Version mit
weißen LEDs geplant. Damit lässt sich alles Mögliche anstellen.
Das Pi Lite wird an die GPIO-Pins des Raspberry Pi angeschlossen
und nimmt passgenau und platzsparend ein
Stockwerk über der Pi-Platine Platz (siehe Abbildung).
Das Pi Lite ist zwar kein Plug-and-Play-Gerät, doch es erfordert
nur ein wenig Konfigurationsarbeit, bevor es bereit
zum Einsatz ist. Eine Anleitung hierfür finden Sie auf
http://bit.ly/1c0GOY1. Die Einrichtung dürfte eine Sache
von zehn Minuten sein, allerdings benötigen Sie eine Netzwerkverbindung,
um ein wenig Software herunterladen zu
können. Das könnte sich bei einem Raspberry Pi Modell A
als schwierig erweisen.
Wenn Sie das Pi Lite eingerichtet haben, können Sie es
über den seriellen Anschluss des Raspberry Pi ansteuern.
Tippen Sie
minicom -b9600 -o -D /dev/ttyAMA0
in die Kommandozeile, und Sie erhalten eine Schnittstelle zu
der LED-Platine. Alles, was Sie nun schreiben, scrollt als rote
Lichtpunkte über das Pi Lite. Das ist an sich schon mal cool,
aber mit dem Pi Lite lässt sich noch viel mehr machen. Statt
Text können Sie auch Befehle an das Gerät senden. Die Befehle
beginnen immer mit drei Dollarzeichen, so wie in diesem
Beispiel:
$$$ALL,ON
Mit diesem Kommando werden alle Pixel auf dem Pi Lite aktiviert.
Es lassen sich außerdem vertikale und horizontale Linien
darstellen und die Pixel auch einzeln ansprechen. Letzteres
könnte dann etwa so aussehen (1 = an, 0 = aus):
$$$F00000000000000000000011100001111111001111111011
111111111110111111110111101100011001100011000000000
0000000000000000000000000000
In diesem Modus lassen sich Bilder erzeugen, wobei es aber
sinnvoll ist, dies mithilfe von Skripten zu automatisieren. Da
die gesamte Kommunikation mit dem Pi Lite über den seriellen
Anschluss des Raspberry Pi läuft, können Sie es mit jeder
Sprache ansteuern, die die serielle Kommunikation
unterstützt.
Für den Einstieg am besten geeignet ist vermutlich die Programmiersprache
Python (mit dem seriellen Modul). Auch
hierzu gibt es direkt von Ciseco einige einführende Beispiele:
http://bit.ly/19C3Sve.
Da das Pi Lite über einen seriellen Anschluss angesteuert
wird, ist es sehr portabel und lässt sich über jedes Gerät mit
entsprechenden Fähigkeiten betreiben, also außer dem
Rasp berry Pi auch über einen Linux-PC oder fast jeden anderen
Computer (gegebenenfalls per USB-FTDI-Verbindung).
Eventuell müssen Sie dafür zum Lötkolben greifen.
Testmöglichkeit vor dem Kauf
Falls Sie sich erst einmal anschauen möchten, wie das Pi Lite
funktioniert, bevor Sie eine Kaufentscheidung treffen, können
Sie den von Ciseco unter http://bit.ly/14Li3d4 zur Verfügung
gestellten Emulator nutzen.
Das Pi Lite hat übrigens noch ein weiteres Ass im Ärmel:
Es betreibt die LEDs mit einem ATMEGA-Chip, der zur selben
Familie gehört wie die Prozessoren, die in den beliebten Arduino-Boards
verbaut werden, und es wird mit einem Arduino-Bootloader
ausgeliefert. Mit anderen Worten, Sie können
den Mikrocontroller auf dem Bord beliebig programmieren.
Sie könnten das Pi Lite sogar allein für sich, ohne Anschluss
an irgendeinen anderen Rechner, betreiben. Da die
Platine Zugang zu den fünf Analog-Inputs des ATMEGA gewährt,
können Sie diese mit ein bisschen Programmierarbeit
für Ihr Projekt nutzbar machen. Dies ist etwas komplexer als
die Standardverwendung des Pi Lite, aber es ist ein tolles Beispiel
dafür, wie ein einzelnes Stück Hardware dabei helfen
kann, eine breite Palette technischer Fähigkeiten zu
entwickeln.
Laufschriften,
Benutzerschnittstelle
im Stil der
1980er Jahre, die
Digitalkamera
mit der niedrigsten
Auflösung
der Welt – was
werden Sie mit
dem Pi Lite
anstellen?
37

Grundlagen
Kameramodul
Fotografieren mit dem Pi.
Hier ist zu
sehen, wie das
Kameramodul
per Flachbandkabel
mit dem
Raspberry Pi
verbunden wird.
Bevor wir darüber sprechen, was das Kameramodul
kann, sollten wir vielleicht darüber sprechen, was es
nicht kann: Falls Sie nach einer billigen Webcam Ausschau
halten, mit der Sie Videotelefonate per Skype führen
können, ist das Pi-Kameramodul nicht das Richtige für Sie.
Allein schon, weil Skype sowieso nicht auf dem Gerät läuft.
Das Kameramodul lässt sich einfach bedienen, jedoch nicht
im Sinne von „einstöpseln und Grafik-Tools benutzen“ – es
handelt sich vielmehr um eine programmierbare Kamera.
Das Kameramodul ist mit einer Flachbandschnittstelle
ausgestattet, die beim Raspberry Pi in den vertikal angeordneten
Anschluss zwischen dem Ethernet-Port (beziehungsweise
der entsprechenden Aussparung beim Modell A) und
dem HDMI-Port gesteckt wird. Wenn das Flachband eingerastet
ist, prüfen Sie, ob Sie die neueste Version von Raspbian
installiert haben, und zwar mit folgendem Kommando:
sudo apt-get update
sudo apt-get upgrade
sudo rpi-update
Lassen Sie danach raspi-config laufen, und achten Sie darauf,
dass die Kamera aktiviert ist. Zuletzt führen Sie einen
Neustart durch, und schon kann es losgehen. Die Steuerung
der Kamera basiert auf zwei Befehlen, raspistill und raspivid.
Mit dem ersten nehmen Sie Fotos, mit dem zweiten Videos
auf. Um einen Schnappschuss zu machen, tippen Sie:
raspistill -o image.jpg
Das ist natürlich nur der erste Anfang, denn spannend wird
es dadurch, dass Sie die Befehle – die ja direkt per Kommandozeile
eingegeben werden – in Ihre Programme integrieren
können. Falls Sie beispielsweise stets unsicher sind, welchen
Weißabgleich Sie verwenden sollen, können Sie alle zusammen
verwenden, etwa mit folgendem Python-Skript:
from subprocess import call
for awb in [‘off’,’auto’,’sun’,’cloud’,’shade’,’tungsten’,’fluoresce
nt’,’incandescent’,’flash’,’horizon’]:
call([“raspistill -n -awb “ + awb + “ -o image” + awb + “.jpg”],
shell=True)
Wie Sie sehen, können Sie das Kameramodul aus Python heraus
kontrollieren, obwohl keine Python-Sprachanbindung
vorliegt, nämlich mithilfe eines System Calls. Dies funktioniert
mit den meisten Programmiersprachen, daher können
Sie beinahe beliebig draufloshacken. Da alle Optionen als
Kommandozeilen-Switch realisiert werden können, ist es
recht einfach, die gewünschten Optionen in den System Call
einzubauen. Wie wäre es mit einem Stop-Motion-Cartoon?
raspistill -ifx cartoon -ISO 800 -tl 100 -t 10000 -w 300 -h 300
-o test_%04d.jpg
Hier werden diverse Kommandozeilenoptionen benutzt. -ifx
steht für Image Effects, also Bildeffekte, und bietet etliche
Möglichkeiten. Im Beispiel werden die Aufnahmen im Cartoon-Stil
gerendert. Mit -ISO legen Sie die Filmempfindlichkeit
fest. Mit -t1 wird die Unterbrechungszeit in Millisekunden
eingestellt und mit -t die Gesamtzeit des Aufnahmezyklus. -w
und -h stehen für Breite und Höhe des Bildes in Pixeln, und -o
bezeichnet den Dateinamen des Fotos (wobei _%04d eine
Zahl darstellt, die mit jedem Bild hochgezählt wird).
Um sich eine vollständige Liste aller Optionen der Kamera
anzeigen zu lassen, geben Sie einfach raspistill in die Kommandozeile
ein. Einige der Optionen erfordern für den sinnvollen
Einsatz ein wenig Erfahrung im Fotografieren.
Nun kommen wir zur Videofunktion. Mit dem Befehl raspivid
können Sie eine Aufnahme anfertigen:
raspivid -t 5000 -o video.h264
Auch bei der Videofunktion haben Sie etliche Optionen, die
den Foto-Optionen ähneln.
Im Internet sind Anleitungen und Vorschläge zu einigen interessanten
Projekten mit dem Pi-Kameramodul zu finden.
Wie wäre es etwa mit einer Gesichtserkennung mithilfe von
OpenCV? Näheres finden Sie unter http://bit.ly/1ap4S7G.
Andere Kameras
Webcam oder DSLR anschließen
Bislang ist die offizielle Raspberry-Pi-Kamera das einzige
Kameramodul, das sich mit dem vertikalen Anschluss
verbinden lässt. Allerdings kann der Raspberry Pi auch via
USB eine Kamera ansprechen, und hier sind die Möglichkeiten
weitaus größer. Nicht alle Webcams werden funktionieren,
aber es sind bereits mehr, als auf der Liste unter
http://elinux.org/RPi_USB_Webcams verzeichnet
sind.
Auch gewöhnliche Digitalkameras können Sie mithilfe
von gPhoto2 ansteuern. Die meisten aktuellen Modelle
werden bis zu einem gewissen Grad unterstützt, aber oft
stehen nicht alle Features zur Verfügung (beispielsweise
Fernsteuerung). Bilder herunterladen geht aber bei so
ziemlich jeder Kamera. Weitere Infos erhalten Sie auf
www.gphoto.org und www.gphoto.org/doc/remote/.
38

Grundlagen
GPIO-Expander von Quick2Wire
Zusätzliche Anschlüsse für den Raspberry Pi.
Ein Hauch von
Retro-Schick
dank bunter
Flachbandkabel.
Allerdings lassen
sich einige
Gehäuse für
den Raspberry
Pi nicht damit
kombinieren.
Eins der genialsten Features des Raspberry Pi sind die
direkt zugänglichen GPIO-Pins, die den Anschluss beliebiger
Schaltkreise ermöglichen. Diese Kontaktstifte
sind einfach zu benutzen und einfach zu verstehen: Mit einer
einzigen Befehlszeile in Python oder Bash lassen sie sich einund
ausschalten oder kann Input ausgelesen werden.
Allerdings gibt es auch einige Unzulänglichkeiten bei den
GPIO-Pins: So sind nicht alle Pins tatsächlich benutzbar, es
existieren keine Analog-Inputs und -Outputs, und die Kontaktstifte
sind sehr empfindlich und können den gesamten
Raspberry Pi zerstören, wenn etwa die falsche Spannung angelegt
wird.
Mehrere Firmen haben Produkte entwickelt, um hier Abhilfe
zu schaffen. So gibt es etwa von Ciseco das Slice of Pi –
ein Board mit Zugriff auf 16 GPIOs, die geschützt sind und sowohl
mit 3 V als auch 5 V arbeiten. Das PiFace fügt ein paar
nützliche Features wie Knöpfe, LEDs und Relays (zum Beispiel
zur Motorsteuerung) hinzu. Das Gertboard bietet ein
breites Spektrum an Input- und Output-Lösungen, und man
kann sogar ein Arduino anschließen und die Anschlüsse
damit steuern (allerdings erfordert dies einiges Programmieren
in C).
GPIO-Erweiterung
Besonderes Augenmerk möchten wir hier auf die Boards von
Quick2Wire legen. Quick2Wire bietet eine Platine mit Schnittstellen
für die seriellen Datenbusse I2C und SPI an, bei der
ein Schutzmechanismus für den Raspberry Pi sowie Spannungswählschalter
enthalten sind. Auch Boards mit GPIO-
Ports und analogen Input- und Output-Anschlüssen sind
„Es gibt eine Fülle von
Zubehör und Erweiterungen
für den Raspberry Pi
auf dem Markt.”
erhältlich. Die Platinen können sogar in Reihe geschaltet werden.
Bei den angebotenen Sets muss man selbst eine Menge
Lötarbeiten durchführen, doch danach lassen sich die Boards
einfach per Flachbandkabel anschließen.
Doch auch auf der Softwareseite ist noch einiges an Arbeit
erforderlich, bis die Quick2Wire-Boards mit dem Raspberry
Pi laufen. Unter Umständen müssen einzelne Kernelmodule
konfiguriert werden. Unter http://quick2wire.com/
articles/beta-kit finden Sie eine Anleitung. Diese ist jedoch
unvollständig, darum konsultieren Sie auch https://github.
com/quick2wire/quick2wire-python-api – dort finden Sie
den Ort der Python-Bibliothek. Nach geglückter Installation
des Quick2Wire-Boards kann man mithilfe von Python spannende
Dinge damit anstellen.
Welches der hier genannten GPIO-Zubehöre am besten für
Ihr Projekt geeignet ist, hängt von den jeweiligen Erfordernissen
ab. Das Slice of Pi von Ciseco ist ein preisgünstiges Produkt,
das Ihren Raspberry Pi in puncto GPIO-Verwendung
schützt, das PiFace eignet sich besonders gut zum allgemeinen
Experimentieren im Bereich des Physical Computing,
und die Platinen von Quick2Wire sind unglaublich nützlich,
wenn Sie I2C oder SPI benötigen, um Peripheriegeräte und
Port-Expander in Reihe zu schalten.
Noch mehr Extras
Zubehör und Ausbausets
Derzeit gibt es eine überwältigende Fülle von
Zubehör und Erweiterungen für den Raspberry Pi
auf dem Markt, beispielsweise von Adafruit
(www.adafruit.com/distributors/) oder Pimoroni.
Neben den allgemeinen Zubehörprodukten gibt es auch
viele speziellere Dinge. Als Beispiel sei das faszinierende
BrewPi (brewpi.com) genannt, mit dessen Hilfe man
selber Bier brauen kann. Sogar ein Arcade-Automat
namens Picade ist in Vorbereitung; die zugehörige
Kickstarter-Kampagne wurde erfolgreich abgeschlossen.
39

Projekte
40

Projekte
Projekte
Der erste Schritt beim arbeiten mit dem
Raspberry Pi ist die Wahl des Betriebssystems.
Es folgt die Wahl eines Projektes, denn der Pi
soll ja auch Nutzen bringen. Vielleicht haben Sie ja
sogar Muße, selbst eigene Projekte anzugehen?
Betriebssysteme für den Raspberry Pi.......................................42
Betriebssystem: Raspbian....................................................................48
Zünde den Raspberry-Booster...........................................................54
Arch Linux...........................................................................................................62
System: Eigene Distribution.................................................................66
XBMC enthüllt.................................................................................................70
Auto-Backups per Bash-Skript............................................................74
dnsmasq: DNS servers...........................................................................78
Syslog: Loggen per E-Mail.....................................................................80
Desktop: Eigene Schreibtische.........................................................82
41

Roundup Projekte
Office suites
Im Vergleich
Betriebssysteme für
den Raspberry Pi
Wir stellen Ihnen eine feine Auswahl empfehlenswerter
Betriebssysteme für Ihren Raspberry Pi vor.
Das sind unsere
Testkriterien
Es gibt zwei Modelle des Raspberry
Pi, das Modell A und das Modell B,
und vom Modell B wiederum zwei
Versionen – eine ältere mit
256 MB und eine neuere mit
512 MB Speicher. Um einen gründlichen
Blick auf die unterschiedlichen
Betriebssysteme werfen zu
können, haben wir diese jeweils auf
eine SD-Karte mit 4 GB Speicher
installiert und mit beiden Versionen
von Modell B ausprobiert.
Im Rahmen unseres Tests prüfen
wir die Installation, die vorinstallierte
Software, die Medienwiedergabe
„out of the box“ sowie das Design
und die Handhabung. Daneben
sind die Quellcode-Offenheit des
jeweiligen Betriebssystems sowie
dessen Community weitere Kriterien.
Wir schauen uns das Thema
zudem aus der Sicht von Nutzern an,
die noch nicht mit Linux vertraut sind.
Unsere
Auswahl
Raspbian
Risc OS
Plan 9
Android
Arch
Das Phänomen Raspberry Pi
(RPi) scheint nicht aufzuhalten
zu sein, wie eine Lokomotive
rast es vorwärts und erkämpft
sich einen Platz in den Annalen. Kein
Wunder: Die Hardware des Computers
ist genau auf die Nutzerbedürfnisse
zugeschnitten, der Preis lässt
keine Wünsche offen, und die Vielseitigkeit
von Linux rundet das Ganze
perfekt ab.
Die meisten RPi-Neukäufer installieren
wie auf der offiziellen Website der
Raspberry Pi Foundation empfohlen
das Betriebssystem Raspbian (eine
Linux-Distribution) auf ihrem Rechner.
Damit können sie dann zum Beispiel
den armen kleinen RPi passend programmieren
und einrichten und ihn an
einem Wetterballon befestigt zum äußeren
Rand der Atmosphäre hinaufschicken.
Viele Nutzer des Raspberry Pi wissen
jedoch vermutlich gar nicht, dass
es außer Raspbian noch eine Menge
anderer Betriebssysteme für ihren
Computer gibt. Diesen Nutzern möchten
wir auf den folgenden Seiten eine
feine Auswahl verschiedener Systeme
vorstellen.
„Viele Nutzer wissen nicht, dass es außer
Raspbian noch viele andere Betriebssysteme
für ihren Computer gibt.“
42

Projekte
Installation
Einfach oder kompliziert?
Wie man ein Abbild (Image)
eines Betriebssystems installiert,
ist auf der Webseite
elinux.org/RPi_Easy_SD_Card_Setup
gut dokumentiert. Dort finden Sie
alles Notwendige, um das Image auf
die SD-Karte zu ziehen. Der Vorgang
ist schnell erledigt. Anschließend setzen
Sie die Speicherkarte ein, schalten
den Strom ein, und der Spaß kann
beginnen.
Die fünf von uns getesteten Betriebssysteme
haben alle ihre Eigenheiten,
wenn es darum geht, dem
Nutzer eine grafische Oberfläche
(GUI) während der Installation zu bieten.
Eine GUI ist an sich nicht zwingend
notwendig bei der Installation,
hilft aber insbesondere Linux-Neulingen.
In der Disziplin, neue Nutzer behutsam
an Linux heranzuführen, war
Raspbian einst einsame Spitze, doch
die anderen Systeme holen allmählich
auf.
Nehmen wir hier Risc OS als Beispiel:
Ist es einmal auf der SD-Karte
und gebootet, sehen wir sogleich eine
farbenfrohe und freundliche GUI mit
detaillierten Benachrichtigungen über
den Bootvorgang und das Setup. Von
dort aus starten Sie die Konfiguration
und führen Änderungen aus, falls
gewünscht.
Bei Arch Linux für RPi sieht die
Sache schon anders aus. Nach dem
Booten finden Sie sich in einer Terminal-Umgebung
wieder. Dort sollen Sie
das Betriebssystem herunterladen, installieren
und einrichten. Wenn Sie
Arch erst einmal eingerichtet haben,
dann ist es eines der besten verfügbaren
Betriebssysteme. Es sind jedoch
einige Kniffe nötig, bis Sie zum fertigen
Desktop kommen.
Android für den RPi nimmt allmählich
Gestalt an. Ist das System hochgefahren,
sehen Sie den offiziellen
Sperrbildschirm von Android. Darauf
folgt die konventionelle Android-Oberfläche,
wie viele Smartphone- und Tablet-Nutzer
sie kennen. Das RPi-Android
hat noch einige Bugs und stürzt
öfters ab. Dazu ist es langsam, fast
ungeeignet für die 256-MB-Version
Raspbian ließ sich einst mit Abstand am einfachsten installieren.
Doch der Wettbewerb scheint aufgeholt zu haben.
des RPi. Auf dem neueren Modell läuft
es ein wenig besser.
Plan 9 bietet eine effektive Benutzeroberfläche
und ist gut dokumentiert,
fordert aber eine steile Lernkurve
vom Nutzer.
Raspbian bietet ein textbasiertes
Menü beim Bootvorgang. Sie können
das System konfigurieren, SSH-Zugriff
aktivieren und das System automatisch
in die nutzerfreundliche
LXDE-GUI booten lassen.
Wir empfehlen Raspbian oder Risc
OS für Einsteiger und Arch für
Fortgeschrittene.
Wertung
Raspbian
Risc OS
Plan 9
Android
Arch
Bei Raspbian
gibt es eine
vertraute und
intuitive
Desktop-GUI.
Vorinstallierte Software
Welches Zubehör wird mitgeliefert?
Die Softwarepakete der RPi-Betriebssysteme
variieren stark
und sind häufig der Grund, sich
für oder gegen ein bestimmtes System
zu entscheiden. Natürlich sollten
Sie nichts zu Komplexes erwarten
Beeindruckend, was diese Kategorie im Menü von
Arch bereithält.
– es handelt sich in allen Fällen um ein
Betriebssystem, das auf einer SD-Karte
läuft und von einem Rechner befeuert
wird, der die Größe einer Kreditkarte
und im Vergleich zu einem
Desktop-Computer minimale Ressourcen
hat. Trotzdem:
Während Office-
Anwendungen,
Multimedia und Grafikbearbeitung
Standard
bei gewöhnlichen
Linux-Paketen
sind, waren wir überrascht,
welches Zu
behör uns unsere
Auswahl an RPi-
Betriebssystemen
bescherte.
Wie erwartet führt
Raspbian das Feld
mit reichlich
Standard-Software an. Risc OS liegt
nicht weit zurück. Wenn Sie für gut
40 Euro das NutPi-Paket kaufen, bekommen
Sie zudem einen vollausgestatteten
Raspberry-Pi-Desktop mit
Office-Suite, Webbrowser und Messenger.
Arch bringt Sie wie bereits erwähnt
zu einem Terminal. Wenn Sie
die richtigen Kommandos kennen,
dann können Sie sich ein ähnlich umfangreiches
Angebot wie auf einem
Desk top-Computer zusammenstellen.
RPi-Android sorgte für eine negative
Überraschung. Es gab zwar eine
vernünftige Auswahl an Medien-Software,
dafür jedoch keine Office-App.
Plan 9 ist eher freudlos. Einmal bis
zum Rio-Desktop vorgestoßen, fanden
wir wenig vor, mit dem wir effektiv
arbeiten konnten. Einsteigern dürfte
es ähnlich ergehen.
Wertung
Raspbian
Risc OS
Plan 9
Android
Arch
Wenn Sie für
das NutPi-Paket
zahlen, dann
können Sie mit
Risc OS kaum
etwas falsch
machen.
43

Projekte
Design und Handhabung
Aussehen und Benutzerfreundlichkeit ist nicht alles? Oh doch!
Desktop-Effekte sind für viele Linux-Nutzer ein heimliches
Laster. Obwohl Linux allgemein den Ruf eines
schlanken, funktionalen Systems besitzt, installieren
etliche Anwender rotierende 3D-Objekte, Feuer-Effekte und
anderen grafischen Schnickschnack. Es ist natürlich persönlicher
Geschmack, aber irgendwann ist die Nutzerfreundlichkeit
vor lauter Grafikeffekten dahin, Stichwort Windows Vista.
Bedenken Sie dies also auch bei Ihrem Betriebssystem für
den Raspberry Pi: Sie tauschen stets ein wenig der begrenzten
Leistung gegen optischen Komfort. Wir schauen uns hier
an, wie die Systeme „nackt“ aussehen und wie sie sich aufmotzen
lassen.
Raspbian
Raspbian bietet dem Nutzer einen funktionellen Desktop. Mit Xfce als
Desktop-Umgebung haben Sie die RPi-Ressourcen gut im Griff und
nicht für ineffizienten Ballast verschwendet. Dennoch können Sie den
Raspbian-Desktop mit wenigen Mitteln grundlegend verändern. Mit Programmen
wie Mate können Sie dem Desktop das „Look and Feel“ einer
klassischen Gnome-2-Umgebung verleihen, das heißt, Sie können anschließend
alles nach eigenem Gusto anpassen.
In Sachen Nutzerfreundlichkeit liegt Raspbian in der Basisausstattung
ganz weit vorn. Ein allzu ausschweifender Gebrauch des apt-Befehls
und die Installation Hunderter von Anwendungen kann den Raspberry
Pi allerdings leistungsmäßig in die Knie zwingen.
Arch
Arch ist ein wundersames System. Es beginnt sein Leben auf dem RPi
mit nichts weiter als einer Kommandozeile, doch stößt man in die Tiefen
von Arch vor, entpuppt es sich als eines der besten Betriebssysteme.
Arch ist ein schlichtes, modernes Programm. Selbst nach der Installation
einer Desktop-Umgebung wie etwa OpenBox arbeitet das System
schnell. Wenn Sie OpenBox mit einem RPi-Theme und Conky kombinieren,
dann sind Sie auf dem besten Wege zu einem komfortablen
Desktop.
Die Stärke von Arch ist, alles Nötige ohne Ballast nachinstallieren zu
können. Arch ist somit das am besten individualisierbare Betriebssystem
für den Raspberry Pi. Ein paar installierte Pakete, und Arch lässt
seinen großen Bruder Raspbian spielend leicht hinter sich.
Die Community
Die Gemeinschaft der Nutzer bildet ein relevantes Kriterium.
Wertung
Raspbian
Seine eingeschworene Userschaft
macht Linux aus. Sie besteht
aus Individuen, die helfen,
teilen und sich für das eigene Lieblings-Betriebssystem
starkmachen.
Die Gemeinschaft ist ein Ort des Lernens
und der Weitergabe von Wissen.
Raspbian und Arch haben die größten
Communitys: insbesondere Raspbian,
das im Forum der RPi-Website
den größten Fokus erhält. Arch hingegen
folgt mit einem Hauch von
Rivalität, die zunimmt, während
immer mehr Nutzer sich mit unterschiedlichen
Betriebssystemen
auseinandersetzen.
Das Android-Projekt für den Raspberry
Pi nimmt an Fahrt auf. Immer
mehr Nutzer interessieren sich für
das Potenzial der RPi-Portierung. Gegenwärtig
spielt Android jedoch noch
eine untergeordnete Rolle. Risc OS
kommt mit vielen langjährigen Nutzern
auf eine lebhafte Gemeinschaft.
Plan 9 mag neuer sein, doch die Nutzer
haben detaillierte und gut dokumentierte
Hilfestellungen verfasst.
Die meisten Community-Angebote
finden sich auf den offiziellen Webseiten
– nehmen Sie sich Zeit, das Raspberry-Pi-Forum
zu durchforsten.
Haben Sie keine Angst, Fragen zu
stellen, denn es gibt sehr viele hilfsbereite
Nutzer, die Einsteigern und
Fortgeschrittenen gerne unter die
Arme greifen.
Risc OS
Plan 9
Android
Arch
Die Linux-
Community ist
ein Quell des
Wissens, den
man nutzen und
fördern sollte.
44

Projekte
Android
Android 2.3 ist an sich ein gut aussehendes Betriebssystem: ansehnliche
Animationen, Symbole, Themes, bewegliche Hintergründe
und Desktops sorgen für eine attraktive Umgebung. Auf einem
Raspberry Pi geht jedoch einiges davon schief.
Android für den RPi ist derzeit weit davon entfernt, ein perfektes
Betriebssystem zu sein. Auf einem 256-MB-RPi ist es unbenutzbar,
doch der erweiterte Arbeitsspeicher des 512-MB-Modells macht sich
immerhin positiv bemerkbar. Es bleibt abzuwarten, wie sich die Sache
entwickelt.
Risc OS
Risc OS bringt Sie wie Raspbian vom Start weg zu einer netten GUI. Die
Oberfläche von Risc OS ist ausgewogen, farbenfroh und nett, vor allem
wenn Sie es in 1080p hochfahren und mit einem passenden Bildschirm
nutzen können. In Sachen Design ist der Basis-Desktop womöglich der
einzige, den brauchen werden. Er orientiert sich an der glorreichen Vergangenheit
von Risc, wirkt retro, aber nicht so billig wie zu 8-Bit-Zeiten.
Die Bedienung erfordert etwas Erfahrung, beispielsweise ist der Netzwerk-Port
standardmäßig deaktiviert. Es gibt zwar genügend Anleitungen,
wie man ihn aktiviert, doch Einsteiger könnten damit schnell überfordert
sein. Dennoch wird Sie Ausdauer wie bei allen anderen
Computer-Themen voranbringen. Innerhalb einer Stunde sollte man
sich ganz gut in Risc OS einarbeiten können.
Plan 9
Wenn Sie Plan 9 nutzen wollen, dann vergessen Sie alles, was Sie bei
Windows, OS X, Linux oder gar Unix gelernt haben. Die Befehle sind
zwar ähnlich, aber bis Sie tatsächlich welche eingeben können, ist einiges
an Arbeit nötig. Das Verständnis von Plan 9 erfordert eine steile
Lernkurve, der Start ist also nicht leicht. Dafür gibt es aber unzählige
Dokumentationen.
Rio, das Window-System von Plan 9, wirkt wie ein Rückschritt in
Amiga- oder gar Atari-ST-Zeiten, weil die Fassade recht ähnlich aussieht.
Wenn Sie durchhalten, werden Sie mit einem einfachen, eleganten und
pfeilschnellen Desktop belohnt.
Kindgerechte Systeme
Kommen auch junge Anwender zurecht?
Wertung
Raspbian
Der Raspberry Pi ist beim Computer-Nachwuchs
sehr beliebt,
aber wie benutzerfreundlich
sind seine Betriebssysteme im Hinblick
auf Kinder und Jugendliche? Es ist ein
ehrenwerter Ansatz seitens der Raspberry
Pi Foundation, der heranwachsenden
Generation auf der Hardwareseite
die Werkzeuge in die Hand zu
geben, um experimentierfreudiger mit
Computern umgehen zu können –
doch wenn die Hardware sich mithilfe
der Software nicht gut bedienen lässt,
dann werden insbesondere junge Anwender
womöglich schnell das Interesse
verlieren. Um dies besser einschätzen
zu können, haben wir Daniel (11)
und Hannah (10) als Tester rekrutiert.
Raspbian und Risc OS führen das
Feld an, Einrichtung und Benutzung
waren einfach. Android und Plan 9 hinterließen
einen schlechten Beigeschmack.
Arch sorgte für blanke Ahnungslosigkeit
und leere Gesichter, die
jedoch nach ein bisschen Einarbeitung
wieder an Farbe gewannen.
Daniel entschied sich klar für Raspbian
als Sieger, Hannah für Risc OS, welches
für sie vor allem „netter aussieht“.
Risc OS
Plan 9
Android
Arch
Unsere
jugendlichen
Tester ließen sich
von Raspbian
und Risc OS
überzeugen.
45

Projekte
Medienwiedergabe
Ein Media-Center ist fein, doch funktioniert es auf Anhieb?
Mit der Medienwiedergabe
unter Linux ist es so eine
Sache. Einige Distributionen
bieten alles Notwendige an Tools und
Codecs an, andere nicht. Gut ist, dass
Sie Linux nach Ihrem Gusto einrichten
können – doch wie schneiden die von
uns getesteten Betriebssysteme in der
Standardausstattung ab?
Android überraschte mit einer ordentlichen
Wiedergabe unseres
HD-Testfilms, allerdings war auf dem
256-MB-RPi schon nach zwei Minuten
Schluss. Wir mussten daraufhin sogar
die SD-Karte neu mit dem Betriebssystem
bespielen, weil Android nicht
mehr booten wollte. Der 512-MB-RPi
streikte bei der Wiedergabe mit
In der Basisausstattung fehlt Raspbian ein Media-Player für Filme und MP3s,
doch auf lange Sicht ist das Betriebssystem die erste Wahl für die Medienwiedergabe
auf dem Raspberry Pi.
Android nach 15 Minuten. Das Video
lief befriedigend, Kamerabewegungen
führten jedoch zu Bildreißen (Tearing):
mehr erlaubt der gegenwärtige
Stand von RPi-Android wohl nicht.
MP3-Playback über den Audio-Port
funktionierte, doch die 256-MB-Version
des RPi war weit davon entfernt,
anständige Media-Player-Qualitäten
aufzuweisen.
Raspbian bot von Haus aus keinerlei
Software, um Filme oder MP3s abzuspielen,
was umso bedauerlicher ist,
als eine Integrierung des OMXplayer
wohl niemandem wehgetan hätte.
Risc OS schnitt auch nicht besser ab.
Sowohl Filme als auch MP3s ließen
sich nicht laden – genau wie auch bei
Plan 9. Obwohl beide Systeme sehr
gute Medienzentralen abgeben würden,
sind die Pakete nach der Ersteinrichtung
nicht in der Lage, auch nur die
gängigsten Medienformate abzuspielen.
Es bedarf weiterer Downloads und
einiger Kniffe, um Abhilfe zu schaffen.
Arch reiht sich ebenfalls ein. Es bootet
ins Terminal – die Hoffnung, direkt
etwas Grafisches in Bewegung setzen
zu können, ist verschwindend gering.
Arch lässt sich als toller Media-Player
einrichten, doch die erforderliche Lernkurve
dürfte manchen Einsteiger
überfordern.
Wertung
Raspbian
Risc OS
Plan 9
Android
Arch
Android
funktioniert
einigermaßen
mit dem
512-MB-RPi,
doch auf lange
Sicht ist Raspbian
am besten.
Open-Source-Software
Bestnote für alle Systeme dank Linux-Philosophie.
Die Quellcodes aller getesteten
Betriebssysteme sind im Netz
frei verfügbar. Sollte sich
daran aus irgendwelchen Gründen
etwas ändern, werden die entsprechenden
Communitys ohne Frage sofort
auf die Barrikaden gehen.
Risc OS für den Raspberry Pi ist als
Version 5.19 quelloffen, eine Gruppe
von Freiwilligen kümmert sich darum.
Die neueste Version 6 erfordert hingegen
den Abschluss eines Select-Abonnements
zu einem Preis von rund 120
Euro pro Jahr. Dementsprechend handelt
es sich bei Risc OS 6 um proprietäre
Software, sprich sie wird lizenziert
und ist nicht mehr quelloffen.
Plan 9, Arch, Android und Raspbian
sind nach wie vor frei zugänglich und
individuell erweiterbar gemäß den
Grundsätzen der gesamten Linux-
Gemeinschaft und speziell denen der
Raspberrry Pi Foundation.
Die generelle Haltung zum Thema
Software-Freiheit ist bei allen Projekten
hinsichtlich der Verbesserung der
Programme, des Einsatzes für Bildungszwecke
und des Gebrauchs der
Software ähnlich und befindet sich in
Übereinstimmung mit den Grundsätzen
der Open-Source-Community.
Es wäre unfair, Risc OS hier abzuwerten,
weil Risc OS 6 keine Open-
Source-Software mehr ist, denn die
Community hinter Version 5.19 für
Raspberry Pi kümmert sich weiterhin
um das Programm und den Grundgedanken
freier Software.
Risc OS erfordert ab Version 6 ein
Select-Abo, das rund 120 Euro im Jahr
kostet.
Wertung
Rasbian
RISC OS
Plan 9
Android
Arch
Bestnoten für
alle Systeme,
wobei jedoch das
neueste Risc OS
nicht mehr
quelloffen ist.
46

Projekte
Betriebssysteme für den Raspberry Pi
Das Fazit
Ein Sieg für
Raspbian, doch
die Konkurrenz
rückt näher!
Von allen getesteten Betriebssystemen
entpuppte sich Raspbian
als nutzerfreundlichstes,
bestaussehendes und bestausgestattetes.
Allerdings nähern die anderen
Systeme sich langsam, aber sicher an.
Für Einsteiger ist Raspbian ein guter
Startpunkt – nicht nur in die Welt des
Raspberry Pi, sondern auch für die
ersten Schritte in die große Welt von
Linux und anderen alternativen Betriebssystemen.
Sollte ein Anfänger
über die Einstiegshürden hinweg sein,
besteht eine hohe Wahrscheinlichkeit,
dass er sich für Arch, Risc OS oder
Plan 9 als Betriebssystem für seinen
Raspberry Pi entscheiden wird.
Android für RPi ist sicher interessant
und hat Potenzial, doch bislang
bleiben dessen Möglichkeiten weit hinter
denen aktueller Android-Mobilgeräte
zurück.
Mehr Leistung fürs Volk
Die Leistung ist entscheidend. Während
die minimalistischen Vertreter
Arch und Plan 9 die jetzigen RPi-Modelle
nicht zum Schwitzen bringen
sollten, ist diese Wahrscheinlichkeit
bei Raspbian recht hoch.
Sollte die Raspberry Pi Foundation
jemals ein leistungsfähigeres Modell
entwickeln, dürfte die Anzahl der Betriebssysteme
in kurzer Zeit sprunghaft
ansteigen. Das Problem liegt
hierbei jedoch bei den Kosten. Der
jetzige Preis von rund 35 Euro ist das,
was den RPi so attraktiv macht. Mit
mehr Leistung und Performance
gehen allgemein höhere Kosten einher.
Gegenwärtig geht es uns mit
der Anzahl guter Betriebssysteme
recht gut. Es gibt keinen Konkurrenzkampf,
dafür aber die Möglichkeit,
dass ein RPi-Nutzer die Hand
nach einem neuen OS ausstreckt,
davon lernt und sich – wie beim gesamten
Thema Linux – individuell
weiterentwickelt.
Denken Sie also daran: Raspbian
gewinnt den Vergleichstest zwar,
doch die anderen Betriebssysteme
sind Projekte, die auf experimentierfreudige
Menschen warten.
„Raspbian entpuppte sich
im Test als das nutzerfreundlichste
System.“
1.
2.
Raspbian
Download: http://goo.gl/4WwPJ
Raspbian ist perfekt für Einsteiger, Fortgeschrittene schauen sich
woanders um.
Risc OS
Download: http://goo.gl/pn2NP
Mit wenig Aufwand ist Risc OS ein voll funktionsfähiges Desktop-
Betriebssystem.
4.
Android for RPi
Download: http://goo.gl/w4eoy
Arbeitet kaum auf dem 256-MB-RPi, doch man darf auf die Zukunft gespannt
sein.
5.
Plan 9
Download: http://goo.gl/qtN7E
Sieht retro aus, kann Ihnen mit genügend Geduld jedoch das geben,
was Sie wollen.
3.
Arch Linux ARM
Download: http://goo.gl/L5HtQ
Arch erfordert mehr Erfahrung, ist dafür aber am Ende stärker.
PiBang – noch ein
Betriebssystem
Falls Ihnen die getesteten Systeme nicht zusagen, werfen Sie
einen Blick auf PiBang, eine Linux-Distribution, die sich am
beliebten CrunchBang Linux orientiert. PiBang sieht dank der
gelungenen Kombination aus OpenBox, Tint2 und Nitrogen
fantastisch aus, dazu ist es schnell, läuft flüssig und stabil. Pi-
Bang beinhaltet OMXplayer und VLC, wenngleich VLC sich
laut den Machern auf dem Raspberry Pi noch nicht dazu
eignet, Videos flüssig abzuspielen, sondern vorerst Testzwecken
und der Musikwiedergabe dient. PiBang bietet darüber
hinaus eine vollwertige Desktop-Umgebung. Es nutzt dieselben
Software-Quellen wie Raspbian – also sind sie kompatibel.
Wir haben PiBang dennoch nicht in unseren Vergleichstest
aufgenommen, da es bisher leider noch nicht allzu viel
Beachtung gefunden hat.
47

Projekte
Betriebssystem:
Mit Windows-Tools kopieren Sie Raspbian einfach auf eine SD-Karte.
Schritt-für-Schritt-Anleitung: Windows
1 Tools herunterladen
Obwohl Windows von Microsoft nicht viel mit der
Linux-Version, die auf dem Raspberry Pi läuft, gemein
hat, bedeutet dies nicht, dass Windows-Anwender
im Nachteil wären, wenn es um die Einrichtung
eines funktionierenden Pi-Systems geht.
Das liegt unter anderem daran, dass die vielen
verschiedenen Einsatzzwecke von Windows und
die zahlreichen Tools im Prinzip gar nicht so unterschiedlich
zum Ansatz des Raspberry Pi sind.
Beide Systeme bieten dem Nutzer grundsätzlich
die gleichen Freiheiten bei der Verwendung von
Anwendungen. Wenn man genauer sucht, findet
man sogar bei Windows eine Kommandozeile,
und viele Open-Source-Programme sind auch für
den Betrieb mit Windows ausgelegt.
Windows-Anwender profitieren darüber hinaus
von einer relativ gefahrlosen Installationsroutine
in Form der Open-Source-Software Win32 Disk
Imager. Als Erstes sollten Sie sich daher das
Tool unter folgender Adresse herunterladen:
sourceforge.net/projects/win32diskimager
Sie brauchen Win32 Disk Imager nicht zu
installieren, es reicht aus, wenn Sie das ZIP-File
mit einem Rechtsklick in einen Ordner entpacken.
Um Raspbian auf eine SD-Karte zu kopieren,
benötigen Sie natürlich auch eine Kopie der
entsprechenden Image-Datei. Unsere Methode
funktioniert grundsätzlich mit allen Raspberry-Pi-
Betriebssystemen und kann auch für das Schreiben
anderer Images auf ein externes USB-Gerät
verwendet werden.
Sie können das Open-Source-Tool Win32 Disk
Imager für den Schreibvorgang verwenden.
2 USB-Speicher prüfen
Bevor Sie das Tool zum Schreiben des Image-
Files starten, sollten Sie sichergehen, dass auf
der SD-Karte keine wichtigen Dateien mehr
gespeichert sind und der SD-Kartenspeicher
einen selbsterklärenden Namen wie beispielsweise
„Raspbian“ trägt. Viele PCs besitzen
einen eingebauten SD-Kartenleser, allerdings
gibt es Berichte, nach denen es mit solchen
Kartenlesern öfter Probleme geben soll, wenn
man eine bootbare Version von Raspbian auf
einer SD-Karte erstellen will. Die besten Ergebnisse
konnten wir mit einen Kartenleser erzielen,
der extern via USB mit dem PC verbunden war.
Sollten Sie ebenfalls auf Probleme stoßen, sollten
Sie als Erstes beim Kartenleser ansetzen.
Die SD-Karte sollte nach dem Einschieben in
den Kartenleser als eigenes Laufwerk angezeigt
werden – merken Sie sich den Laufwerksbuchstaben,
und prüfen Sie bei dieser Gelegenheit
nochmals, ob das Laufwerk noch wichtige Daten
enthält.
Windows zeigt in der Übersicht die Größe der
Partitionen, nicht der Laufwerke an.
3 Win32 Disk Imager starten
Jetzt können Sie die ausführbare Datei des
Open-Source-Tools Win32 Disk Imager starten.
Manchmal warnt Windows vor unbekannten
Datei quellen, im Zweifelsfall können Sie die ausführbare
Datei von einem aktuellen Virenprogramm
prüfen lassen. Seien Sie sich bei Windows-Dateien
lieber ganz sicher, denn unter
Linux gibt es kaum Viren – also besser am Anfang
etwas mehr Sorgfalt walten lassen, als sich
der Gefahr einer Virusinfektion auszusetzen. Das
Hauptfenster des Tools ist nicht besonders intuitiv,
für den Moment sind aber nur zwei Schaltflächen
für die erfolgreiche Arbeit wichtig. Ein Knopf
ist zuständig für die Auswahl des Image-Files,
der andere – rechts daneben – erlaubt die Zielauswahl
des Ortes, auf den die Daten des
Image-Files geschrieben werden sollen. Wenn
Sie auf das kleine Ordner-Icon klicken, müssen
Sie dem Programm zeigen, wo das Image-File
liegt. In der Regel werden nur *.img-Dateien angezeigt.
Der kleine „Geräte“-Knopf zeigt dem Programm
im Anschluss den Ort, wohin die Dateien
geschrieben werden sollen. Win32 Disk Imager
wählt meist das korrekte Ziel automatisch aus,
aber prüfen Sie unbedingt den Laufwerksbuchstaben,
sonst werden eventuell wichtige Dateien
unbeabsichtigt gelöscht.
Das User-Interface ist zwar schlicht, aber es
zeigt alle wichtigen Schaltflächen.
48

Projekte
Raspbian
4 Daten schreiben
Wenn Sie alles geprüft und korrekt eingestellt
haben, können Sie auf den „Write“-Knopf
drücken. Es erscheint eine Warnung, die erneut
die Gefahren für das Ziellaufwerk aufführt,
diese können Sie allerdings ignorieren. Die
SD-Karte wird auf dem untersten „Level“ mit
den neuen Daten überschrieben, dazu zählen
auch die Partitionstabelle und weitere grundlegende
Formatierungen. Diese Low-Level-Formatierung
ist notwendig, damit die SD-Karte
später auch bootbar ist. Nach dem Start sollte,
falls vorhanden, eine kleine LED beim SD-Kartenleser
flackern, so können Sie ebenfalls sicherstellen,
dass Sie den richtigen Laufwerksbuchstaben
ausgewählt haben. Man kann nicht
oft genug betonen, dass Sie hier extrem sorgfältig
zu Werke gehen müssen, denn so ein
Schreibvorgang auf einer der internen Festplatten
sorgt dafür, dass alle Daten auf diesem
Daten träger verloren sind. Der Schreibvorgang
benötigt rund 20 Minuten, dieser wird von einer
Balkenanzeige und von der Angabe der Schreibleistung
pro Sekunde ergänzt.
Während die Daten auf die SD-Karte geschrieben
werden, informiert Sie ein Balken über den
Fortschritt.
5
Die Installation prüfen
Bevor Sie die neu beschriebene SD-Karte in
Ihren Raspberry Pi stecken, sollten Sie die Installationsdateien
prüfen. Dieser Schritt gibt
Ihnen auch einige Einblicke in die neue Formatierung
der SD-Karte. Schauen Sie im ersten
Schritt mithilfe der Laufwerksübersicht auf der
SD-Karte nach, ob die neuen Dateien tatsächlich
auf dem Speichermedium vorhanden sind.
Die neue Linux-Partition auf der SD-Karte kann
aber von einem Windows-PC nicht gelesen
werden, da Windows das Linux-Dateisystem
nicht versteht. Nutzen Sie zur Überprüfung
daher ein gesondertes Windows-Tool, welches
Sie durch die Suche nach „Erstellen und Formatieren
einer Festplattenpartition“ finden können.
Auf der Übersichtsseite der Computerverwaltung
werden alle Laufwerke und Partitionen, die
derzeit angeschlossen sind, angezeigt. Suchen
Sie den Laufwerksbuchstaben der SD-Karte,
darunter sollten drei Partitionen angezeigt
werden: eine im FAT-Dateisystem mit rund
56 MB Speicher platz, dann die Linux-Partition
sowie eine dritte, die den nicht zugewiesenen
Speicherplatz anzeigt. Wenn Sie also drei
Partitionen auf der SD-Karte vorfinden, ist dem
Anschein nach alles so verlaufen, wie es
geplant war.
Die Partitionsanzeige von Windows liefert
brauchbare Hinweise, ob der Kopiervorgang ohne
Probleme abgelaufen ist.
NOOBS – es geht noch einfacher!
Es ist grundsätzlich immer von Vorteil, wenn man
die einzelnen Abläufe und Maßnahmen kennt, die
beispielsweise zur Erstellung einer bootbaren
SD-Karte erforderlich sind. Daher geben wir Ihnen
für Windows, OS X und Linux auch diese Schrittfür-Schritt-Anleitungen
an die Hand. Es gibt allerdings
eine noch einfachere Methode, mit der man
das gewünschte Resultat erzielen kann.
Dazu benötigen Sie die Software NOOBS, mit der
man Raspbian und andere Linux-Versionen auf
einem Raspberry Pi installieren kann. NOOBS ist
ein Recovery-Tool für Raspberry Pi und enthält
Images von OS-Varianten wie Raspbian, RiscOS,
Arch Linux, Pidora, Raspbmc und OpenElec.
Das ganze Paket ist rund 1 GB groß und unter
www.raspberrypi.org/downloads erhältlich. Um
NOOBS zu nutzen, benötigen Sie eine SD-Karte
mit 4 GB oder mehr Speicherplatz, als Dateisystem
muss FAT32 verwendet werden. NOOBS wird
installiert, indem Sie den Inhalt des NOOBS-Zip-
Files auf die leere SD-Karte kopieren. Nun können
Sie bereits die SD-Karte in einen Raspberry Pi
stecken und das System starten. Beim ersten
Bootvorgang wird NOOBS automatisch geladen
und begrüßt Sie mit einem sehr übersichtlichen
Aufbau. Um ein Betriebssystem zu installieren,
müssen Sie im zugehörigen Menü einfach nur
„Install OS“ auswählen – fertig. Es folgt ein grafischer
Installationsassistent, der Sie über das
ausgewählte Betriebssystem informiert. Eine der
besten NOOBS-Funktionen ist, dass Sie beim
Booten einfach die Shift-Taste gedrückt halten
können und dann ein anderes der zur Verfügung
stehenden Betriebssysteme auswählen können.
Beachten Sie aber, dass der Start mit einem
anderen OS die Daten des vorherigen löscht.
49

Projekte
Betriebssystem:
Für Apple-Anwender gibt es eine schnelle Installationsmöglichkeit ohne
großen Aufwand.
Schritt-für-Schritt-Anleitung: Apple
1 Die Vorbereitung
Obwohl OS X an jeder Stelle die Apple-Handschrift
trägt und viele Dinge stark vereinfacht
implementiert sind, hat das Apple-OS doch viele
Dinge mit Linux gemeinsam. Beide Betriebssysteme
basieren auf einem älteren Multi-User-
System namens UNIX, und viele Tools und Anwendungen
haben denselben Ursprung. Dies
gibt erfahrenen OS X-Anwendern einen Vorteil,
denn wenn Sie bereits mit der Kommandozeile
von OS X gearbeitet haben, wird Sie das Linux-
System vor keine großen Herausforderungen
stellen. Ebenfalls sehr ähnlich sind die Konzepte
der Anwenderkonten, der Verzeichnisse, des Dateiaustauschs
und der Netzwerk-Drucker. Sie
können den Raspberry Pi mit OS X über die
Kommandozeile konfigurieren und steuern, ohne
dabei spezielle Software installieren zu müssen.
Darüber hinaus sind auch virtuelle Desktops
kein Problem, und in dieser Disziplin können
beide Systeme ihre Wurzeln nicht verleugnen.
Bevor Sie allerdings diese Schnittstellen des
Mac nutzen können, müssen Sie Raspbian natürlich
erst auf einer Speicherkarte installieren.
OS X bietet von Haus aus Tools, die Sie auch
auf einem Raspberry Pi finden.
2 Tools herunterladen
Die Standard-Installationsvariante von Raspbian
mit einem Mac ist, genau wie bei Linux,
über die Kommandozeile durchzuführen. Über
diese installieren Sie Raspbian auf einer SD-
Karte. Wenn Sie diesen Weg gehen möchten,
folgen Sie der Schritt-für-Schritt-Anleitung für
Linux und passen Sie die Gerätenamen denen
bei OS X an. Es gibt auf dem Mac aber auch
eine einfachere und sicherere Lösung, bei der
die Installation über ein grafisches Benutzerinterface
angegangen wird. Dazu benötigen Sie
das Tool RPi-sd card builder, welches derzeit in
der Version 1.2 verfügbar ist. Das Tool finden
Sie unter:
alltheware.wordpress.com/2012/12/11/
easiest-way-sd-card-setup.
Speichern Sie das Tool in einem lokalen Ordner
auf Ihrem Mac, und stellen Sie sicher, dass
Sie die aktuelle Version des Raspbian-Images
zur Hand haben, da dieses bereits im ersten
Schritt der Installation benötigt wird. Die aktuelle
Version des Raspbian-Images finden Sie
unter www.raspberrypi.org/downloads. Verwenden
Sie die Version, die mit dem Namenszusatz
„wheezy“ versehen ist. Da die Image-Datei nur
rund 500 MB groß ist, sollte der Download nur
wenige Minuten dauern – dies hängt natürlich
auch von Ihrem Internetanschluss und der
Server-Geschwindigkeit ab.
Der RPi-sd card builder erspart Ihnen den mühsamen
Weg über die Kommandozeile und ist für
Einsteiger ideal.
3 Den Builder starten
Der Download ist als Zip-File verpackt. Auf
einem Mac werden die Zip-Dateien in der Regel
nach dem Download automatisch entpackt.
Sie erhalten dann eine Datei mit einem Namen
wie 2012-12-16-wheezy-raspbian.img – wobei
die genaue Bezeichnung vom Download-Datum
und der jeweiligen Software-Version abhängt.
Wenn Sie die Datei selbst entpacken müssen,
genügt ein Doppelklick auf die heruntergeladene
Zip-Datei. Der RPi-sd card builder sollte
nach dem Herunterladen ebenfalls im
Download-Ordner abgelegt worden sein und ist
recht einfach durch das Raspberry-Pi-Icon zu
identifizieren. Starten Sie nun den RPi-sd card
builder, und dieser fordert Sie auf, das jeweilige
Image auszuwählen, das Sie für die Installation
auf Ihrem Raspberry Pi heruntergeladen
haben – da Sie das Image vorher in einem
speziellen Ordner abgelegt haben, sollte es
leicht zu finden sein. Anschließend drücken Sie
noch auf den „Choose“-Knopf, und das Tool
beginnt mit der Verarbeitung der
Raspbian-Image-Datei.
Der RPi-sd card builder fordert Sie auf, manuell
den Speicherort des Image-Files für die Installation
auszuwählen.
50

Projekte
Raspbian
4 SD-Karte auswählen
Der RPi-sd card builder wird sich nach dem Start
beschweren, dass keine SD-Karte gefunden wird
– egal, ob diese korrekt angeschlossen ist oder
nicht. Wir verwenden für unsere Arbeiten einen
Standard-USB-Kartenleser, ein ähnliches Gerät
sollten Sie mit der eingelegten SD-Karte an
Ihrem Mac anschließen. Stellen Sie sicher, dass
der Schreibschutz der SD-Karte nicht aktiviert ist.
Bei Karten mit diesem Feature finden Sie an der
Seite einen kleinen Plastikschieber – stellen Sie
sicher, dass dieser korrekt eingestellt ist. Achten
Sie ebenfalls darauf, dass auf der eingelegten
SD-Karte keine Daten mehr gespeichert sind, die
Sie behalten möchten, denn diese werden im folgenden
Prozess vollständig überschrieben.
Der angeschlossene SD-Kartenleser wird automatisch
nach dem Anschluss auf dem Desktop
angezeigt. Nachdem Sie den Kartenleser samt
Karte angeschlossen haben, klicken Sie in dem
Programm RPi-sd card builder auf „Continue“.
Der folgende Bildschirm zeigt alle Laufwerke an,
hier müssen Sie den SD-Kartenleser und die SD-
Karte auswählen – seien Sie 100 % sicher, dass
Sie das richtige Ziel auswählen, denn sonst wird
im schlimmsten Fall Ihre Festplatte gelöscht. In
der rechten Spalte der Übersicht sehen Sie den
Namen des ausgewählten Geräts, dieser sollte
mit dem Namen der SD-Karte übereinstimmen.
Vergleichen Sie auch die Größenangabe der SD-
Karte mit Ihren Informationen. Wenn alles passt,
klicken Sie auf „OK“.
Überprüfen Sie den Namen des Zielgeräts zur
Not dreimal, damit Sie absolut sicher sind.
5 Raspbian schreiben
Nun werden Sie gebeten, Ihr Passwort einzugeben.
Sie müssen am Mac als Administrator angemeldet
sein – eine weitere Ähnlichkeit mit
dem Linux-System. Die meisten Mac-Anwender
haben ohnehin Administratorenrechte, also können
Sie ein gewünschtes Passwort in der Regel
ohne Vorarbeiten eingeben. Ein weiteres Fenster
verkündet nun, dass das Gerät erst entfernt
(„unmount“) werden muss. Dies ist erforderlich,
da Inhalte im „Low Level“-Format geschrieben
werden müssen und dies am Mac nicht möglich
ist, wenn das Gerät vom Desktop aus erreicht
werden kann. Warten Sie also, bis das Icon der
SD-Karte vom Desktop verschwunden ist, dann
klicken Sie auf „Continue“. Der eigentliche
Schreibvorgang dauert rund 15 Minuten. Hinter
dem rotierenden Zahnrad oben am Bildschirm
verbirgt sich zusätzlich eine Statusleiste.
Sie müssen Ihr Passwort
eingeben, um der Anwendung
die benötigen Schreibrechte
einzuräumen.
6 Die Installation prüfen
Wenn der Vorgang abgeschlossen ist, sollte die
SD-Karte für den ersten Einsatz im Raspberry Pi
bereit sein. Bevor Sie sie benutzen, sollten Sie
sich den Inhalt der SD-Karte aber nochmal auf
dem Desktop anschauen. Dadurch können Sie
schon früh Fehler bei der Vorbereitung ausschließen,
damit es später keine Probleme gibt. Kurz
nach dem Abschluss des Kopiervorgangs sollte
die SD-Karte wieder auf dem Desktop auftauchen.
Dieses Laufwerk sollte nur 18 MB Daten
beherbergen, und angeblich sind nur noch etwa
41 MB auf dem Laufwerk frei. Dies liegt daran,
dass Sie sich so zwar die Boot-Partition anzeigen
lassen können, aber die anderen Partitionen auf
der SD-Karte für den Mac unsichtbar sind. Wenn
Sie diese Partitionen sehen wollen, müssen Sie
die Datenträgerverwaltung des Mac verwenden.
Diese zeigt bei der Auswahl das jeweilige Speichermedium,
und wenn Sie es auswählen, können
Sie sich auch die Partitionen anzeigen lassen.
Wenn alles korrekt abgelaufen ist, sehen
Sie zwei Partitionen und etwas ungenutzten Platz
auf der SD-Karte. Diesen können Sie später mit
einem Linux-Tool dem freien Patz auf der SD-
Karte hinzufügen.
Prüfen Sie mit der Datenträgerverwaltung die
Installation auf der SD-Karte, bevor Sie den Pi
starten.
51

Projekte
Betriebssystem:
Die Installation von Linux auf dem Raspberry Pi mithilfe eines Linux-Rechners ist
vermutlich die sicherste Variante, und etwas lernen können Sie dabei auch noch.
Schritt-für-Schritt-Anleitung: Linux
1 Funktionsvielfalt
Wenn Sie bislang Linux noch nicht verwendet
haben, müssen Sie sich deswegen keine Sorgen
machen. Linux ist mittlerweile so einfach zu verwenden
wie andere Betriebssysteme auch. Bei
manchen Dingen ist es sogar einfacher zu bedienen.
Man muss beispielsweise keine Treiber
suchen, und Anwendungen werden quasi über
einen eigenen App Store installiert. Und da Sie
ohnehin Linux auf einem Raspberry Pi installieren
wollen, können Sie auch schon mit den Vorbereitungen
unter Linux beginnen. Wir empfehlen
Ubuntu für die ersten Schritte mit Linux, die
Tipps funktionieren im Prinzip aber auch mit
jeder anderen Linux-Distribution. Linux ist auch
für Notfälle eine gute Option, denn es kann von
einer CD gestartet werden – ganz ohne Festplatte.
Nach dem Einlegen einer Ubuntu-CD erscheint
ein Auswahlmenü. Wählen Sie hier das
Optionsmenü „Try Ubuntu“, denn so kommen wir
auf den Ubuntu-Desktop, den Sie für Notfälle benötigen.
Die Software ist kostenlos im Netz erhältlich
und kann auf CD gebrannt werden.
Auch ohne Linux installiert zu haben,
können Sie mit Ubuntu das System
bis zum Desktop laden.
2 Vorbereitung
Allerdings ist das Problem mit dem Start von der
Ubuntu-Boot-CD, dass Sie damit Raspbian nicht
herunterladen können, da Sie die Dateien nicht
speichern können. Der Grund liegt darin, dass
der Ubuntu-Anwendung zu wenig Speicher für
den gesamten Download von Raspbian zur
Verfügung steht. Sie müssen die Daten also auf
einem externen Datenspeicher ablegen, aber
nicht auf der SD-Karte, auf der ja das Image erzeugt
werden soll. Wenn Sie ein installiertes
Linux-System besitzen, sieht die Sache natürlich
anders aus, dann können Sie die Daten einfach
auf dem Datenträger ablegen. Nachdem das
Image heruntergeladen wurde, sollten Sie sich
ein Bild von der SD-Karte machen. Alle Daten
auf dem Datenträger werden gelöscht. Stellen
Sie also sicher, dass keine wichtigen Informationen
auf der SD-Karte abgelegt sind.
Wenn Sie unter Ubuntu ein
USB-Laufwerk einlegen, zeigt Ihnen
Ubuntu sämtliche Partitionen
auf diesem an.
3 ImageWriter installieren
Wir werden das Tool ImageWriter als grafisches
Frontend für den Schreibvorgang von Raspbian
nutzen. Dieses Tool kann über das Software-Center
von Ubuntu installiert werden. Dieses starten
Sie durch einen Klick auf das Korb-Icon. Suchen
Sie dann nach „imagewriter“. Es sollte nur ein
einziges Tool angezeigt werden. Machen Sie
einen Doppelklick auf das Programm, und es erscheint
eine Anzeige, nach der die Software von
der „universe“-Quelle erhältlich ist. Diese Quelle
ist standardmäßig nicht aktiviert, sondern muss
mit einem Klick auf „Use this Source“ freigegeben
werden. Warten Sie, bis der Fortschrittsbalken
durchgelaufen ist und die interne Angebotsliste
aktualisiert wurde. Löschen Sie das
Suchfeld, und geben Sie erneut „imagewriter“
ein. Das Softwareangebot sollte nun aktualisiert
worden sein, und Sie können nun auf einen
„Install“-Knopf klicken. Sie werden sich vielleicht
fragen, warum man ein Zusatzpaket, nicht aber
Raspbian ohne zusätzlichen Speicherplatz installieren
kann. Das liegt daran, dass das Paket
deutlich kleiner als Raspbian ausfällt.
ImageWriter kann auch mit der
Live-CD von Ubuntu installiert und
genutzt werden.
52

Projekte
Raspbian
4 Das Raspbian-Image schreiben
ImageWriter muss mit der „gemounteten“ SD-
Karte gestartet werden, sonst startet es nicht
und beschwert sich, dass kein Speicherplatz verfügbar
ist. Wenn der Hauptbildschirm erscheint,
müssen Sie der Software einige Parameter verraten.
Der erste ist die Position des Raspbian-
Images, das Sie auf den USB-Stick schreiben
wollen, der zweite bezeichnet das Gerät, auf welches
das Image geschrieben werden soll. Die
zweite Einstellung ist besonders wichtig, da Sie,
falls Sie mehrere Speicherplätze auf Ihrem System
haben, sicherstellen müssen, dass Sie die
Daten nicht auf das falsche Laufwerk aufspielen,
um nicht unabsichtlich irgendwelche Daten zu
löschen. Es wird auch der Name des Geräteherstellers
angezeigt, dies könnte Sie ebenfalls vor
einer falschen Auswahl bewahren. Nun können
Sie das Programm mit einem Klick auf „Write to
Device“ starten. Wenn das USB-Laufwerk mit der
SD-Karte eine LED für Laufwerksaktivitäten besitzt,
sollte diese jetzt flackern. Der Schreibprozess
wird eine gute Weile dauern, die genaue
Zeitspanne hängt von der Geschwindigkeit der
USB-Ports und anderer Komponenten ab. Normalerweise
können Sie von rund 15 Minuten
ausgehen, danach können Sie die SD-Karte
testen.
ImageWriter benötigt nur das Image und die
SD-Karte als Ziel, dann kann es auch schon
losgehen.
5 SD-Karte testen
Anders als Windows und OS X kann Linux als
einziges Betriebssystem die beiden Partitionen
der neuen Raspberry-Pi-SD-Karte lesen. Die
erste ist in einem Windows-FAT-Format formatiert
und sollte rund 60 MB groß sein. Über
diese Partition startet das System, und anschließend
übergibt Raspbian quasi die Kontrolle
an die zweite Partition. Diese ist mit den
wichtigsten Inhalten von Raspbian angefüllt,
hier ist also das Root-Dateisystem von Linux
zu finden. Beide Partitionen werden erkannt,
wenn Sie die SD-Karte an ein Linux-System
anschließen. Die Linux-Partition sieht der Ihres
Ubuntu-Systems recht ähnlich. Dies liegt daran,
dass beide Systeme vom selben Ursprung namens
Debian abstammen. Der „Home“-Ordner
besitzt beispielsweise einen Anwender-Ordner, in
dem Dateien und Settings gespeichert werden.
Raspbian ist auf einen einzigen Anwender „pi“
vorkonfiguriert. Dies lässt sich später natürlich
schnell ändern. Sie können sehen, was sich in
diesem Ordner befindet, wenn Sie auf „Home“
klicken. Wenn Sie fertig sind, „unmounten“ Sie
die SD-Karte und stecken Sie diese in Ihren
Raspberry Pi.
Linux kann das Windows- und Mac-Dateisystem
ohne die Installation von Zusatzsoftware problemlos
auslesen.
6 Alternativ-Installation
Es gibt eine weitere Methode, Raspbian auf eine
SD-Karte zu schreiben. Da diese allerdings relativ
gefährlich für den Inhalt anderer Datenträger sein
kann, sollten Sie diesen Weg nur gehen, wenn
die anderen nicht verfügbar sind. Bei dieser Methode
müssen Sie über die Kommandozeile arbeiten
und das dd-Kommando verwenden. Dieser
Befehl kopiert die Daten quasi „roh“, also Byte
für Byte. Wenn Sie sich hier mit der Zieleingabe
vertun, wird Ihre wichtigste Festplatte schlimmstenfalls
mit einem unbrauchbaren Raspbian-
Image überschrieben. Nehmen Sie die SD-Karte
aus dem System und starten Sie das Terminal
von Ubuntu. Dieses ermöglicht nun die Kommandozeileneingabe.
Tippen Sie tail -f /var/log/
syslog ein, und stecken Sie die SD-Karte in den
Rechner. Halten Sie nach einem Systemevent mit
der Schreibweise sdb: sdb1 Ausschau. Dies bedeutet,
dass eine neue Festplatte erkannt wurde,
in diesem Fall die eingelegte SD-Karte. Es werden
vermutlich auch viele weitere Ausgaben angezeigt,
da das Linux-System versucht, alle Inhalte
auf der SD-Karte zu erfassen. Falls es „ge -
mountet“ ist, sollten Sie es jetzt „unmounten“
und dann den Befehl sudo dd bs=1M if=
raspbian.img of=/dev/sdX eingeben. Sie müssen
jedoch den *.img-Dateinamen durch die korrekte
Beschriftung des Image-Files ersetzen und
den /dev/sdX-Node um Ihre eigenen Spezifikationen
ergänzen. Das Image wird jetzt auf die SD-
Karte geschrieben, ganz ohne Desktop-Befehle.
Sie können den dd-Befehl durch die Tastenkombination
STRG+C abbrechen.
53

Projekte
Zünde den
Raspberry-Booster
Als die ersten Exemplare des Raspberry
Pi Ende Februar 2012 in den
Vorverkauf gingen, ahnten die
Schöpfer des Mini-Computers recht schnell,
dass sie einen Nerv getroffen hatten. Das
Interesse war von Beginn an gewaltig, die
Erstauflage von 10.000 Stück stand zwanzigmal
so vielen Vorbestellungen gegenüber.
Ab Mitte April 2012 wurde dann endlich
ausgeliefert, und die Produktion wurde hochgefahren,
um die immer weiter steigende
Nachfrage bedienen zu können. Im September
2012 waren 500.000, im Februar 2013
1 Million Einheiten des Raspberry Pi verkauft.
Bis Ende 2013 fanden weit über 2 Millionen
Exemplare des kleinen Rechners einen Käufer,
was sogar die optimistische Prognose des
Entwicklerteams noch übertraf. Man kann
ohne Übertreibung sagen, dass dieser Erfolg
in den letzten Jahren einzigartig gewesen ist.
Abseits dieser beeindruckenden Zahlen ist
jedoch die Tatsache an sich, dass der Raspberry
Pi Anklang bei Computer-Fans in aller
Welt findet, durchaus nicht so erstaunlich,
denn für etwa 35 Euro bekommt man einen
voll funktionsfähigen Linux-Rechner mit ARM-
Ben Everard zückt den (nicht nur)
virtuellen Lötkolben und zeigt Ihnen, was
Sie mit dem Pi so alles anstellen können.
Prozessor und 512 MB RAM (jedenfalls in der
ab Oktober 2012 ausgelieferten Modellvariante)
in den Abmessungen einer Kreditkarte.
Das Ziel der Raspberry-Pi-Schöpfer um
Eben Upton war es, die IT-Ausbildung in Großbritannien,
die nicht mehr am Puls der Zeit
war, zu revolutionieren. Ob dieses Ziel dereinst
erreicht wird, ist noch nicht abzusehen,
doch eines lässt sich mit Sicherheit schon
heute sagen: Die Welt der Hobbyschrauber im
Computerbereich ist nicht mehr dieselbe wie
zuvor! Die winzigen, aber voll funktionsfähigen
Geräte sind perfekt dazu geeignet, überall
dort eingesetzt zu werden, wo Stromversorgung
und räumliche Verhältnisse begrenzende
Faktoren sind – und natürlich auch dort, wo
Geld gespart werden muss.
Raspberry Pis sind bereits ins Weltall und
über den Ozean geschickt worden, sie werden
als Steuerungseinheiten von Robotern,
Sicher heitssysteme und für alle möglichen
Experimente eingesetzt, und der Einfallsreichtum
der Pi-Enthusiasten kennt schier keine
Grenzen.
54

Distributionen
Es gibt etliche Distributionen (Betriebssystemvarianten)
für den Raspberry Pi,
und laufend kommen neue hinzu. Auf
dieser Seite stellen wir einige der wichtigsten
„Distros“ vor.
Eine Distribution wird auf dem Raspberry Pi
etwas anders installiert als auf einem normalen
PC. Da die Software beim Pi von einer SD-Karte
aus läuft, braucht man das Betriebssystem und
weitere Programmpakete nur auf diese Karte zu
schreiben. Am einfachsten ist das mit dem Befehlszeilen-Tool
dd zu bewerkstelligen. Mit diesem
Kommando erzeugt man Bit-für-Bit-Kopien
von Daten zwischen Geräten und Dateien. Distributionen
werden als Image-Dateien zur Verfügung
gestellt, die gegebenenfalls noch entpackt
werden müssen und auf einen Datenträger geschrieben
werden können. Die Befehle lauten:
sudo dd if= of= bs=4k
sudo sync
Die zweite Zeile sorgt dafür, dass die gesamten
Daten auf die Karte geschrieben werden
und nicht in irgendwelchen Zwischenspeichern
hängen bleiben. Benutzt man beispielsweise
einen PC mit zwei Festplatten sda und sdb, so
wäre die SD-Karte dev/sdc. Sollten Sie
unsicher über den Gerätenamen Ihrer SD-Karte
sein, lassen Sie sich durch Eingabe von df -h in
die Befehlszeile eine Liste aller Geräte
ausgeben.
Um eine Sicherheitskopie Ihres Raspberry-Pi-
Setups anzulegen, können Sie eine neue Image-
Datei erzeugen, indem Sie die if- und of-Flags,
die für Input und Output stehen, beim dd-Befehl
umkehren:
sudo dd if= of=
bs=4k
Das Image kann dann noch komprimiert werden,
beispielsweise mit gzip oder bzip.
+
Raspbian
Arch Linux
Raspbian ist die Distribution, die
von der Raspberry Pi Foundation
offiziell empfohlen wird. Falls Sie
keinen triftigen Grund haben, ein
anderes Ssystem zu verwenden,
können Sie ruhig zu Raspbian
greifen. Es basiert auf Wheezy,
der neuesten Version der beliebten
GNU/Linux-Distribution Debian,
und kann daher auf die umfangreichen
Debian-Repositorys
zurückgreifen. Die Standard-
Desktopumgebung von Raspbian
heißt LXDE, eine sehr schlanke,
dadurch aber auch etwas spartanische
Benutzeroberfläche. Wer
mehr fürs Auge möchte, fährt mit
Xfce vielleicht besser. Im Lieferumfang
von Raspbian ist das
praktische Konfigurationsprogramm
raspi-config enthalten.
Der Raspberry Pi ist so konzipiert,
dass auch Kinder mit ihm
zurechtkommen, und diesem
Ansatz folgt auch Raspbian.
Bezugsquelle: raspberrypi.org
Im Gegensatz zu Raspbian, das
den Anwender eher vom internen
Setup des Systems abschirmt,
ist Arch Linux so konzipiert,
dass es dem Anwender
das Verständnis der
Arbeitsweise des Systems
erleichtert. Das Basis-Image
enthält nur die nötigsten
Komponenten, und alles
Weitere kann man später je
nach Wunsch hinzunehmen,
was allerdings auch einiges an
Arbeit (und natürlich jede
Menge Erfahrung in der
Zusammenstellung der
Einzelteile einer Distribution)
mit sich bringt. Das offizielle
Wiki zu Arch Linux finden Sie
auf archlinux.org.
Bezugsquelle: raspberrypi.org
Raspbmc
Android
Auch wenn der Raspberry Pi
im Hinblick auf Bildungszwecke
konzipiert wurde, haben viele
Bastler sehr schnell auch die
Spiele- und Unterhaltungsmöglichkeiten
des Geräts für sich
entdeckt. Die Distribution Raspbmc
verwandelt Ihren Raspberry
Pi in ein Medienzentrum, mit
dem Sie Ihr Fernsehgerät steuern
können.
Raspbmc basiert auf XBMC,
das es ermöglicht, Musik- und
Videodateien aus Ihrem Fundus
abzuspielen oder Inhalte aus
dem Netz zu streamen.
Mehr zu Raspbmc gibt es auf
Seite 67 in diesem Heft.
Bezugsquelle: raspbmc.com
Vielleicht bleibt es nur ein frommer
Wunsch, vielleicht wird es
eines Tages Wirklichkeit: ein gut
lauffähiges Android auf dem Raspberry
Pi. Von offizieller Seite wird
inzwischen abgewunken, aber einige
Fans versuchen weiterhin einen
eigenen Ansatz, wobei jedoch
alles ziemlich ruckelt und holpert.
Falls sich etwas tut, werden Sie
es auf razdroid.net erfahren.
Bezugsquelle: Ask Google
55

Projekte
Raspbian
+
Für die meisten Pi-Benutzer wird Raspbian
das „Gesicht“ ihres Geräts darstellen.
Eine Schritt-für-Schritt-Anleitung
zur Installation von Raspbian finden Sie auf
Seite 16-21. Sie können das Betriebssystem
sehr einfach auf dem neuesten Stand halten,
wenn Sie mit den folgenden Befehlen
Updates und Upgrades durchführen:
sudo apt-get update
sudo apt-get upgrade
Das Konfigurationsprogramm raspi-config
ist ein sehr nützliches Werkzeug, um Ihren
Raspberry Pi optimal einzustellen. Es startet
beim erstmaligen Booten des Geräts automatisch,
kann aber ansonsten jederzeit mit
der Eingabe des Befehls sudo raspi-config in
die Kommandozeile aufgerufen werden. Eine
genaue Übersicht über die Optionen, die
Ihnen das Tool bietet, finden Sie auf Seite
28-31, hier seien nur einige in aller Kürze
herausgegriffen:
expand_rootfs: Das Dateisystem von
Rasp bian belegt nur 2 GB Speicherplatz.
Falls Sie also eine größere SD-Karte benutzen,
würde der ungenutzte Platz verfallen,
oder aber Sie erweitern das Dateisystem
mit dieser Option.
memory_split: Der Pi verwendet denselben
RAM-Speicher sowohl für seine CPU als auch
für seine GPU. Mit dieser Option können Sie
die Ressourcenaufteilung zwischen den beiden
Chips verändern.
overclock: 50 % mehr Prozessorleistung!
Ja, und wie? Schauen Sie in den Kasten
unten auf dieser Seite.
boot_behaviour: Hier können Sie einstellen,
dass der Raspberry Pi direkt in
die grafische Benutzeroberfläche booten
soll.
Die Installationssoftware von Raspbian
umfasst nicht allzu viele Tools. Was Sie
vermissen, können Sie jedoch nachinstallieren.
Die benötigten Pakete finden Sie
in den umfangreichen Debian-Repositorys.
Falls Sie Ihre Softwareverwaltung lieber
auf einer grafischen Oberfläche vornehmen,
empfehlen wir ihnen das Paketmanager-Interface
Synaptic. Installieren Sie
es mit
sudo apt-get install synaptic
und öffnen Sie es über die Einstellungsoptionen
im LXDE-Menü.
12 coole Raspberry-Projekte
Wie alle guten Distributionen enthält natürlich
auch Raspbian eine Auswahl süchtig machender
Zeitfresser wie etwa Squirrels hier im Bild.
1 Ein Kindle als Bildschirm: www.ponnuki.net/2012/09/kindleberry-pi
2 Pi-Supercomputer (aus Lego): http://bit.ly/OGBGfD
3 Steuerung einer Arduino-Plattform über das Web: http://bit.ly/Xyjsld
4 Bau eines Synthesizers: www.raspberrypi.org/archives/1878
5 Roboterfahrzeug mit Nachtsichtgerät: www.aonsquared.co.uk/the_dark_pi_rises
6 Solar-Datenlogging mit dem Raspberry Pi: http://bit.ly/MHwCHF
7 Echtzeitübersetzung: www.willpowell.co.uk/blog/?p=219
8 Pi in einem Wetterballon hoch über der Erde: www.daveakerman.com/?p=592
9 Bierbrauanlage: http://bit.ly/PSfdzr
10 Pi als Retro-Spielekonsole: http://petrockblog.wordpress.com/retropie
11 Wie man ein Betriebssystem baut: www.cl.cam.ac.uk/freshers/raspberrypi/tutorials/os
12 Pi als Erinnerungsfoto-Drucker: http://bit.ly/PvmWjF
Overclocking
Der Prozessor unter der Haube des Raspberry
Pi ist dafür ausgelegt, mit einer Taktung von
700 MHz zu arbeiten. Das bedeutet, er führt
700.000.000 Rechenoperationen pro Sekunde
aus. Allerdings bedeutet „dafür ausgelegt“ nicht,
dass man diesen Wert nicht noch steigern
könnte. Das kann man nämlich.
Damit einher geht allerdings ein höherer
Stromverbrauch, woraus wiederum eine größere
Wärmeentwicklung resultiert. Hier muss man
etwas aufpassen, denn dadurch kann die
Platine beschädigt werden.
Praktischerweise enthält das Konfigurationswerkzeug
des Raspberry Pi, raspi-config, eine
Option (jedenfalls in den Programmversionen
seit Ende 2012), bei der man das Overclocking
(Übertakten) schrittweise einstellen kann und
gleichzeitig die erlaubte Wärmeentwicklung
gedeckelt ist. Da es sich um ein offizielles Tool
des Herstellers handelt, erlischt durch das Overclocking
auch nicht die Garantie des Geräts
(wie das bei Eigenmaßnahmen der Fall wäre).
Das Konfigurationsprogramm rufen Sie mit
dem Befehl sudo raspi-config in der Kommandozeile
auf, suchen Sie dort dann die Option overclock.
Es gibt mehrere Einstellungsschritte bis
zu einer Mehrleistung von 50 %. Sollten Sie im
übertakteten Modus Stabilitätsprobleme bei
Ihrem Raspberry Pi feststellen, starten Sie ihn
neu und drücken Sie während des Bootens die
Shift-Taste, um das Overclocking zu
deaktivieren.
Falls Sie die Temperatur des Prozessors in
konkreten Werten angezeigt bekommen möchten,
können Sie der LXDE-Oberfläche ein Temperatur-Widget
hinzufügen. So oder so schaltet
sich das Overclocking automatisch aus, sobald
eine Temperatur von 85 Grad Celsius erreicht
wird.
Die Übertaktung des Pi-Prozessors führt zu
einem Mehr an Stromverbrauch, und das kann
sich auf die Stabilität der Rechenleistung
auswirken.
56

Raspbmc
Falls Sie Ihren Raspberry Pi im Sinne
eines Computers für den allgemeinen
Gebrauch mit gelegentlicher Medienwiedergabe
verwenden, können Sie einen
Media-Player wie VLC auf dem Raspbian-
Betriebssystem installieren und sind vermutlich
damit gut versorgt. Die geringe
Größe und der geräuschfreie Betrieb des
Raspberry Pi machen diesen aber auch zum
perfekten Kandidaten für die Einrichtung
eines persönlichen Entertainment-Centers.
Ein solches Projekt lässt sich sicher auch
auf der Grundlage von Raspbian umsetzen,
aber wenn Sie sich die Arbeit nicht machen
möchten, können Sie direkt auf ein vorgefertigtes
Media-Betriebssystem namens
Raspbmc zurückgreifen. Das geht so:
Laden Sie das Installationsprogramm
von der offiziellen Website raspbmc.com
herunter, kopieren Sie es auf den Pi (wozu
ein funktionierendes Raspbian notwendig
ist), und geben Sie Folgendes ein:
sudo python install.py
Im Zuge der Installation werden die
Daten auf Ihrer SD-Karte gelöscht. Sichern
Sie also zuvor alles Wichtige. Nachdem das
Installationsprogramm durchgelaufen ist,
führen Sie einen Neustart des Systems
durch. Sobald die grafische Oberfläche lädt,
sehen Sie sofort den Unterschied:
Raspbmc verwendet den beliebten XBMC-
Media-Desktop, der sich ziemlich vom
schlichten Design der Raspbian-Standardoberfläche
LXDE unterscheidet. Sie können
mit Raspbmc Medien abspielen, die lokal
auf Ihrem Gerät gespeichert sind, aber
Die Platinen der neueren Variante des Raspberry
Pi (Revision 2) besitzen Befestigungslöcher,
damit das Gerät elegant untergebracht
werden kann.
Dies ist die Standardoptik der Fernbedienungsfunktion von Raspbmc, aber Sie können bei den
Settings ein anderes Design einstellen.
auch Inhalte aus dem Internet streamen,
wofür Sie dann allerdings spezielle Add-ons
brauchen.
Lokale Musik- und Videodateien können
entweder von einem USB-Speichergerät
geladen werden oder per FTP (mit den
üblichen Logindaten „pi“ und „raspberry“)
direkt von der SD-Karte.
Je nachdem, über welchen Anschluss
(Audio-Ausgang mit 3,5-mm-Klinkenbuchse
oder HDMI-Buchse) sie das Tonsignal senden
möchten, müssen Sie bei den Systemeinstellungen
noch zwischen analog und
HDMI wählen.
Bliebe noch die Frage, wie Sie Ihr Fernsehgerät
vom Raspberry Pi aus ansteuern.
Mit Tastatur und Maus könnte das auf die
Dauer ein wenig unbequem werden. Die
Entwickler von XBMC haben darum einen
Fernbedienungsmodus eingebaut. Am einfachsten
und sichersten lässt sich das mithilfe
der Weboberfläche von Raspbmc bewerkstelligen
– so können Sie mit jedem
Gerät, das sich im selben Netzwerk befindet
und auf dem ein Webbrowser installiert
ist, die Wiedergabe steuern. Dieser Modus
ist standardmäßig eingestellt, das heißt,
Sie benötigen nur noch die IP-Adresse Ihres
Raspberry Pi, um diesen von einem anderen
Gerät aus per Webbrowser ansprechen
zu können. Die IP-Adresse finden Sie unter
System > System Info.
Sie können für die Fernsteuerung auch
ein Android- oder iOS-Mobilgerät benutzen.
Hierzu sind diverse Anwendungen in den jeweiligen
App Stores zu finden.
Für Fortgeschrittene
Wenn man möchte, kann man sogar seinen
gesamten Fernsehkonsum – auch das Anschauen
von TV-Sendungen direkt aus dem
Live-Programm und die Aufzeichnung von
Sendungen – per Linux steuern. Dies geht
mittels MythTV (Bezugsquelle: mythtv.org),
wobei ein separater Computer mit TV-Anschluss
als Server fungieren muss. Leider
ist MythTV dafür bekannt, dass die Installation
extrem kompliziert ist.
Sie können auch Videos abspielen, die
auf anderen Geräten innerhalb Ihres Netzwerks
gespeichert sind, zum Beispiel auf
einem Dateiserver. Die genaue Vorgehensweise
kann sich dabei je nach Hardware
und Datentyp unterscheiden. Konsultieren
Sie am besten das XBMC-Wiki unter
http://bit.ly/OOvXb6.
57

Projekte
Kamera-Controller
Sichern Sie Ihre Fotoaufnahmen mithilfe des Raspberry Pi.
Da der Raspberry Pi so klein ist, eignet
er sich hervorragend dafür, andere eingebettete
Systeme zu steuern. Man
könnte zwar meinen, das wäre überflüssig,
da die eingebetteten Systeme selbst ja bereits
eine eigene Steuereinheit besitzen, aber
mit dem Pi haben wir die Möglichkeit, den
entsprechenden Geräten neue Funktionen
angedeihen zu lassen, die sie aus eigener
Kraft nicht (oder nur mit viel Aufwand) bewältigen
könnten. Fast alles, was man an einen
normalen Desktop-PC anschließen kann,
lässt sich auch vom Pi mit einem Skript ansprechen,
doch in unserem Beispiel wählen
wir eine Digitalkamera als Versuchsobjekt
aus, und zwar aus zwei Gründen: Erstens
unterstützt Linux beinahe jede Kamera, und
zweitens gibt es eine Menge nützlicher Anwendungen,
die man mit dem Pi und einer
Kamera durchführen kann, sobald man das
Grundkonzept verinnerlicht hat.
Das beste Befehlszeilen-Tool für die Steuerung
von Digitalkameras, das unter Linux zu
haben ist, heißt gPhoto2. Holen Sie es sich
mit folgendem Kommando:
apt-get install gphoto2
Bevor wir in die Einzelheiten unseres Projekts
gehen, beschäftigen wir uns kurz mit
diesem nützlichen Werkzeug und seinen
Fähig keiten. Da die grafische Benutzeroberfläche
des Raspberry Pi möglicherweise versuchen
würde, die Kamera als Ressource
einzubinden, und dies gPhoto2 vor einige Probleme
stellen würde, ist es ratsam, den Pi
ohne den grafischen Desktop hochzufahren.
Stromversorgung
Der Raspberry Pi bezieht seine Stromversorgung
über den Micro-USB-Port. Dieser liefert eine
Spannung von 5 V, und die Raspberry Pi Foundation
empfiehlt eine Stromstärke von mindestens
700 mA. Diese kann problemlos von einem
Netzteil oder per USB-Verbindung von einem
anderen Computer zur Verfügung gestellt werden.
Dies können Sie im Konfigurationsprogramm
raspi-config einstellen. Öffnen Sie dieses mit
dem Befehl sudo raspbi-conf, wählen Sie
beim Punkt boot_behaviour „No“, um den Pi
ohne Desktop hochzufahren (siehe auch
Seite 31), und booten Sie erneut.
„Der Pi eignet sich hervorragend
dafür, andere eingebettete
Systeme zu steuern.“
Sie befinden sich nun in der Nur-Text-
Steuerungsumgebung des Pi. Schließen Sie
die Kamera an und tippen Sie:
gphoto2 --auto-detect
Dieses Kommando führt dazu, dass nach
Kameras gesucht wird, die mit dem Pi verbunden
sind. Die allermeisten Digitalkameras
werden unterstützt. Sollten Sie jedoch das
seltene Pech haben, dass gerade Ihr Modell
nicht auf der Liste steht, haben Sie leider
keine Möglichkeit, es auf dem Pi zu
Mithilfe eines kleinen Skripts können Sie den Raspberry Pi automatisch Fotos von einer
Digitalkamera herunterladen lassen.
Wenn Sie den Pi als portables Gerät benutzen
möchten, gibt es andere Optionen. Vier AA-
Batterien sollten – eine adäquate Verbindung
zum Gerät vorausgesetzt – genügend Strom zur
Verfügung stellen. Am besten gefiel uns jedoch
die Variante, einen Ersatzakku für Smartphones
direkt am Raspberry Pi einzustecken.
aktivieren, sondern müssen auf eine andere
Kamera ausweichen, wenn Sie den Versuch
durchführen möchten.
Da die unterstützten Kameras sich in Ihren
Steuerungsmöglichkeiten voneinander unterscheiden,
müssen wir zunächst etwas über
die spezifischen Gegebenheiten
des verwendeten Modells herausfinden.
Mit dem Kommando
gphoto2 --auto-detect --abilities
lassen Sie sich die verfügbaren
Aktionen anzeigen. Grundsätzlich
gibt es zwei verschiedene
Gruppen von steuerbaren Aktionen:
Capture (Aufnahme) sowie Upload/Download.
Falls Aufnahmeaktionen möglich sind – was
in der Regel eher bei höherwertigen Kameras
der Fall ist –, kann man mittels Skriptbefehlen
Fotos schießen. Upload/Download bedeutet,
dass Bilder, die auf der Speicherkarte
archiviert sind, weiterverarbeitet werden können
– diese Aktionsart ist bei den meisten
unterstützten Kameras verfügbar.
Im Rahmen dieses Projekts beschränken
wir uns auf die Upload/Download-Funktionen.
Das simpelste Kommando, dass wir einer
Kamera übermitteln können, ist die Anweisung,
alle gespeicherten Fotos zu
übertragen:
gphoto2 --auto-detect --get-all-files
Damit werden alle Dateien von der Kamera
in das aktuelle Verzeichnis heruntergeladen.
Bei einem normalen PC wäre das problemlos
möglich, doch beim Raspberry Pi sollte man
angesichts des begrenzten Speicherplatzes
auf der SD-Karte die Fotos lieber auf einem
anderen Medium wie zum Beispiel einem
USB-Stick speichern. Um dies in einer interaktiven
Sitzung durchzuführen, könnte man
den USB-Stick einfach mithilfe eines Tools
mit grafischer Benutzeroberfläche einhängen,
dann den Befehl df -h ausführen, um den Einhängepunkt
festzustellen, und schließlich mittels
cd in das entsprechende Verzeichnis
wechseln.
58

Da das Ganze jedoch automatisch vonstattengehen
wird, müssen wir den Ort des Geräts
kennen. Es gibt mehrere Möglichkeiten,
diesen festzumachen, aber wir werden es
einfach halten. Wir hängen die erste Partition
der ersten seriellen Platte ein und speichern
die Bilder dort.
Wir gehen davon aus, dass Sie den Standardnutzer
„pi“ verwenden, andernfalls müssen
Sie das Skript entsprechend anpassen.
Zunächst müssen wir einen Einhängepunkt
für das Laufwerk festlegen. Es handelt sich
dabei lediglich um einen Ordner, und dieser
kann an einer beliebigen Stelle angelegt werden.
Wir weichen hier von der Konvention ab
und erstellen den Ordner im Home-Verzeichnis
– wie folgt:
mkdir /home/pi/pic_mount
Danach können wir mit dem Skript beginnen.
Mit diesem werden wir das Laufwerk
einhängen und die Fotos herunterladen:
#!/bin/bash
if mount /dev/sda1 /home/pi/pic_mount ;
then
echo „Partition mounted“
cd /home/pi/pic_mount
yes ‚n‘ | gphoto2 --auto-detect
--get-all-files
umount /dev/sda1
else
echo „/dev/sda1 could not be mounted“
fi
Der Befehl yes ‚n‘ gibt lediglich eine Reihe
von n Zeichen aus, das heißt, wenn mit
gphoto2 eine zuvor heruntergeladene Datei
überschrieben werden soll, wird dies zurückgewiesen.
Das umount ist unabdingbar, da
es dafür sorgt, dass das Laufwerk korrekt
synchronisiert wird und dann entfernt werden
kann.
Wir nennen das Skript get-pics.sh und
speichern es im Home-Verzeichnis des Raspberry
Pi ab. Um es ausführbar zu machen,
geben Sie ein:
chmod +x /home/pi/get-pics.sh
Sie sollten das Skript nun manuell starten
können. Dabei müssen Sie sudo verwenden,
Netzwerkverbindung
Einen Raspberry Pi mit dem Internet zu verbinden,
bewerkstelligen Sie (jedenfalls beim Modell B) am
einfachsten über ein Ethernet-Kabel. In Fällen, wo
eine Kabelverbindung unpraktisch ist (und generell
beim Modell A, das keinen Ethernet-Anschluss
besitzt), bietet sich ein USB-Wireless-Adapter als
drahtlose Alternative an. Diesen können Sie mit
Ihrem Router verbinden, aber es ist auch möglich,
ein Smartphone als Modem einzusetzen. Falls
diese Funktion (Tethering) nicht vom Telefonanbieter
gesperrt worden ist, können Sie zum
Beispiel bei einem Android-Mobilgerät dessen
WLAN- oder 3G-Verbindung mit dem Pi teilen.
da das Skript das Laufwerk einhängen muss.
Der letzte Schritt besteht darin, das Skript
automatisch ausführen zu lassen. Dazu
fügen wir es der Datei etc/rc.local hinzu.
Das Skript startet während des Bootvorgangs
und läuft unter Root, darum brauchen wir uns
keine Gedanken über irgendwelche Berechtigungen
zu machen. Öffnen Sie einfach die
Datei als Root mit einem Texteditor,
beispielsweise mit dem Befehl sudo nano /
etc/rc.local, und fügen Sie
/home/pi/get-pics.sh
///end code///
direkt vor der Zeile exit 0 ein.
Jetzt brauchen Sie nur noch Ihre Kamera
anzuschließen (und einzuschalten!) und den
USB-Stick einzustecken, und schon werden
Ihre Fotos automatisch während des Bootvorgangs
auf den Stick kopiert.
Ausblick
Statt die Fotos auf einem USB-Stick zu speichern,
könnten Sie sie auch zu einem Online-
Dienst wie Flickr hochladen (siehe dazu Seite
106-109). Sie könnten auch eine Art Schalter
einbauen, mithilfe dessen Sie Ihrem Raspberry
Pi mitteilen, welche Fotos er uploaden und
welche er auf den USB-Stick speichern soll,
beispielsweise in Abhängigkeit von der Bildauflösung:
kleine Bilddateien auf Flickr hochladen
und große speichern.
Dabei müssen Sie aber nicht stehen bleiben.
Wenn Sie einen Wireless-Dongle an den
Pi anschließen, könnten Sie den Rechner als
HTTP-Server verwenden. Mithilfe von PHP
oder einer anderen webgeeigneten Skriptsprache
ist es möglich, eine Schnittstelle zu
gPhoto2 einzurichten, über die man sich per
Smartphone mit dem Gerät verbinden kann.
Schließlich könnten Sie sich – sofern Ihre
Kamera dies unterstützt – auch der erwähnten
anderen Gruppe steuerbarer Aktionen zuwenden,
nämlich Capture, und mithilfe des
Raspberry Pi die Fotoaufnahme auslösen.
gPhoto2 bietet noch viele weitere Features, auf die wir hier nicht näher eingehen, beispielsweise Javaund
Python-Anbindung. Infos dazu gibt es auf der Projekt-Website www.gphoto.org.
Sofern Ihr Mobilfunkvertrag eine Begrenzung des
Datenvolumens vorsieht, sollten Sie dies allerdings
im Hinterkopf behalten, wenn Sie mit dem
Pi größere Dateien aus dem Netz herunterladen.
Aktivieren Sie das Tethering auf Ihrem Mobilgerät
(bei den WLAN- und Netzwerkeinstellungen),
und verbinden Sie es mit dem Raspberry Pi. Auf
dem Pi tippen Sie sudo ifconfig in die Kommandozeile,
dann sollte die Schnittstelle als usb0
angezeigt werden, allerdings ohne IP-Adresse.
Netzwerkschnittstellen kontrollieren Sie auf dem
Pi mithilfe der Datei /etc/network/interfaces.
Standardmäßig existiert darin kein Eintrag für
USB-Networking, darum müssen Sie einen solchen
Eintrag selber vornehmen. Öffnen Sie die
Datei als sudo mit einem Texteditor, etwa mit
dem Befehl sudo nano /etc/network/interfaces,
und fügen Sie dort die folgenden Zeilen hinzu:
iface usb0 inet dhcp
nameserver 208.67.220.220
nameserver 208.67.222.222
Es handelt sich hierbei um allgemeine Nameserver
des Unternehmens OpenDNS, es stehen aber auch
Alternativen zur Verfügung. Nach einem Neustart
werden die Änderungen wirksam, und Ihr Raspberry
Pi sollte mit dem Internet verbunden sein!
59

Projekte
LED-Anzeige
Die GPIO-Pins des Raspberry Pi und was man mit ihnen machen kann.
Da der Raspberry Pi so klein ist, eignet
er sich hervorragend dafür, andere
eingebettete Systeme zu steuern. Ja,
das hatten wir schon, aber es bleibt richtig
und zeigt die Vielseitigkeit dieses Wunder -
winzlings.
Es gibt allerdings ein kleines Problem, und
das ist, dass man nicht erkennen kann, was
gerade im Raspberry Pi vor sich geht, wenn
man ihn „headless“ betreibt, also ohne angeschlossenen
Monitor und Tastatur. An eine
mögliche Lösung dieses Problems haben die
Pi-Entwickler jedoch bereits gedacht: Der
Rechner ist mit einer Reihe GPIO-Pins ausgestattet.
Dies sind Kontaktstifte mit integrierten
Schaltkreisen zur Allzweckein- und
-ausgabe.
Die insgesamt 26 GPIO-Pins befinden sich
Das ohmsche Gesetz
am Rand der Platine, zwischen dem Video-
Ausgang und dem Anschluss für die SD-
Karte. Die Schaltkreise können Informationen
von beliebigen Quellen ausgeben, doch in
diesem Beispiel werden wir sie dazu benutzen,
das letzte Byte (entspricht dem vierten
„Wenn man die falschen
Kontakte verbindet, kann
man den Pi zerstören!“
Zahlenblock) der aktuellen IP-Adresse des
Geräts anzuzeigen. Dies ist nützlich, wenn
man den Raspberry Pi per Fernzugriff steuern
möchte, aber keine statische IP-Adresse einrichten
kann – etwa, weil das Gerät in
GND Pin 7 Pin 8 Pin 25 Pin 23
A
B
C
D
E
F
G
H
I
J
1 5 10 15 20 25 30
1 5 10 15 20 25 30
Abbildung 1: Hier Sehen Sie, wie wir die einzelnen Bauteile auf einer Steckplatine angeordnet
haben. Die übrigen vier LEDs werden in gleicher Weise verdrahtet.
verschiedenen Netzwerken eingesetzt wird.
Die ersten drei Bytes (oder Zahlenblöcke) der
IP-Adresse lassen sich meist mithilfe der
Netzmaske herausfinden, doch das letzte
Byte ist oft schwierig zu ermitteln, wenn kein
Monitor angeschlossen ist.
Für unser Projekt benötigen wir
das Programm gpio, das ein Element
der WiringPi-Bibliothek darstellt. Vertiefende
Informationen dazu sind
unter http://bit.ly/RP8UKJ zu finden.
Da die Software als Quellcode
zur Verfügung gestellt wird, müssen
Sie sie zunächst entpacken und kompilieren.
tar xvf wiringPi.tgz
cd wiringPi/wiringPi
make
sudo make install
cd ../gpio
make
sudo make install
Außerdem brauchen wir noch bc:
sudo apt-get install bc
So viel zur Software, nun ist die Hardware
an der Reihe. Zuvor jedoch ein warnender
Hinweis: Wenn man die falschen Kontakte
miteinander verbindet, kann man dem Raspberry
Pi den Garaus machen! Vergewissern
Sie sich daher lieber zweimal, ob Sie den
richtigen Draht in der Hand haben, bevor Sie
etwas zusammenlöten oder -stecken.
Die Schaltung ist bei unserem Versuch
sehr simpel: Wir müssen jeden Output mit
dem Pluspol (dem langen Anschlussstift)
einer LED verbinden, den Minuspol (den kurzen
Stift) jeder LED mit einem elektrischen
Widerstand von 1 kOhm und das andere
Ende jedes Widerstandes erden (siehe Abbildung
3). Die einzelnen Bauteile haben wir auf
einer Steckplatine angeordnet (siehe Abbildung
1).
Wenn Sie alles zusammengebaut und mit
dem Pi verbunden haben, können Sie mit der
Elektrizität wird in zwei physikalischen Größen
gemessen: Spannung und Stromstärke. Die
Spannung – die in Volt (V) gemessen wird – ist
die Menge Energie, die eine bestimmte Anzahl
von Elektronen besitzt, während die Stromstärke
– die in Ampere (A) gemessen wird – die Menge
an Elektronen angibt, die einen Punkt passiert.
Im ohmschen Gesetz wird ein Zusammenhang
zwischen den beiden Größen hergestellt:
Spannung = Stromstärke x Widerstand (oder als
Formel: U = IR). Sie können dieses Gesetz anwenden,
um zu verhindern, dass Ihr Raspberry Pi zu
Toast wird, indem zu viel Strom in ihn hineinfließt.
Das Setup des Pi ist in dieser Hinsicht recht komplex.
Gert van Loo, einer der Entwickler des Geräts,
erklärt es unter http://bit.ly/Qp4PMl ausführlich.
Aber als Faustregel lässt sich sagen, dass 3,3 V
und 16 mA das Maximum an Output und Input bei
einem GPIO-Pin sind. Nach dem ohmschen Gesetz
errechnet sich daraus ein Widerstand von 206,25
Ohm, der mindestens gegeben sein muss, damit
der Raspberry Pi nicht beschädigt wird. Sie sollten
jedoch einen Sicherheitsabstand von den erwähnten
Werten einhalten, um das Gerät keiner Gefahr
auszusetzen. In unseren Schaltungen haben wir
einen Widerstand von 1.000 Ohm benutzt, also
sozusagen einen Sicherheitsfaktor von 5 eingebaut.
60

Programmierung beginnen. Für den Anfang
nehmen wir uns nur den letzten Pin vor, dies
ist Pin Nr. 7 (die Nummerierung der Pins folgt
nicht der Reihenfolge ihrer Anordnung). Öffnen
Sie die Befehlszeile, und setzen Sie den
Pin auf Output:
gpio -g mode 7 out
Nun können Sie den Pin aktivieren:
gpio -g write 7 1
Und deaktivieren:
gpio -g write 7 0
Jetzt können wir uns das komplette Skript
vornehmen. Es besteht aus vier Teilen. Der
erste sorgt lediglich dafür, dass sich die einzelnen
Pins im korrekten Modus befinden
und ausgeschaltet sind:
pins=“7 8 25 24 23 18 15 14“
for x in $pins
do
gpio -g mode $x out
gpio -g write $x 0
done
Im zweiten Teil wird mithilfe von ifconfig
die IP-Adresse des Pi ausgelesen, ins Binärformat
umgewandelt und gegebenenfalls mit
Führungsnullen aufgefüllt.
ipaddress=‘ifconfig eth0 | grep ‚inet ‚ |
awk ‚{print $2}‘ | cut -f4 -d‘.‘‘
binary=‘echo
„ibase=10;obase=2;$ipaddress“ | bc‘
paddedBinary=‘printf %08d $binary‘
Im dritten Teil extrahieren wir mittels cut-
Befehl den gewünschten Teil aus dem Binärstring
und leiten die Information an den zuständigen
Pin weiter.
bit=1
for x in $pins
do
out=‘echo $paddedBinary | cut -b$bit‘
gpio -g write $x $out
bit=$((bit+1))
done
Im letzten Teil weisen wir das Skript an,
5 Minuten lang zu schlafen und dann die
Offizielles Zubehör: Gertboard
Indem Sie eine direkte Verbindung mit den GPIO-
Pins Ihres Raspberry Pi herstellen, erlangen Sie
eine einfache Eingabe- und Ausgabekontrolle,
doch diese ist in den Möglichkeiten begrenzt.
Es gibt jedoch ein sehr interessantes Zubehör
für den Pi, das Sie einsetzen können, um die
Interaktion sehr viel genauer zu gestalten.
Das Zubehör heißt Gertboard. Es handelt sich
um ein umfassendes Erweiterungsset, das
jedoch in der Basisausttattung aus Einzelteilen
Pin 7 Pin 8 Pin 25 Pin 24
LEDs auszuschalten.
sleep 5m
for x in $pins
do
gpio -g write $x 0
done
Das war es auch schon. Erstellen Sie die
Datei showIP.sh, und machen Sie sie zu
einer ausführbaren Datei:
chmod a+x showIP.sh
Geben Sie sudo ./showIP.sh ein, um die
IP-Adresse anzeigen zu lassen. Um das Programm
beim Booten automatisch starten zu
Pin 7 Pin 8 Pin 25 Pin 24 Pin 23 Pin 18 Pin 15 Pin 14 GND
Abbildung 2: Verbinden Sie die Steckplatine mit den hier gezeigten Pins. Wir haben handelsübliche
einpolige Stecker verwendet, Sie können aber auch zum Lötkolben greifen.
GND
besteht und selbst zusammengebaut werden
muss (es gibt aber auch vorgefertigte Gertboards
zu kaufen). Es ist ideal zum Experimentieren
geeignet, da es unter anderem mit einem Arduino
(Micro-Controller), LEDs, A/D- und D/A-Wandler
sowie Schaltern ausgestattet ist. Es kann direkt
in den Raspberry Pi eingestöpselt werden.
Der Namensgeber des Gertboards ist Gert van
Loo, der entscheidend an der Entwicklung des
Raspberry Pi beteiligt war.
Pin 23 Pin 18 Pin 15 Pin 14
Abbildung 3: Hier eine schematische Darstellung unseres Schaltplans. GND steht für die Erdung.
lassen, müssen Sie in rc.local noch folgende
Zeile einfügen (siehe dazu auch Seite 69):
/home/pi/showIP.sh &
Sie haben nun gesehen, wie Sie mithilfe
der GPIO-Pins Output erzeugen können. Sie
können aber, da die Pins sowohl der Aus- als
auch der Eingabe dienen, ebenso gut Input
verarbeiten. Dabei ist es allerdings noch wichtiger,
dass nicht zu viel Strom in die Pins hineinfließt.
Um einen Kontaktstift von Output
auf Input umzuschalten, müssen sie dessen
Modus mit gpio -g mode in
ändern und den Wert mit gpio -g read auslesen.
Da unsere Schaltung beliebige acht Bits
an Information darstellen kann, brauchen Sie
sich nicht auf die Anzeige der IP-Adresse zu
beschränken. Es wäre beispielsweise denkbar,
den Kamera-Controller von Seite 68-69
zu modifizieren, indem Sie die LEDs dessen
Aktivität anzeigen lassen.
Sehr detaillierte Informationen zu allen
26 GPIO-Pins des Raspberry Pi erhalten Sie
unter http://bit.ly/JTlFE3. Die Pins, die wir
mit unserem Skript benutzt haben, haben in
Revision 1 und Revision 2 des Raspberry Pi
die gleiche Funktion, allerdings sind einige
der restlichen Pins beim Wechsel der Revisionen
anders belegt worden. Falls Sie eigene
Schaltpläne entwickeln oder welche aus dem
Internet nachbauen, vergewissern Sie sich,
dass sie mit der korrekten Pin-Belegung
arbeiten.
61

Arch Linux
Kann eine sich schnell ändernde, manchmal kaputte,
rasant vorpreschende Distribution ein ernsthafter
Mitbewerber sein? Zeit, das zu untersuchen.
Wissen Sie, was ein Ricer ist? Ricer
sind Leute, die ihre Autos mit
riesigen Spoilern, gigantischen
Auspuffen, teuren Radfelgen und
ähnlichem Schnickschnack aufmotzen, wobei
all diese Modifikationen jedoch so gut wie
keinen Effekt auf die tatsächliche Leistung des
Fahrzeugs haben.
Als Anfang der 2000er Jahre Gentoo Linux
in Fahrt kam, tauchte eine neue Art von
Ricer am Horizont auf: der Linux-Ricer. Die
Linux-Ricer trieben das quellcodebasierte
Design von Gentoo auf die Spitze und investierten
endlose Arbeitsstunden in das Feintuning
der Compiler-Optionen, nur um gedit
0,05 % schneller starten zu lassen. Gentoo
war (und ist immer noch) eine großartige
Distribution, aber das Verhalten einiger
Fans, die jeden anpöbeln, weil er „langsame“
Binärpakete nutzt, verliehen dem Betriebssystem
einen schlechten Ruf. Gentoo war außerdem
– eine Neuheit in jener Zeit – eine Rolling-
Release-Distribution: Während für fast alle
anderen Distributionen ein bis zwei Mal im
„Arch simplifiziert nichts,
Sie haben von Anfang an
alles unter Kontrolle.“
Jahr ein großes Update mit vielen Änderungen
anstand, wurde Gentoo kontinuierlich mit kleinen
Aktualisierungen versorgt. Man konnte
Gentoo zu jedem Zeitpunkt updaten und erhielt
dabei die volle Packung aus der Welt der
freien Software, ohne eine zeitaufwendige Überholung
des gesamten Systems durchführen zu
müssen.
Wie auch immer: Anno 2014 ist Gentoo immer
noch am Leben, doch viele Anhänger des Rolling-
Release-Ansatzes sind zu Arch Linux
(archlinux.org) übergelaufen. Die Distributionen
sind sich in Vielem ähnlich, auch
wenn Arch auf einem System aus Binärpaketen
basiert. Die Aushängeschilder der
Distribution sind ihre Einfachheit, die Geschwindigkeit,
mit der Pakete aktualisiert
werden, sowie die Tatsache, dass sie
nichts simplifiziert: Sie haben von Anfang an alles
unter Kontrolle. Arch hat vermutlich genauso
viele leidenschaftliche Befürworter wie Kritiker.
Lassen Sie uns mal nachsehen, was innerhalb
dieses Projekts so alles passiert.
62

Projekte
Das Arch-Konzept
Arch beherzigt das KISS-Prinzip („Keep it simple (and)
stupid“, also „Halte es einfach (und) schlicht“) und
setzt dieses mit einem recht minimalen und leichtgewichtigen
Basissystem um, das für Nutzer einen guten Startpunkt
für eigene Anpassungen und das Hinzufügen von Paketen
bietet.
Arch versucht nicht, Vermutungen anzustellen, was Ihnen
gefallen könnte, sondern sagt, „Hier ist die Basis, nimm sie
und baue die Linux-Distribution, die du haben möchtest.“
Ebenso versucht Arch, es so weit wie möglich zu vermeiden,
Software zu patchen. Manche Distributionen nehmen den
Original-Quellcode und fügen einen Patch nach dem anderen
hinzu, womit sich das Resultat über kurz oder lang stark von
der ursprünglichen Version unterscheidet. Das macht nicht
nur alles komplexer (alle Patches synchron zu halten), es
kann auch schwerer werden, einen Bug in der offiziellen Version
zu melden.
Während Arch großes Gewicht auf die Einfachheit legt,
schlägt sich dies nicht unbedingt in der Benutzerfreundlichkeit
nieder. Sie werden bei Arch kaum distributionsspezifische
Einrichtungsassistenten oder Einstellungswerkzeuge
finden: Diese werden als separate und unnötige Schicht der
Abstraktion empfunden. Stattdessen werden Sie dazu aufgefordert,
Verantwortung zu übernehmen und Linux in seinem
aufgeräumten und reinen Zustand zu erforschen, indem Sie
die bei fast allen Linux-Distributionen gängigen Werkzeuge
benutzen. Hier passt eine leicht veränderte Faustformel, welche
bereits bei Slackware häufig benutzt wurde: „Benutze
Ubuntu, und du lernst Ubuntu. Benutze Red Hat, und du
lernst Red Hat. Benutze Arch, und du lernst Linux“.
Wer gibt den Ton an?
Sie haben nun also eine Distribution, die minimalistisch und
weitestgehend ungepatcht ist, die zum Erforschen einlädt
und – zugegeben – eine steile Lernkurve hat. Die Entwicklung
von Arch findet ziemlich dezentral statt. Laut Allan McRae,
der zum Arch-Kernteam gehört, existiert keine richtige Hierarchie
unter den Arch-Entwicklern, auch wenn diejenigen, die
schon lange dabei sind und viel beigetragen haben, sich oft
mehr Gehör verschaffen können.
Aber was, wenn wichtige Entscheidungen getroffen werden
müssen, die die Aufmachung von Arch drastisch verändern?
Varianten von Arch
Hierzu sagt McRae: „Das Treffen von Entscheidungen ist bei
Arch meist nichts weiter als die Feststellung der Abwesenheit
von Einwänden. Wir gehen gemeinhin davon aus, dass die
Person, die an einer bestimmten Komponente arbeitet, auch
diejenige ist, die sich damit am besten auskennt. Bei tiefgreifenderen
Entscheidungen kann das jedoch viele weitere Fragen
nach sich ziehen, bis die letzten Zweifel der anderen Entwickler
ausgeräumt sind.“
Ein Beispiel dafür ist der Umstieg auf systemd. McRae erzählte
uns, dass dieser Prozess kontinuierlich vonstatten ging,
beginnend mit einem Entwickler, der experimentelle Pakete
erstellte, gleich nachdem das neue Boot-System freigegeben
worden war. Der Entwickler zweifelte, ob systemd je Einzug in
Arch finden würde. Aber als die Zeit fortschritt, begann Arch,
der Einfachheit halber die gleichen Konfigurationsdateien zu
nutzen. „Nach einer Weile stellten wir fest, dass viele Programme
die systemd-Dienstdateien integrierten und dass
viele Arch-Entwickler auf systemd umsteigen mussten. Das
führte zu einem Vorschlag auf einer Mailingliste, formell auf
systemd umzusteigen und initscripts fallen zu lassen.“
Die meisten der verbleibenden Arch-Entwickler stiegen
auf systemd um, und die auf der Mailingliste vorherrschende
Meinung war, dass es sich um die technisch bessere Lösung
handelt. „Die Änderungen wurden aufgrund fehlender Einwände
gemacht“, erklärt McRae, und es ist diese technische,
begründungsbasierte Herangehensweise, die viele Arch-
Fans mögen. Große Entscheidungen werden umsichtig getroffen,
sobald jeder das Pro und Contra des Vorschlags abgewogen
hat.
Die Installation
von Arch ist eine
langwierige und
komplizierte Aufgabe,
besonders
im Vergleich zu
anderen Distributionen.
Der
Vorgang ist aber
außergewöhnlich
gut dokumentiert.
Seit der Einführung von Arch im Jahr
2002 sind mehrere Distributionen
erstellt worden. Die meisten zielen
darauf ab, Arch ein wenig aufzupolieren
und benutzerfreundlicher zu
machen. Hier eine Auswahl:
Manjaro (manjaro.org) ist in
mehreren Abwandlungen erhältlich
und deckt die meisten Desktop-
Umgebungen ab. Manjaro hat
einen eigenen Paketmanager und
Konfigurationstools und benutzt
den Installer von Linux Mint.
Chakra (chakra-project.org) ist
ein Vorzeigeprodukt für den aktuellen
KDE-Desktop. Chakra hat einen
„halben“ Rolling-Release-Zyklus:
Während das Basissystem langsamer
als bei traditionellen Distributionen
aktualisiert wird, werden Desktop-
Anwendungen weit öfter gepflegt.
ArchBang (archbang.org) ist
eine einfache, leichtgewichtige Distribution,
bei der X und der Openbox-
Fenstermanager vorinstalliert sind.
Es wird alle paar Monate aktualisiert.
Der Installer von Chakra schmeichelt dem Auge,
genauso wie der Rest der Distribution.
63

Projekte
Arch im Detail
Da es bei Arch Linux keine Release-Versionen in dem
Sinne gibt, neue Nutzer jedoch eine praktikable Möglichkeit
brauchen, es auf ihren Rechner zu bekommen,
veröffentlicht das Arch-Team jeden Monat ein frisches
Installer-Image. Dieses ist etwa 520 MB groß und enthält nur
die notwendigste Software, um den Rechner zu booten.
Alles Weitere können Sie später mit Pacman herunterladen.
Das ist auch der Punkt, an dem das Rolling Release ins
Spiel kommt. Das Arch-Team empfiehlt die Verwendung von
pacman -Syu alle ein bis zwei Wochen, um die Distribution
über die Arch-Repositorys auf den aktuellen Stand zu
bringen.
Inzwischen laufen die Updates meist problemlos ab,
manchmal gehen aber auch Dinge kaputt. Sie sollten sich
dringend die News auf der Arch-
„Ein falscher Befehl,
und Sie könnten Ihr
System ruinieren.“
Das ArchServer-Projekt
liegt
leider auf Eis,
aber vielleicht tut
sich irgendwann
wieder etwas
bei dieser Initiative,
die darauf
abzielte, Arch für
die Verwendung
als Server-Betriebssystem
stabiler
zu machen.
Website durchlesen, bevor Sie ein
Update durchführen. Das ist eine
der kontroverseren Eigenschaften
von Arch Linux, im Grunde aber
konsequent. Manchmal jedoch ist
der Schaden so gravierend, dass
man sich gut überlegen sollte, ob man Arch auf Produktivrechnern
einsetzt.
Stabilität versus Aktualität
So kündigte das Arch-Team im Sommer 2013 an, ein vereinigtes
Verzeichnis /usr/bin einzuführen und dafür /bin
und /sbin zu entfernen – an sich ein aus Gründen der Übersichtlichkeit
begrüßenswertes Vorhaben. Allerdings war der
Aufwand der Nutzer, um die Änderung zu bewerkstelligen,
alles andere als trivial. Sie mussten Dateien manuell hin und
her kopieren, das System auf eine Vielzahl von Paketen hin
überprüfen sowie Befehle wie diesen ausführen:
paclist | awk ‘ { print $1 } ‘ | pacman -Ql - | grep ‘
/s\?bin/\| /usr/sbin/’
All das ist für fortgeschrittene Linux-Nutzer machbar,
allerdings braucht es Zeit und eine Menge Konzentration.
Ein falscher Befehl, und Sie könnten Ihr System ruinieren.
Falls Sie Linux als Hobby betrachten und damit auf einem
sonst unbenutzten Rechner herumspielen, ist das vertretbar,
doch was ist, wenn Sie Linux auf der Arbeit einsetzen
oder als Server? Ausfälle aufgrund derartiger Anpassungen
kann man sich nicht leisten, ebenso wenig, dass Anwendungen
danach nicht mehr funktionieren.
Wenn man den größten Wert auf ein stabiles System
legt, das sich wenig verändert und nur Flicken für kritische
Sicherheitslücken erhält, ist man wohl bei Debian, RHEL
oder CentOS am besten aufgehoben.
Andererseits entgehen einem
dann die Vorzüge eines Rolling-Release-Systems
wie Arch Linux, wie
zum Beispiel eine höhere Aktualität.
Das Arch-Team ist sich dieses
Problems jedoch bewusst und hat
Schritte unternommen, es zu lindern.
Die Distribution besitzt ein „linux-lts“-Paket,
welches einen Kernel
mit Langzeit-Unterstützung beinhaltet.
Dieser ändert sich nicht so
schnell wie der Kernel des Hauptzweigs
von Arch Linux. Unter
http://tinyurl.com/44alfmh finden
Sie detaillierte Erklärungen, wie
Sie die Stabilität einer Arch-Installation
verbessern können.
Was gehört wohin?
Wie fast jede andere Linux-Distribution
stellt auch Arch seine Software in diversen
Repositorys zur Verfügung. Zwischen
diesen wird sehr genau unterschieden:
Core Die allerwichtigsten Pakete, um ein
System zu starten, es mit dem Internet zu
verbinden und ein kaputtes Dateisystem zu
reparieren. Einige weniger wichtige, aber häufig
genutzte Werkzeuge wie etwa OpenSSH
sind ebenfalls dabei. Core hat die restriktivste
Qualitätskontrolle aller Repositorys.
Extra Was nach einem Repository voll
mit optionaler Software klingt, enthält in
Wirklichkeit fast die gesamte Software,
deren Nutzung Sie gewohnt sind, wie etwa
X.org, Firefox, KDE, Apache und so weiter.
Community Pakete vom Arch User
Repository (siehe unten), die ein positives
Feedback erhalten haben.
Testing Diese Pakete sind nicht für
den Alltagsgebrauch zu empfehlen,
da hier experimentelle Pakete landen,
deren Bugs erst ausgebügelt werden
müssen. Danach wandern die Pakete
entweder nach Core oder nach Extra.
Arch User Repository (AUR) Eine
großartige Quelle seltener Software, die
sich mitten in der Entwicklung befindet und
noch nicht verpackt wurde oder aufgrund
von Lizenzproblemen nicht in den anderen
Repositorys untergebracht werden kann.
Jeder darf bei AUR mitmachen, weshalb
die Qualität der Software stark schwankt.
64

Projekte
Das sagen Admins
Arch behauptet von sich, jeder Aufgabe gewachsen und
eine ideale Distribution für Server zu sein, doch die
Schilderungen auf den vorherigen Seiten lassen Zweifel
daran aufkommen. Wir haben Allan McRae mit unseren Bedenken
konfrontiert, und das Folgende ist seine Sicht der Dinge.
Allan McRae: Der ausschlaggebende Faktor ist, wie gut der
Administrator sich mit Arch auskennt. Da Arch ein Rolling Release
ist, gibt es gelegentlich Update-Probleme. Wenn Sie
nicht damit vertraut sind, wäre eine Distribution, die lediglich
Sicherheits-Updates zur Verfügung stellt, besser für Sie geeignet.
Die typische Antwort darauf, ob Arch gut als Server-
Betriebssystem geeignet sei, lautet darum auch: „Nicht, wenn
du fragen musst.“
Ein weiterer zentraler Punkt ist, wo man Zeit investieren
möchte. Arch erfordert immer wieder ein bisschen Zeit, um
das System aktuell zu halten und Softwaretests durchzuführen,
bevor Änderungen in das Produktivsystem übernommen
werden können. Ein Sammel-Release stellt zwar Sicherheits-
Updates zur Verfügung, die kaum Testaufwand mit sich bringen,
doch dafür ist der Aufwand größer, wenn Sie ein Distributions-Update
durchführen müssen. Weil Arch Linux nur eine
oder einige wenige Komponenten auf einmal aktualisiert, kann
es leichter sein, etwaige Probleme einem bestimmten Paket
zuzuordnen, als es bei einem Distributions-Update der Fall ist.
Auch wenn Sie einmal eine neue Version einer Software benötigen,
etwa weil Sie ein neues Feature dringend brauchen, ist
Arch klar im Vorteil.
Was Sicherheits-Updates angeht, so gibt es bei Arch reguläre
größere Updates und gelegentliche kleinere Patches dort,
wo sie nötig sind. Es ist schwer zu sagen, was den Anwender
einem größeren Sicherheitsrisiko aussetzt: das – oder eine
Distribution, die stabile Softwareversionen nutzt, in Kombination
mit rückportierten Sicherheitspatches. Ich warte noch
darauf, dass jemand dies untersucht, damit Arch gegebenenfalls
seine Sicherheitsstrategie anpassen kann.
Berichte aus der Praxis
So weit also die Perspektive eines der Hauptentwickler von
Arch. Wichtig sind jedoch insbesondere auch die Erfahrungen
der Nutzer. Wir haben bei einigen Administratoren nachgefragt,
die Arch Linux auf Servern einsetzen.
Paul Gideon Dann: Ich betreibe Arch Linux auf zwei Servern
auf der Arbeit. Einer ist ein Vielzweck-Server, welcher einige
interne Web-Apps hostet, den Serverraum überwacht und als
Quellcode-Repository dient. Der andere Server ist ein Beowulf-Servercluster,
an dem 36 Knoten für anspruchsvolle
Rechenaufgaben hängen. Bis jetzt konnte ich keine nennenswerten
Downtimes feststellen. Die Änderung am /usr-Verzeichnis
war etwas kritisch, ging aber noch gut aus, auch
wenn es bedeutete, von Legacy Grub auf Syslinux umzusteigen.
Ich reboote das System alle ein bis zwei Monate, um den
Kernel aktuell zu halten. Meist aber laufen die Systeme einfach
durch.
ich höre von einer kritischen Lücke in einer Komponente, die
vom Internet aus erreichbar ist (etwa WordPress).
Ich stelle nur sicher, dass die Downtimes am Freitag oder
am Samstag erfolgen. Falls etwas schief geht, kann es öfter
mal etwas mehr Zeit verschlingen, als das bei einer konventionellen
Distribution der Fall wäre. Als Sicherheitsexperte weiß
ich es zu schätzen, immer auf dem aktuellen Stand zu sein,
genauso wie mehr Kontrolle darüber zu haben, was auf meinem
System läuft. Ich habe die Angriffsfläche durch das Weglassen
von Paketen, die ich niemals brauche, massiv
verkleinert.
Gene: Ich habe bereits mit Red Hat, Fedora und Arch Server
betrieben. Arch ist aus meiner Sicht fraglos die beste Lösung
für ein Server-System. Änderungen sind unvermeidlich, und
bei Arch erreichen mich
„Arch ist aus meiner Sicht
fraglos die beste Lösung für
ein Server-System.“
die Änderungen in kleineren
Portionen, sodass
ich die Gelegenheit
habe, sie eine nach der
anderen abzuarbeiten
(wie etwa die Migration
zu systemd). Jede der Änderungen kann größer oder kleiner
sein, doch bei Arch bekomme ich zumindest die Chance,
mich immer nur auf eine zur selben Zeit konzentrieren zu
müssen. Ohne einen Rolling Release muss ich alle paar Jahre
(oder bei Fedora alle sechs bis neun Monate) eine Neuinstallation
vornehmen, die alle Anpassungen beinhaltet.
Ich teste alle Aktualisierungen zunächst auf einem Schattensystem,
bevor ich sie auf dem Server selbst installiere. Das
ist die einzige vernünftige Vorgehensweise, egal welche Distribution
man benutzt.
Chris Down: Ich benutze Arch Linux nur in kleinen Produktivumgebungen
und hatte nie irgendein Problem im Zusammenhang
mit den Paketen. Die geringe Anzahl der Pakete reduziert
das Fehlerrisiko.
Dinge gehen auf Arch generell nicht einfach so kaputt,
schließlich gibt es ja das Testing-Repository. Wenn etwas kaputt
geht, passiert das normalerweise, weil jemand vor dem
Update nicht auf Konfigurationsänderungen oder andere
wichtige Details geachtet hat. Falls man sich nicht darum
kümmert, was auf der Mailingliste und in den Repositorys
passiert, wird das mit Arch Linux nicht gut ausgehen.
Chester Wisniewski: Ich betreibe zwei produktive Arch-Server.
Ich aktualisiere sie etwa zweimal pro Monat, es sei denn,
65

Projekte
System: Eigene
Beim Raspberry Pi müssen Sie nicht einmal das Ende der Bootsequenz
abwarten, bevor Sie an ihm herumbasteln können. John Lane zeigt Ihnen, wie
Sie sich Ihre ganz persönliche Distribution zusammenstellen.
auf dem Pi, und installieren Sie gegebenenfalls die nötigen
Tools und Pakete:
# pacman -Syu
# pacman -S base-devel python2 git parted dosfstools
In diesem Tutorial zeigen wir Ihnen, wie man ein individuelles
Image für das Raspberry-Pi-Betriebssystem erstellt. Sie
könnten ja den Wunsch verspüren, die Zusammenstellung
der Pakete im Vergleich zu offiziellen Images zu ändern, die
Konfiguration anzupassen und möglicherweise sogar den Kernel
zu bearbeiten. Sie werden nach unserem Kurs in der Lage sein,
das Image auf eine SD-Karte zu schreiben, um damit den Raspberry
Pi zu booten. Sie könnten aber auch einen Emulator verwenden,
um das Image auf Ihrem PC zu booten. Da es zwar
möglich ist, ein maßgeschneidertes Image direkt auf dem Pi zu
erstellen, dies jedoch nur sehr langsam vonstattengehen würde,
erklären wir Ihnen außerdem, wie Sie Ihren PC als Cross-Compiler
verwenden oder auf ihm sogar ARM-Code ausführen können.
Es ist zwar technisch kein Problem, auch an einem laufenden
System Änderungen vorzunehmen, indem man einzelne Pakete
hinzufügt oder entfernt, doch ist dies mit Risiken verbunden,
denn ein einziger Fehler genügt unter Umständen, um einen Absturz
herbeizuführen. Außerdem sind Änderungen am laufenden
System schwieriger zu reproduzieren und vor allem zu automatisieren.
Die Erstellung einer eigenen Distribution ist also aus unserer
Sicht die weit bessere Möglichkeit.
Um ein individuelles Betriebssystem-Image zu erzeugen, benötigen
wir zunächst einmal bestimmte Werkzeuge. In diesem
Tutorial verwenden wir Arch Linux als Ausgangspunkt, denn das
ist eine tolle Distribution, die sowohl für den Raspberry Pi als
auch für den PC erhältlich ist. Wir setzen an dieser Stelle voraus,
dass Sie die neueste offizielle Version von Arch Linux samt
Updates auf Ihrem Pi installiert haben. Booten Sie Arch Linux
Wählen Sie Ihre Garnitur
Der erste Schritt hin zu einem maßgeschneiderten Betriebssystem-Image
ist die Überlegung, welche Dinge es enthalten soll.
Eine gute Möglichkeit, sich der Auswahl anzunähern, ist es, bei
der Standardausstattung von Arch Linux anzusetzen und auf
dieser Basis Pakete zu entfernen oder bei Bedarf hinzuzufügen.
Nicht erwünschte Kernel-Pakete sollten weggelassen und die
speziellen Raspberry-Pi-Pakete ergänzt werden.
Falls Sie individuelle Features einbauen möchten, müssen
Sie einen eigenen Kernel zusammenstellen. Es kann außerdem
sinnvoll sein, für Ihre Zwecke überflüssige Kernel-Funktionalitäten
zu deaktivieren, um Platz zu sparen – besonders im Hinblick
auf die beschränkten Speicherressourcen des Raspberry Pi.
Da es auf die herkömmliche Weise über zehn Stunden dauern
würde, den Kernel auf dem Pi zu kompilieren, ist eine Alternativmöglichkeit
dringend erforderlich. Eine Variante ist die Verwendung
eines Cross-Compilers. Eine andere bietet distcc, allerdings
brauchen Sie auch bei diesem Client-Server-Tool einen
Cross-Compiler, da der distcc-Server ARM-Code erzeugen muss.
Die nachfolgenden Befehle demonstrieren, wie wir mithilfe
von Pacman, dem Paketmanager von Arch Linux, die Paketliste
der Basisgruppe holen, die unerwünschten Pakete löschen und
die Pakete des Raspberry-Pi-Kernels sowie Firmware-Pakete hinzufügen.
Sie können auch einen Texteditor benutzen, um damit
weitere Pakete gemäß Ihren Vorstellungen zuzufügen (etwa
OpenSSH) oder wegzunehmen.
$ pacman -Sg base | awk ‘{print $2}’ | grep -v “^\
(linux\|kernel\)” | tr ‘\n’ ’ ’ > base_packages
$ sed -i -e ‘s/$/linux-raspberrypi linux-headers-raspberrypi
raspberrypi-firmware/’ base_packages
Nachdem Sie die Paketzusammenstellung festgelegt haben,
müssen Sie die Pakete für das neue Image installieren. Mit
mkarchroot geht das ganz leicht: Es installiert Pakete in ein
Unterverzeichnis, welches Sie dann in ein Image umwandeln
können.
# mkarchroot archroot $(cat base_packages)
Dieses Kommando erzeugt ein neues Unterverzeichnis
namens archroot, das alles enthält, was für ein vollständiges
System benötigt wird. Sie könnten es sogar mit chroot zum
Root-Verzeichnis machen, und trotzdem würde alles weiter funktionieren.
In der Tat ist dies der Weg, den Sie gehen würden,
wenn Sie ein Root-Passwort setzen oder Benutzer hinzu fügen
wollten.
Wir erzeugen das System-Image in einer Datei. Sie könnten
es auch direkt auf einer SD-Karte erstellen, doch ist es
66

Projekte
Distribution
Innerhalb des Images arbeiten
Manchmal ist es nützlich, innerhalb
eines Dateisystem-Images wie archroot
arbeiten zu können. Dies geht mithilfe
von chroot, aber es ist ratsam, zuvor
einige Teile des Dateisystems per
Bind-Mount einzuhängen. Sie können
dieses kleine Skript verwenden:
#!/bin/bash
mkdir -p $1/{dev/pts,proc}
mount proc -t proc $1/proc
mount devpts -t devpts $1/dev/pts
chroot $1 /usr/bin/env -i
TERM=“$TERM” /bin/bash --login
umount $1/{dev/pts,proc}
Der Prozessor-Emulator QEMU emuliert einen Raspberry Pi, der
mit unserem Image Marke Eigenbau läuft.
durchaus nützlich, das Image auf der Festplatte zu haben, da
es dann schnell auf eine weitere Karte geschrieben werden
kann oder sogar in einem Emulator zu booten geht, ohne dass
es überhaupt auf irgendeine Karte geschrieben wurde. Der Kernel
hat eine Loop-Funktionalität, mit deren Hilfe eine Datei wie
eine physische Festplatte behandelt und partitioniert werden
kann. Das Modul erzeugt einen normalen Geräteknoten in
/dev, über den die Datei in dieser Weise angesprochen wird.
Das Image muss groß genug sein, um das Dateisystem
aufnehmen zu können, aber auch klein genug, um auf eine
SD-Karte zu passen. Unser Image hat ein Volumen von 2 GiB,
entspricht hinsichtlich seiner Größe also dem offiziellen Image.
Stellen Sie sicher, dass das Loop-Modul des Kernels geladen
wurde, generieren Sie die Datei, und erzeugen Sie ein Loop-
Gerät dafür:
# modprobe loop
$ truncate -s 2G myimage
$ device=$(losetup -f)
# losetup $device myimage
Wir verwenden losetup hier zweifach: erstens, um dem Loop-
Gerät einen Gerätenamen (üblicherweise /dev/loop0) zuzuteilen,
und zweitens, um es zu erzeugen (wir speichern den Gerätenamen
in einer Variablen, um später darauf Bezug nehmen zu
können). Das Image benötigt eine bestimmte Partitionierung:
Die erste Partition muss FAT16 verwenden und die Bootdateien
sowie das Kernel-Image enthalten, während die zweite Partition
– mit ext4 – für das Root-Dateisystem benötigt wird. Falls Sie
eine Austauschpartition wünschen, können Sie zu diesem
Zweck noch eine dritte Partition einrichten. Die Boot-Firmware
des Raspberry Pi hält nach einer MS-DOS-artigen MBR-Partitionstabelle
Ausschau (anders als das BIOS eines PCs führt die
Firmware keinen Bootloader aus dem MBR aus). Erzeugen Sie
mit dem Kommando parted die Partitionstabelle auf der
Image-Datei:
# parted -s $device mktable msdos
Wenn Sie Partitionen erstellen, ist es ratsam, diese mit den
Erase Blocks der zu verwendenden SD-Karte in Übereinstimmung
zu bringen. Bei den meisten Karten haben die Erase
Blocks eine bevorzugte Größe von 4 MiB, doch Sie können das
mit dem folgenden Befehl genau ermitteln:
$ cat /sys/class/block/mmcblk0/device/preferred_erase_size
Bei einer bevorzugten Größe von 4 MiB je Erase Block besteht
alle 8.192 Sektoren eine Übereinstimmung (da die Sektoren
je 512 Byte umfassen), daher sollten die Partitionen bei
einem Sektor beginnen, dessen Nummer ein Vielfaches von
8.192 darstellt: Der erste Erase Block beinhaltet die ersten
8.192 Sektoren (0 bis 8.191), der zweite die nächsten (8.192
bis 16.383) und so weiter. Der Sektor 0 ist der Partitionstabelle
vorbehalten, darum muss die erste Partition mit Sektor 8.192
beginnen.
Eine gute Größe für die Boot-Partition wäre 40 MiB, dies entspricht
81.920 Sektoren. Das ist ausreichend für die Bootdateien
und stimmt überdies mit der Grenze eines Erase Blocks
überein. Lassen Sie die Boot-Partition demzufolge mit Sektor
8.192 beginnen und mit Sektor 90.111 (8.192 + 81.920 - 1)
enden:
# parted -s $device unit s mkpart primary fat32 8192 90111
Reservieren Sie gegebenenfalls ein bisschen Platz für eine
Austauschpartition (die SD-Karte dafür zu verwenden, wäre
aus Geschwindigkeitsgründen nicht ratsam). Als ein Beispiel
erzeugen wir eine Austauschpartition von 256 MiB (also
524.288 Sektoren oder 64 Schreibblöcke).
Unser 2-GiB-Image besteht aus 4.194.304 Sektoren, das
heißt, der letzte Sektor trägt – da die Zählung bei 0 beginnt –
die Nummer 4.194.303. Die Root-Partition kann den gesamten
Speicherplatz zwischen der Boot-Partition und der Austauschpartition
belegen und würde somit mit Sektor 90.112 beginnen
und vor dem ersten Sektor der 256 MiB großen Austauschpartition
enden. Heraus kommen also die folgenden Kommandos
zur Partitionierung:
# parted $device unit s mkpart primary ext2 90112 3670015
Quick-
Tipp
Falls Sie ein 32-Bit-
System verwenden,
können Sie auf einen
vorgefertigten Cross-
Compiler bei den
Raspberry-Pi-Tools
zurückgreifen. Dieser
heißt arm-bcm2708-
linux-gnueabi und
ist unter https://
github.com/
raspberrypi/tools
zu finden.
Quick-
Tipp
Holen Sie mehr
aus Ihrem Mehrkernprozessor
heraus: Beim Befehl
make sorgt der
Parameter -j dafür,
dass gleichzeitig
mehrere Prozesse
gestartet werden.
Geben Sie im Falle
des Core i7 mit
seinen vier Kernen
(acht Threads) den
Wert 8 ein.
67

Projekte
Quick-
Tipp
Falls Sie Yaourt
noch nicht haben,
finden Sie den
Quellcode im Arch
User Repository
(AUR). Sie
können sich das
Selberbauen jedoch
ersparen, wenn
Sie das Paket aus
einem inoffiziellen
Repository
verwenden: http://
archlinux.fr/
yaourt-en
Quick-
Tipp
Die Raspberry-Pi-
Utilities unseres
Autors John Lane
finden Sie unter
https://github.
com/johnlane/
rpi-utils.
# parted $device unit s mkpart primary linux-swap 3670016
4194303
Wenn Sie möchten, können Sie sich die Partitionstabelle mittels
des Befehls parted -s $device unit s print ausdrucken. Als
Nächstes generieren Sie die Dateisysteme. Das Loop-Gerät
muss erneut erstellt werden, damit Geräteknoten für die Partitionen
erzeugt werden (mithilfe der Option -P).
# losetup -d $device
# device=$(losetup -f)
# losetup -P $device myimage
Stimmen Sie die interne Struktur der Dateisysteme auf die
Sektoren ab. Zur Abstimmung eines FAT-Dateisystems müssen
Sie die Größe seiner Dateizuordnungstabelle (FAT) kennen. Sie
müssen ein Dateisystem erstellen, um diese zu ermitteln:
mkfs.vfat -I -F 16 -n boot -s 16 -v ${device}p1 | grep “FAT size”
Um eine Übereinstimmung zu erzielen, erweitern Sie den reservierten
Teil in der Weise, dass der Datenbereich an einer
Blockgrenze beginnt. Die Größe des reservierten Bereichs sollte
der Größe der Schreibblöcke abzüglich der beiden Dateizuordnungstabellen
(FAT) entsprechen. Wenn wir unser Beispiel mit
einer FAT-Größe von 32 Sektoren weiterführen, errechnet sich
daraus ein reservierter Bereich von
8.192 - 2 x 32 = 8.128 Sektoren. Erstellen Sie das Dateisystem
erneut auf Grundlage dieser Information:
mkfs.vfat -I -F 16 -n boot -s 16 -R 8128 -v ${device}p1
Für die Root-Partition verwenden Sie bitte ein ext4-Dateisystem.
Da bei ext4 die Erase Blocks lediglich 4 KiB groß sind,
brauchen Sie diesmal keine Sektorenangaben zu machen:
$ mkfs.ext4 -O ^has_journal -L root ${device}p2
Mounten Sie die Dateisysteme und kopieren Sie die Dateien
vom archroot-Unterverzeichnis an die richtige Stelle. Die Boot-
Partition ist bei /boot auf der Root-Partition eingehängt, sodass
Bootsequenz des Raspberry Pi
Der Raspberry Pi bootet anders als ein
PC. Beim Pi wird der Prozess nicht vom
ARM-Chip, sondern vom Grafikchip aus
gestartet. Nach dem Einschalten initiiert
die GPU den ersten Bootloader (ROM-Firmware),
der dann weitere Stufen von der
ersten (FAT16-formatierten) Partition der
SD-Karte nachlädt. Der zweite Bootloader
namens bootcode.ini wird im L2-Cache
der GPU ausgeführt. Er lädt loader.bin,
den Bootloader der dritten Stufe, ins RAM,
dessen Aufgabe es ist, die GPU-Firmware
Hier wird aus einem x86 plötzlich ein ARM!
start.elf auszulesen. Die weiteren Dateien
config.txt und cmdline.txt ermöglichen
die Konfigurierung des Bootprozesses.
Schließlich lädt start.elf das Kernel-Image
von Linux namens kernel.img in den RAM-
Speicher des ARM-Prozessors, der damit
aktiviert ist. Das Image wird ausgeführt
und der Linux-Bootprozess beginnt.
Der klassische Master Boot Record (MBR)
– Sektor 0 – der SD-Karte enthält lediglich
die Partitionstabelle, und es wird – anders
als beim PC – kein MBR-Code ausgeführt.
die Bootdateien in der korrekten Partition platziert werden:
# mount ${device}p2 /mnt
# mkdir /mnt/boot
# mount ${device}p1 /mnt/boot
# (cd archroot ; cp -a * /mnt)
# umount /mnt/boot /mnt
Schreiben Sie nun das Image auf die SD-Karte. Falls Ihr
Rasp berry Pi das Root-Dateisystem auf der Karte hat, müssen
Sie das Image auf einen anderen Rechner mit einem Kartenlesegerät
kopieren:
# dd if=myimage of=/dev/mmcblk0 bs=4M
Fahren Sie den Raspberry Pi herunter, stecken Sie die neue
Karte ein, und booten Sie wieder. Alternativ können Sie das
Image auch auf Ihren PC kopieren und es dort in einem Emulator
laufen lassen.
Das linux-raspberry-Paket, das wir in unserem Image Marke
Eigenbau verwendet haben, enthält das offizielle Kernel-Image,
doch es lässt sich relativ einfach anpassen. Sie benötigen dazu
den Quellcode des Kernels sowie einen Compiler, um ein neues
ausführbares Kernel-Image zu erzeugen.
Ein Compiler generiert normalerweise ausführbaren Code für
die CPU derselben Maschine, doch mithilfe eines Cross-Compilers
ist es möglich, auch für den Prozessor eines anderen Geräts
lauffähige Programme herzustellen. Der Cross-Compiler erlaubt
es, die leistungsstärkere x86-Hardware zum Kompilieren
des Codes für den ARM-Chip des Raspberry Pi zu benutzen,
was deutlich schneller geht, als wenn man dies direkt auf dem
Pi tun würde.
Der normale Compiler trägt den Namen gcc, während der
Cross-Compiler für ARM-Hardware arm-linux-gnueabi-gcc heißt.
Letzterer befindet sich nicht in den Repositorys, aber man kann
ihn mithilfe von yaourt leicht zusammenstellen:
yaourt -S arm-linux-gnueabi-gcc
Bei yaourt müssen Sie mehrere Eingabeaufforderungen beantworten.
Wählen Sie „no“ bei der Frage, ob Sie das
PKGBUILD editieren möchten, und „yes“, wenn das Tool wissen
möchte, ob Sie ein Paket bauen oder installieren möchten.
Hello world!
Bevor wir weitermachen, sollten wir kurz den Cross-Compiler
checken. Legen Sie eine neue Datei namens hello.c an:
#include
int main ()
{
printf(“Hello world!\n”);
return 0;
}
Nun kompilieren Sie die Datei für die ARM-Architektur, und
überprüfen Sie den Typus:
$ arm-linux-gnueabi-gcc -o hello hello.c
$ file hello
hello: ELF 32-bit LSB executable, ARM, version 1 (SYSV),
dynamically linked (uses shared libs), for GNU/Linux 2.6.27,
not stripped
Wenn Sie die Datei auf Ihren Raspberry Pi verschieben, sollte
sie sich ausführen lassen:
$ ./hello
Hello world!
Wird diese Ausgabe angezeigt, dann wissen Sie, dass der
Cross-Compiler funktioniert. Wenden wir uns also wieder dem
Kernel zu:
$ git clone --depth 1 git://github.com/raspberrypi/linux.git
68

Projekte
$ cd linux
$ ssh root@alarmpi zcat /proc/config.gz > .config
$ make -j 8 ARCH=arm CROSS_COMPILE=
arm-linux-gnueabi- menuconfig -k
Wir laden den Quellcode des Kernels von github herunter,
wobei - -depth dafür sorgt, dass nur die neueste Version und
keine vorherigen Varianten geholt werden. Danach kopieren Sie
die aktuelle Kernel-Konfiguration des Raspberry Pi in eine Datei
namens .config, öffnen diese im Kernel-Editor menuconfig, nehmen
die gewünschten Änderungen vor und speichern die Datei.
Sie sind nun in der Lage, den Kernel und dessen Module zu
bauen:
$ make -j 8 ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- -k
$ mkdir -p modules
$ make -j 8 -k ARCH=arm CROSS_COMPILE=
arm-linux-gnueabi-modules_install INSTALL_MOD_
PATH=modules
Wir haben außerdem ein neues Unterverzeichnis dafür angelegt.
Nachdem das neue Image des Kernels und der Module
erstellt worden ist, können Sie es auf den Pi überspielen und
diesen dann neu booten (zuvor sollten Sie aber ein Backup des
alten Kernels und der Module machen):
$ scp arch/arm/boot/Image root@alarmpi:/boot/kernel.img
$ cd modules/lib/modules
$ tar cJf - * | ssh root@alarmpi ‘(cd /usr/lib/modules; tar xjf -)’
$ ssh root@alarmpi reboot
Alternativ können Sie alles auch in Ihrem archroot-Verzeichnis
installieren, bevor Sie das Image erstellen. Kopieren Sie
arch/arm/boot/Image nach archroot/boot/kernel.img sowie
modules/lib/modules nach archroot/usr/lib.
Emulator und Cross-Compiler
Es ist ebenfalls möglich, das Image in einem ARM-Emulator
laufen zu lassen und dadurch einen virtuellen Raspberry Pi auf
Ihrem x86-PC zu betreiben. QEMU ist ein Prozessor-Emulator,
der ARM-Code auf einem PC mit x86-Architektur interpretieren
kann. Sie installieren QEMU mit pacman -S qemu. Erstellen Sie
ein Verzeichnis und kopieren Sie das Image dorthin. Sie benötigen
überdies ein Kernel-Image speziell für den Emulator: Verwenden
Sie kernel-qemu – welches Sie in den Archiven finden
–, und speichern Sie es am selben Ort wie Ihr Image. Nun können
Sie den Emulator mit folgendem Kommando ausführen:
qemu-system-arm -machine versatilepb -cpu arm1176 -m 256 \
-no-reboot -serial stdio -kernel kernel-qemu \
-append “root=/dev/sda2 panic=1” -hda myimage
Mithilfe des Emulators kann man sogar ARM-Code direkt aus
der Befehlszeile eines x86-Rechners ausführen. Hierbei macht
das Programm sich ein Kernel-Feature namens binfmt_misc
zunutze. Dazu sind jedoch Vorbereitungen nötig:
# mount binfmt_misc -t binfmt_misc /proc/sys/fs/binfmt_misc
Das ARM-Binärformat muss dem Kernel angegeben werden,
damit dieser weiß, was er zu tun hat. Die Erkennung basiert auf
Musterübereinstimmung am Anfang der Datei. Geben Sie ein:
echo ‘:arm:M::\x7fELF\x01\x01\x01\x00\x00\x00\x00\
x00\x00\x00\x00\x00\x02\x00\x28\x00:\xff\xff\xff\xff\
xff\xff\xff\x00\xff\xff\xff\xff\xff\xff\xff\xff\xfe\xff\xff\
xff:/usr/bin/qemuarm-static:’ > /proc/sys/fs/binfmt_misc/
register
Im Folgenden wird jeder Versuch, ARM-Binärcode auszuführen,
stattdessen zur Ausführung von /usr/bin/qemu-arm-static
führen, wobei der Pfad des Codes in Form eines Parameters
weitergeleitet wird.
Image auf dem PC erstellen
Mithilfe eines Emulators können Sie das
archroot-Unterverzeichnis auch auf Ihrem
PC anlegen statt auf dem Raspberry Pi.
Dazu müssen Sie den Paketmanager so
konfigurieren, dass er ARM-Pakete herunterlädt
und das mkarchroot-Skript so
einstellen, dass es qemu-arm-static im
archroot-Verzeichnis installiert, während
dieses erzeugt wird. Nachdem Sie diese
letzten Puzzleteile eingefügt haben,
sind Sie in der Lage, auf Ihrem PC ein
vollständiges Image für Ihren Raspberry
Pi samt maßgeschneidertem Kernel
und zusätzlichen Paketen aufzubauen.
So weit, so gut. Was allerdings schwierig ist, ist die
Erstellung von Paketen, da hierbei Abhängigkeiten (dependencies)
ins Spiel kommen und auf einem x86-Computer keine
ARM-Abhängigkeiten installiert werden können. Sie können
das Problem jedoch halbwegs umgehen, indem Sie das anfangs
erwähnte Tool distcc einsetzen. Damit können Sie die
Paketerstellung auf Ihrem Pi erledigen, jedoch die Kompilierungsarbeit
per Cross-Compiling an Ihren PC auslagern.
Um distcc verwenden zu können, müssen Sie es sowohl auf
dem Raspberry Pi als auch auf dem PC installieren, in beiden
Fällen mit dem Befehl pacman -S distcc. Der Pi fungiert als Client
und kontrolliert die Erstellung der Pakete mittels makepkg,
das Sie noch für die Benutzung von distcc konfigurieren müssen,
und zwar durch Angabe der Details Ihres distcc-Servers.
Ändern Sie hierzu /etc/makepkg.conf wie folgt:
BUILDENV=(fakeroot distcc color !ccache)
DISTCC_HOSTS=“10.0.200.12”
MAKEFLAGS=“-j8”
Als Server fungiert Ihr PC, er kompiliert den Code. In der Konfigurationsdatei
/etc/conf.d/distccd muss angegeben werden,
welche Hosts sich verbinden dürfen. Dabei sollte der Server als
Daemon gestartet werden:
/etc/rc.d/distccd start
Sind Client und Server konfiguriert, kann makepkg auf dem Pi
und das Kompilieren auf dem PC ausgeführt werden. Allerdings
muss noch der korrekte Compiler in der Datei distccd eingetragen
werden: Standardmäßig ist dort gcc eingestellt, wir benutzen
jedoch stattdessen den Compiler arm-linux-gnueabi-gcc.
Modifizieren Sie daher den Pfad wie folgt:
# ln -s /usr/bin/arm-linux-gnueabi/gcc /use/bin/
arm-linux-gnueabi-gcc
# sed -i -e ‘/^PID=/iPATH=/usr/bin/arm-linux-gnueabi:\
$PATH’ /etc/rc.d/distcc
Root-Partition verschieben
Falls Sie Ihr Root-Dateisystem nicht auf der SD-Karte haben
möchten, sondern beispielsweise auf einer USB-Festplatte, können
Sie die Root-Partition auch dorthin verschieben. Dies geht
ganz einfach, indem Sie das bestehende Root-Dateisystem von
der SD-Karte in eine Partition der USB-Festplatte kopieren.
Eventuell müssen Sie die Größe anpassen.
# dd if=/dev/mmcblk0p2 of=/dev/sda1 bs=4M
# fsck /dev/sda1
# resize2fs /dev/sda1
Ändern Sie dann in der Datei /boot/cmdline.txt die Position
der Root-Partition im Bootkommando, indem Sie root=/dev/
mmcblk0p2 durch root=/dev/sda1 ersetzen. Nach einem Neustart
befindet sich die Root-Partition auf der Festplatte. Die benötigten
USB-Treiber sind normalerweise bereits im Kernel
vorhanden.
Quick-
Tipp
Sollte beim Bau
des Kernels der
Arbeitsschritt
modules_install
zu der Fehlermeldung
No rule to make
target ‘modules/
lib/firmware/./’
führen, wiederholen
Sie den Schritt
einfach – dann sollte
es klappen.
69

Projekte
XBMC enthüllt
„XBMC hat sich zu einer fantastischen Lösung für Ihre
Medienbibliothek gemausert.“
Aus einem Linux-Rechner ein Media-
Center zu machen war schon immer
beliebt. Möglicherweise liegt es daran,
dass Sie so viele Linux-Versionen
einrichten können wie Sie wollen, ohne einen
Cent zu zahlen, oder es liegt an der System-
Stabilität, die garantiert, dass Sie
stets Ihre Lieblingsserien aufnehmen
können.
Die Einrichtung eines Media-
Centers war stets mit viel Arbeit verbunden,
denn für lange Zeit galt
MythTV als einzig sinnvolle Lösung
für ein Media-Center mit
TV-Anbindung. MythTV ist eine monumentale
Suite von Clients und Servern, die alles kann:
vom Steuern Ihrer Vorhänge bis hin zu komplexen
Suchfunktionen für Ihre Lieblingsaufnahmen.
MythTV ist wundervoll, aber
schwierig aufzusetzen. Sie brauchen ein Back-
End für die Aufnahmen und ein Front-End, um
Ihre Inhalte ansehen zu können – beides ist
nicht leicht einzurichten. Im Januar 2013 wurde
Version 12 einer der besten MythTV-
„XBMC hat sich zu einer
fantastischen Lösung für Ihre
Medienbibliothek gemausert.“
Alternativen veröffentlicht: XBMC. XBMC wurde
schnell zu einem idealen Ersatz für jene, die
sich an der Installation von MythTV schwertaten.
XBMC hat sich mittlerweile zu einer fantastischen
Lösung für Ihre Medienbibliothek
gemausert. Deswegen haben wir XBMC in
unserem Test die höchsten Empfehlungen ausgesprochen.
XBMC ist das Pendant zum Front-End von
MythTV, mit der Ausnahme, dass es die gleichen
Aufgaben mit einer angenehmeren
und geradlinigeren Oberfläche
verbindet. Eine OpenGL-
Beschleunigung sorgt für eine
flüssigere Darstellung sowohl des
Menüs als auch der Inhalte auf
HD-Fernsehern. Das Interface ist
zudem für Einsteiger deutlich
zugänglicher und einfacher zu bedienen.
Deswegen haben wir uns entschieden, uns auf
den folgenden Seiten XBMC etwas genauer zu
widmen.
70

Projekte
Was ist XBMC?
Es dauerte über zehn Jahre bis zum Status quo, aber es begann sehr aufregend.
Das X in XBMC stand einst für Xbox – ja,
genau wie die Microsoft-Konsole. Frühe
Versionen von XBMC machten die erste
Xbox zu einem Media Player, der direkt mit
dem AV-Receiver und dem Fernseher verbunden
war. Die beiden Entwickler mit den Namen
„d7o3g4q“ und „RUNTiME“ gründeten das
Projekt 2002. Beide arbeiteten an ihren eigenen
geschlossenen Komponenten, bevor sie
sich mit Frodo zusammenschlossen, dem
Gründer von YAMP – Yet Another Media
Player. Das neue Projekt bekam den Namen
Xbox Media Player 2.0, welches Ende 2002
veröffentlicht wurde. Ein Jahr später war das
Xbox Media Center geboren, mit einer
Namensänderung, die den Fokus des neuen
Projekts besser betonte und die bis heute
Bestand hat. Das erste stabile Release von
XBMC erschien im Juni 2004, zwei Jahre später
folgte Version 2.0. 2007 schließlich löste
sich das Projekt von der Xbox, Entwickler wurden
gesucht, um das Programm auf Linux
umzuziehen und um von Microsofts DirectX-
Plattform auf SDL und OpenGL zu wechseln.
Installation
Nach zehn Jahren ist XBMC bei Version 12 –
Codename Frodo. Es entwickelte sich zu einer
der ausgereiftesten Multiplattform-Media-
Center, mit mehr Potenzial als nur einem
Ersatz für fast alle bestehenden Media-Front-
End-Lösungen. Die neue Version unterstützt
Android und Raspberry Pi inklusive HD-Audiound
HD-Video-Playback sowie umfassende
Digital-Video-Recorder-Funktionen. XBMC läuft
auf fast allen Plattformen und lässt sich sowohl
als Front-End-Client für das Wohzimmer als
auch als Back-End-Server für die Medienbibliothek
nutzen. Es ist ein großartiger Ersatz
für das brillante MythTV und bringt sogar eine
bessere Oberfläche und eine niedrigere Lernkurve
mit, auch wenn es nicht so individualisierbar
oder leistungsstark wie MythTV ist.
Sie können XBMC auf allen beliebten Linux-
Distributionen via Package-Manager installieren.
Soll XBMC auf einem Raspberry Pi laufen, benutzen
Sie die OpenELEC-Distribution. Dazu brauchen
Sie entweder
Arch oder – unsere
Empfehlung – ein jüngeres
Release, falls
Sie XBMC 12 nutzen
wollen. Haben Sie
noch einen Windowsoder
OS-X-Rechner,
nutzen Sie entsprechende
Binaries, die
den gesamten
Desktop einnehmen.
So genießen Sie das
Gefühl, weiterhin mit
einem Linux-System
zu arbeiten.
XBMC ist eine der
besten Möglichkeiten, um überschüssige
Rechner wieder zum Leben zu erwecken. Mit
einem Klick auf „Quit“ haben Sie das verwendete
System wieder auf Originalzustand gesetzt. Es
gibt auch Extra-Pakete, um die Videobeschleunigung
mit Nvidia- oder Grafikkarten zu verbessern.
Die „vdpau“- für Nvidia-Hardware und die
„xvba“-Bibliothek für AMD hilft Ihrem System,
hochauflösende Video-Streams zu decodieren.
Wenn Sie den Media Player mit einem Recorder
wie dem auf dem Raspberry Pi one basierenden
TVheadend kombinieren möchten, dann brauchen
Sie das „xbmc-pvr-addons“-Package. Viele
Distributionen haben dieses Package auch standardmäßig
integriert.
Drive: Das Thema von 23 Prozent aller Diskussionen auf LXFTowers.
Schritt für Schritt: XBMC einrichten
1 Installation
Nutzen Sie unbedingt XBMC 12 und nicht das
Release in Ihrer Linux-Distribution. Für
Ubuntu-Nutzer empfehlen wir als Ergänzung
das offizielle PPA (https://launchpad.
net/~team-xbmc/+archive/ppa). Spezielle
XBMC-Distros wie etwa XBMCbuntu sind eine
gute Option, wenn Sie in eine Live-Client-
Oberfläche booten möchten.
2 XMBC starten
XBMC startet im Vollbild. Dies können Sie
lediglich in den Einstellungen des Programms
ändern: „System > Video Output > Display
Mode“. Zudem brauchen Sie OpenGL, damit
das funktioniert. Intel-, AMD- und Nvidia-
Hardware funktioniert von Haus aus, für die
beste Performance schauen Sie nach
proprietären Treibern.
3 Inhalte hinzufügen
Für alle Hauptmenü-Optionen wie Bilder,
Videos oder Musik lassen sich einzeln Quellen
festlegen, Das kann auf einem lokalen
Datenträger oder im Netzwerk (UPNP, NFS
und Samba) sein. Der integrierte Datei-
Explorer macht das Auffinden Ihrer Medien
spielend einfach.
71

Projekte
XBMC: Die besten Features
Sechs Gründe, warum XBMC das beste Media-Center ist.
1 Foto-Management
Es gibt viele Werkzeuge, um Ihre Fotosammlung
zu organisieren. Dank der Unterstützung verschiedener
Quellen, Listen, Thumbnails und
Ansichten haben wir das Gefühl, das XBMC die
Balance richtig hinbekommt. Unglücklicherweise
kann XBMC nichts an der Bildqualität ändern, wie
der obige Screenshot schmerzhaft demonstriert.
Daher empfehlen wir Ihnen, einen Mentor oder
einen Kurs aufzusuchen, um sich in die Kunst der
Bildbearbeitung einführen zu lassen.
2 Inhalte optimieren
Wenn Sie eine Video-Quelle hinzugefügt
haben, dann können Sie die Filmdatenbank
nach Bildern und weiterführenden
Informationen durchsuchen. Cover für Ihre
Inhalte machen die Suche in Ihrer Bibliothek
deutlich einfacher und intuitiver. Wenn Dateien
auf einer externen Quelle liegen, dann ist es
den Aufwand wert. Lassen Sie den Prozess zur
Not über Nacht laufen.
3 Erweiterungen
Mit Erweiterungen, die sich unter „Get
More“ für Bilder, Videos und Musik finden
lassen, haben Sie zusätzliche Quellen für
Ihre Medienbibliothek. Es gibt viele Online-
Streaming-Dienste, wie beispielsweise den
Nachrichtensender Al Jazeera unter Video-Addons.
Dazu kommt unter anderem auch eine
iTunes Podcast Bibliothek unter Musik. Das ist
nun übrigens ein guter Moment, den TuxRadar
Podcast zu erwähnen. Das ist der beste, ehrlich!
4 PVR Video-Recorder
Wenn Sie TVheadend installiert haben, dann
können Sie das PVR-Plugin unter „Settings >
Add-ons > Disabled Add-ons > PVR clients“
aktivieren. Anschließend (und ggf. nach
Änderung der IP-Adresse) sehen Sie die „Live
TV“-Option im Menü. Dort können Sie TV
schauen und Aufnahmen timen und den EPG
durchsuchen. Sie können unseren Erfahrungen
nach live über das Netzwerk streamen und
gleichzeitig einige HD-Sender schauen. Um über
das Netzwerk zu streamen, leiten Sie den Port
9982 des Tvheadend Server durch Ihre Firewall
an den XMBC. Beachten Sie, dass der Upload
ausreichend Bandbreite bieten muss.
5 Programme
XBMC bietet eine fantastische Architektur für
Erweiterungen. Über das Programme-Menü
können Sie sehr viele Funktionen hinzufügen.
Es gibt einen Gmail-Checker, Emulatoren und
sogar ein Filmquiz. Sie können auch eigene
Programme entwickeln. Der Text am unteren
Bildschirmrand hält Sie dabei über den Status
verschiedener Plugins auf dem Laufenden.
Aktualisierungen können Sie auch über das
Menü des jeweiligen Programms herunterladen.
Im Sidebar-Menü können Sie automatische
Updates ein- bzw. ausschalten. .
6 Interface-Skins
Der XBMC-Skin heißt Confluence, Dieser bringt
einen modernen Look, den Sie mit weiteren
Skins nach Belieben ändern können. Unter
„Settings > Appearance > Skin“ finden Sie unter
„Get More“ weitere Skins. Unser Favorit ist der
„Aeon“-Skin, der mit heruntergeladenen Movie-
Covern sehr professionell aussieht. Der „Back
Row“-Skin erinnert an Geräte eines Herstellers
mit dem Logo einer angebissenen Frucht. Der
„Rapier“-Skin bringt Minimalismus mit einer
Oberfläche, die nicht von zu vielen Bildern
dominiert wird. Und falls Ihnen der Rest nicht
zusagt, gibt es genügend Möglichkeiten, Skins
zu modifizieren.
Tastatur-Shortcuts
Die Bedienung von XBMC kann kryptisch sein, hier ist eine Liste
mit Shortcuts für die wichtigsten Funktionen.
[E] EPG anzeigen
[B] Aufnahmen timen
[H] TV-Kanäle anzeigen
[F] Vorspulen
[R] Zurückspulen
[P] Play
[Leertaste] Play/Pause
[X] Stop
[M] On-Screen-Steuerung
[S] Herunterfahren-Menü
[Links] Vorherigen Titel 30 Sekunden zurückspulen
[Rechts] Nächsten Titel 30 Sekunden vorspulen
[Hoch] Nächster Kanal, zehn Minuten
vorspulen, nächstes Kapitel
[Runter] Vorheriger Kanal, zehn Minuten
zurückspulen, vorheriges Kapitel
[Esc] Vollbild deaktivieren
[.] (Punkt) Nächster Titel
[,] (Komma) Titel überspringen
[+] or [=] Lautstärke hoch
[-] Lautstärke runter
[Ctrl]+[End] XBMC beenden
72

Projekte
XBMC Hardware
Von Raspberry Pi bis Apple TV, XBMC läuft überall.
Die Multiplattform-Tauglichkeit ist eine
der besten Features von XBMC. Es gibt
nicht nur Versionen für Windows, OS X
und Linux, sondern mit Version 12.0 auch eine
Version für Android. Dazu kommen Versionen
für die ersten beiden Generationen von Apple
TV und für iOS-Geräte mit Jailbreak. Der
Android-Port mag noch am Beginn seiner
Entwicklung stehen, doch es handelt sich um
einen vollständigen Port mit allen Features der
Desktop-Version. Da dies eine erste Version ist,
ist der Hardware-Decoding-Support noch
beschränkt. Das heißt, dass die meisten Geräte
Software-Decoding nutzen müssen. Doch es ist
nur eine Frage der Zeit, bis die Entwickler die
Möglichkeiten der Hardware in Smartphones
und Tablets mit Android effizient ausnutzen
können. Bereits jetzt können Android-Geräte
wie etwa der Media-Player MiniX Neo X5
Berichten zufolge 1080p-Inhalte mit HD-Sound
problemlos wiedergeben. Android-Geräte sind
also schon eine gute Plattform für XBMC, auch
wenn die Software noch nicht ausgereift ist. Die
Systemanforderungen umfassen Tegra-3-
Unterstützung und Android 4.0 – womöglich
funktionieren auch die Vorgänger. Sowohl das
Nexus 7 als auch das Nexus 10 sollen mit
XBMC funktionieren, genau wie die US-Version
des Samsung Galaxy S III.
Umso näher Ihre Hardware an die
Hauptplattform der „XBMC für Android“-
Entwickler kommt, desto besser wird XBMC
funktionieren. Das offizielle Haupt-Gerät ist der
Pivos XIOS DS von AMLogic. Er besitzt einen
ARM Cortex A9 Prozessor, eine Mali 400 3D
GPU und einen HDMI-Ausgang. Dazu kommt
Die Entwickler von XBMC für Android arbeiten hauptsächlich mit dem Media Player Pivos
XIOS DS. Deshalb sollten alle neuen Features dort zuerst rauskommen.
eine Fernbedienung. Das System könnte zwar
keinen Low-End-PC ersetzen, stellt jedoch eine
gute Lösung dar, um ihr Setup zu erweitern.
Das Gerät ist winzig, es ist gerade einmal 15
Millimeter hoch. Sie könnten den Media Player
ganz einfach an die Rückseite eines durchschnittlich
dimensionierten Fernsehers montieren,
ihn via WLAN mit dem Internet verbinden
und ihn Inhalte auf Abruf liefern lassen.
Raspberry Pi
Eine andere großartige, neue Plattform für XBMC
ist der Raspberry Pi. In Sachen Specs siedelt der
Pi niedriger an als viele Android-Geräte. Doch die
Entwickler tun alles, damit eine bestmögliche
Performance möglich ist – bei einem unschlagbaren
Preis. HD-Videos laufen fehlerfrei über den
eingebauten HDMI-Ausgang. OpenELEC (Open
Embedded Linux Entertainment Center) ist dabei
die beste Möglichkeit, XBMC auf Ihr Raspberry Pi
zu bekommen. Die aktuelle Version ist der
Release Candidate 3 der Version 3.0. Der
Download kommt als „tar.bz2“-Datei. Entpacken
Sie das Paket mit einem Doppelklick auf dem
Desktop. Alternativ tippen Sie „tar xvf OpenELEC-
RPi.arm.tar.bz2“ in die Kommandozeile.
Schließen Sie einen Kartenleser mit eingelegter
SD-Karte an Ihre Linux-Maschine. Via „dmesg“
finden Sie den richtigen Pfad zum Gerät, in der
Regel sieht er etwa so aus: „/dev/sdc“. Doch Sie
müssen sich sicher sein. Wenn Sie einen Fehler
machen, dann könnten Sie wichtige Daten verlieren.
Wenn Sie den Namen des Gerätes herausgefunden
haben, dann tippen Sie im Ordner, den Sie
zuvor entpackt haben „sudo ./create_sdcard/
dev/sdX“ ein, passen Sie den Pfad an Ihr eigenes
Gerät an. Anschließend haben Sie ein funktionsfähiges
XBMC, in das Ihr Raspberry Pi direkt bootet.
Fernbedienung
Eine Fernbedienung ist essenziell,
wenn Sie ein XBMC-Gerät mit dem
Fernseher verbinden. Unter Linux
gibt es so viele unterschiedliche
Lösungen wie Distributionen. Sie
können beispielsweise Infrarot-
Empfänger und -Sender konfigurieren
oder Geräte kaufen, die nach
einer Programmierung Tastaturbefehle
senden. Am einfachsten ist
es jedoch, ein Smartphone zu verwenden.
Es gibt offizielle Apps für
Apple und Android, die Sie kostenlos
herunterladen können. Die Apps
senden Befehle via Netzwerk, Sie
müssen sich keine Sorgen um eine
ausreichend starke Infrarot-Verbindung
oder eine freie Sicht zwischen
Sender und Empfänger machen.
Damit die Android-Fernbedienung
funktioniert, müssen Sie in den
Einstellungen von XBMC „Allow
control of XBMC via HTTP“ unter
„Settings > Services > Webserver“
aktivieren. Dies startet einen
Webserver auf der XBMC-Plattform,
auf die Sie via entsprechender
IP-Adresse und Port 8080 mit
Ihrem Smartphone Zugriff haben.
Ist die App auf dem Android-
Gerät installiert, müssen Sie den
„Add Host“-Button drücken. Dort
können Sie den XBMC-Server konfigurieren.
Es sieht einschüchternd
aus, ist aber sehr einfach. Geben Sie
einfach eine Beschreibung und die
IP-Adresse des XBMC-Rechners
ein. Sie finden die IP-Adresse entweder
über das Netzwerk-Applet des
Rechners heraus oder via „ifconfig“-Befehl
in der Kommandozeile.
Stellen Sie sicher, dass die Ports
8080 und 9090 eingestellt und freigegeben
sind. Speichern Sie. Nun
sollten Sie in der Lage sein, Ihr
XBMC fernsteuern zu können.
Unserer Meinung nach ist die
„Remote Control“-Option aus dem
Hauptmenü die nützlichste Option.
Diese Funktion wandelt ihr Smartphone
in eine physikalische Fernbedienung,
während die anderen
Optionen genutzt werden können,
um Ihre Medien zu organisieren.
Nutzen Sie ein Apple- oder
Android-Smartphone
und machen Sie sich
nie mehr Sorgen um die
Infrarot-Verbindung.
73

Projekte
Auto-Backups per
Sind Sie es leid, ständig manuell Ihre Daten zu sichern? Wir zeigen Ihnen, wie
Sie schnell und einfach Bash-Skripte für automatische Backups schreiben.
Die Möglichkeit
zur einfachen
Kombination
leistungsfähiger
GNU-Tools
macht das
Schreiben
von Skripten
mit Bash zum
Vergnügen.
In der Theorie weiß jeder, wie wichtig es ist, regelmäßig die
Daten auf seinem Computer zu sichern. Doch in der Praxis
bleibt es oft beim guten Vorsatz, denn das Anfertigen von
Backups ist langweilig und lästig, und so wendet man sich im
Zweifelsfall lieber interessanteren Dingen zu. Es gibt eine
Fülle von Routineaufgaben, denen sich ein Systemadministrator
widmen muss: alte Backups löschen, den Zustand der
Server überprüfen, neue Server installieren und konfigurieren
und vieles mehr.
Linux gibt Ihnen jedoch ein Werkzeug an die Hand, mit
dem Sie sich viele dieser langweiligen und repetitiven Aufgaben
vom Hals schaffen können – die leistungsfähige Shellund
Skriptsprache Bash. In diesem Artikel stellen wir Ihnen
Bash vor und legen den Fokus dabei auf Skriptfunktionen,
mit denen Sie fast jede Aufgabe automatisieren können.
Was ist Bash?
Bash steht für Bourne Again Shell und ist 1989 als Ersatz für
Bourne Shell entstanden. Eine Shell ist ein Befehlsinterpreter,
der Ihnen die direkte Kommunikation mit dem Computer ermöglicht.
Die Shell übersetzt Ihre Befehle in eine für den
Computer verständliche Sprache und sorgt für deren Ausführung
durch das Betriebssystem. Jede Information, die als
Folge dieses Prozesses entsteht, wird wiederum zurückinterpretiert
und in der Shell in einer für Sie verständlichen Form
dargestellt. In diesem Artikel verwenden wir Bash und Shell
synonym.
Wenn Sie die Shell bisher nicht verwendet haben, ist dies
nun die Gelegenheit. Auf modernen Linux-Systemen werden
Shells für gewöhnlich über eine Desktop-Anwendung gestartet.
Suchen Sie unter Fedora und Ubuntu nach der Anwendung
„Terminal“ und starten Sie sie.
Die Grundlagen von Bash
Nach Programmstart erscheint ein Fenster mit einer Eingabeaufforderung
in der oberen linken Ecke des Bildschirms.
Immer wenn Sie einen blinkenden Cursor sehen, wartet die
Shell auf eine Eingabe Ihrerseits. Versuchen Sie sich an
einem Befehl, indem Sie ls eingeben und mit der Eingabetaste
(Enter) bestätigen. Nun erscheint eine Liste mit Verzeichnissen
und Dateien des gewählten Datenträgers, gefolgt von
einer weiteren Eingabeaufforderung. ls ist der Name eines
Shell-Befehls, der die Dateien in Ihrem momentan gewählten
Verzeichnis auflistet. Indem Sie den Namen eines Befehls
eingeben und Enter drücken, veranlassen Sie die Ausführung
durch die Shell.
Sie können die Art der Ausführung durch das Hinzufügen
von Parametern anpassen, meist in der Form -x, also durch
einen Gedankenstrich gefolgt von einem Buchstaben. Im obigen
Beispiel könnten wir den Befehl ls durch -l ergänzen, was
eine detailliertere Übersicht zur Folge hätte.
Andere Befehle werden durch sogenannte Argumente
näher spezifiziert. Der Befehl cp zum Kopieren einer Datei
beispielsweise benötigt zwei Ortsangaben als Argumente,
nämlich Quelldatei und Zieldatei:
cp hello.txt world.txt
Dieser Befehl kopiert die Datei hello.txt in das momentan gewählte
Verzeichnis und gibt der Kopie den Namen world.txt.
Wenn letztere Datei noch nicht existiert, wird sie erstellt;
wenn sie bereits existiert, wird sie überschrieben – es ist also
Vorsicht geboten!
74

Projekte
Bash-Skript
Wenn Sie ein Verzeichnis wechseln wollen, benutzen Sie
den Befehl cd. Ein Beispiel: cd / führt Sie in das Stammverzeichnis,
welches in der Verzeichnishierarchie ganz oben
steht; cd /usr/bin führt hingegen in das Unterverzeichnis
bin des Verzeichnisses usr, welches wiederum ein Unterverzeichnis
des Stammverzeichnisses ist.
Pfade können auch ortsrelativ sein. Wenn Sie sich im
Stammverzeichnis befinden und in das Unterverzeichnis Documents
wechseln möchten, so geben Sie cd Documents
ein, und die Shell sucht im momentan gewählten Verzeichnis
nach einem entsprechenden Unterverzeichnis und wechselt
an diese Stelle.
Pfade dienen auch dazu, Dateien zu benennen, die das Ziel
eines Befehls darstellen sollen. Um beispielsweise die Datei
hello.txt nach world.txt zu kopieren, während sich world.txt
in Ihrem Dokumentenverzeichnis und hello.txt in Ihrem
Testverzeichnis befindet, geben Sie folgendes ein:
cp test/hello.txt /home/jon/Documents/world.txt
So können Sie relative und absolute Pfade kombinieren und
in Einklang bringen.
Hallo Welt
Kommen wir nun zu den interessanten Dingen: den Skriptbefehlen
für Bash. Lassen Sie uns einer bewährten Tradition bei
Programmier-Tutorials folgen und mit einem Programm beginnen,
das „Hello World“ auf Ihrem Monitor darstellen soll.
Schreiben Sie Folgendes in eine Datei und speichern Sie
diese:
#!/bin/bash
echo ”Hello World”
Danach wandeln Sie die Textdatei zu einer ausführbaren
Datei, indem Sie
chmod +x
eingeben und aus der Shell heraus starten:
./.
Nun sollten Sie die beiden magischen Wörter auf dem Bildschirm
sehen. Die erste Zeile ist die sogenannte „Shebang“-
Zeile. Diese wird vom Betriebssystem genutzt, um
Sie können die Skriptbefehle nicht nur in Dateien, sondern
auch direkt in die Konsole eingeben.
Immer wissen, wo man ist
Wenn Sie die Shell benutzen, sollten
Sie stets Ihr momentan gewähltes
Verzeichnis im Auge behalten. Wie
bereits im Artikel beschrieben, startet
die Shell für gewöhnlich immer im
Stammverzeichnis. Das hört sich vielleicht
nach einem unwichtigen Detail
an, ist tatsächlich jedoch überaus
wichtig. Solange Sie keinen absoluten
Pfad angeben, verhalten sich alle
Dateien und Verzeichnispfade relativ
zu Ihrem momentan gewählten Verzeichnis.
Wenn Sie einen Befehl von
einem falschen Verzeichnis aus veranlassen,
können Sie die seltsamsten
Resultate erhalten – das schließt auch
„Nun sollten Sie die beiden
magischen Wörter auf dem
Bildschirm sehen.“
versehentliches Löschen von Dateien
mit ein. Bestimmte Vorgänge wie das
Unmounting eines Verzeichnisses
werden fehlschlagen, wenn noch Operationen
im betreffenden Verzeichnis
stattfinden. Wenn Sie die Shell in
diesem Moment interaktiv steuern,
stellt dies kein großes Problem dar.
Wenn Sie aber ein Skript laufen lassen,
das versucht, in ein Verzeichnis
zu gelangen, das bereits gelöscht
wurde, bricht das Skript ab – und Sie
werden die Ursache erst ermitteln
müssen. Sie können das momentan
gewählte Verzeichnis jederzeit
mit dem Befehl pwd überprüfen.
festzulegen, mit welchem Programm der Inhalt des Skripts
auszuführen ist, in diesem Falle Bash. Es muss dabei immer
der absolute Pfad angegeben werden. Die zweite Zeile stellt
einen Standardbefehl der Shell dar. In diesem Beispiel handelt
es sich um den Befehl echo, der das ihm folgende Argument
auf dem Monitor ausgibt.
Natürlich gibt es außer echo noch viele andere Befehle, die
an dieser Stelle direkt ausgeführt werden können, und genau
das macht das Skripten mithilfe der Shell zu einem so mächtigen
Instrument. Mit dem Kommando man können Sie sich
die Verwendungsmöglichkeiten für jeden einzelnen Befehl
anzeigen lassen. Tippen Sie dazu beispielsweise man echo
ein. Sogar man man ist möglich, wenn Sie mehr über den
man-Befehl selbst wissen möchten.
Sie können entweder direkt aus der großen Bandbreite
von Befehlen schöpfen, die Bash zu bieten hat, oder Sie nutzen
Funktionen wie Redirection und Pipes, um Befehle zu
verknüpfen. Sie können aber auch Skripte mit bedingten Anweisungen
und Verzweigungen für Schleifen und Subroutinen
schreiben.
Im Zusammenhang mit unserem ersten Skript sind noch
zwei Dinge erwähnenswert: Zum einen mussten wir die Datei
in eine ausführbare umwandeln, denn sonst hätte das Betriebssystem
sie nicht laufen lassen können. Zum anderen
konnten wir den Namen der Datei nicht wie einen Befehl einfach
eintippen, sondern wir mussten ein ./ voranstellen. Der
Punkt ist dabei Kurzschrift für den momentan gewählten Dateipfad,
und der Schrägstrich ist die übliche Trennung von Dateien
und Pfaden (siehe auch Kasten „$PATH“ auf Seite 76).
75

Projekte
Unter Bash
stehen Ihnen
vielfältige Mittel
zur Zuordnung
von Dateien zur
Verfügung, die
Verwendung von
absoluten und
relativen Pfaden
eingeschlossen.
Variablen
Sie können unser Skript auf vielfältige und einfache Weise erweitern:
Fügen Sie einfach in neuen Zeilen weitere Befehle
hinzu:
#!/bin/bash
„Um komplexere Skripte
erstellen zu können,
benötigen wir Bindeglieder.“
echo ”hello world”
echo ”These files are in my current directory:”
ls
Mit den in Bash verfügbaren Befehlen bekommen Sie auf
simple Art und Weise schon jetzt viele Möglichkeiten an die
Hand. Um komplexere Skripte erstellen zu können, benötigen
wir jedoch Bindeglieder, die wir uns aus anderen Programmierspra-
chen entleihen.
Diese ermöglichen
uns, intelligentere
und flexiblere
Skripte
zu schreiben.
Lassen Sie uns mit Variablen beginnen, mit denen wir Werten
bestimmte Namen zuordnen können. Ein Beispiel:
#!/bin/bash
name=Jon
echo ”Hello ${name}”
echo ”${name}, that’s a nice name.”
Die erste Zeile nach unserem Shebang weist der Variablen
den Text-String Jon zu. Danach können wir uns an jeder Stelle
des Skripts auf diese Variable beziehen, indem wir den
Namen der Variablen wie oben in eine geschweifte Klammer
setzen und ein Dollarzeichen voranstellen, also ${}. Wenn wir
das Skript dann ausführen, durchsucht Bash es und ersetzt
den Wert name an jeder Stelle durch ${name}, also den Inhalt
der Variablen.
Allein dies ist schon oft nützlich, aber Bash hat noch mehr
auf Lager: Überaus praktisch ist beispielsweise die Zuweisung
einer Ausgabe zu einer Variablen, indem wir sie mit
Backticks/Gravis (`) einfassen:
date=`date +%Y-%m-%d`
So wird die Ausgabe des Befehls date zu einer Variablen namens
date zur späteren Verwendung innerhalb des Skripts.
Noch geschickter ist die Verknüpfung der Ausgabe von Befehlen
durch den Gebrauch von Strings, indem wir die Konstruktion
$() verwenden:
echo “Today’s date is $(date +%Y-%m-%d)”
An dieser Stelle schlagen wir den Bogen zu den Backups, da
wir so Dateien mit dem jeweils aktuellen Datum erstellen
können.
Die Steuerung des Datenflusses
Ein weiteres Bindeglied, das Bash zur Verknüpfung unserer
Befehle zur Verfügung stellt (und welches üblicherweise auch
Bestandteil anderer Programmiersprachen ist), stellt die
Kontrolle des Programmablaufs dar. Bislang nämlich waren
wir ausschließlich in der Lage, Bash die Befehle in exakt der
Reihenfolge abarbeiten zu lassen, wie wir sie im Skript niedergeschrieben
haben. Mittels bestimmter Befehle zur Datenfluss-Steuerung
sehen wir uns aber in der Lage, den Ablauf
des Skripts zu manipulieren.
Das erste Werkzeug aus der Familie der Datenfluss-Steuerung
sind Bedingungen wie if ... then („wenn ... dann“). Der
Gedanke dahinter ist folgender: Ein Befehlsinterpreter prüft,
ob eine Bedingung zutrifft, etwa ob eine bestimmte Datei vorhanden
ist. Und nur wenn diese Bedingung zutrifft, wird
nachfolgender Code auch ausgeführt:
#!/bin/bash
if [ 2 > 1 ]; then
echo ”True”
fi
Dies ist jetzt nur ein simples Beispiel, da die Ausgabe stets
True („wahr“) lauten wird. Trotzdem wird hier die Syntax
deutlich. In Bash werden if-Ausdrücke immer wie folgt konstruiert:
Zunächst steht das Schlüsselwort if, gefolgt von einer
Anweisung, die in eckigen Klammern steht. Darauf folgt das
Schlüsselwort then, welches vor der Anweisung steht, die
dann ausgeführt wird, wenn die Bedingung erfüllt wird.
$PATH
Es ist überhaupt nichts Geheimnisvolles am Ausführen von
Befehlen in Bash. Wenn Sie einen Namen angeben, findet
die Shell den Binary oder das Skript, auf den sich dieser
Name bezieht. In der Folge wird der Befehl als gewöhnliches
Skript oder Programm ausgeführt, wie zum Beispiel
bei ./hello.bash. Aber wie findet die Shell die Datei, wenn
Sie den absoluten Pfad gar nicht angeben müssen?
Die Antwort darauf ist die Variable $PATH. In der Shell steht
Ihnen eine ganze Palette an Umgebungsvariablen zur Verfügung,
die die Art, wie Programme ausgeführt und Befehle
interpretiert werden, beeinflussen. Eine dieser Variablen trägt
den Namen PATH und enthält eine Liste von Verzeichnissen,
wo Befehle oder Skripte zur Ausführung liegen. Wann
immer Sie den Namen eines Befehls eingeben, durchsucht
die Shell diese Liste von Verzeichnissen von links nach rechts,
bis eine Datei mit demselben Namen wie der von Ihnen
ausgeführte Befehl gefunden wird. Falls keine Übereinstimmung
gefunden wird, gibt die Shell folgenden Fehler aus:
-bash: foo: command not found
Sie können die Inhalte der $PATH-Variablen wie bei jeder
anderen stets durch sogenanntes Echoing anzeigen lassen,
der Befehl lautet echo ${PATH}. Und genau wie bei einer
beliebigen anderen Variablen können Sie auch diese modifizieren.
Wenn Sie die geänderten Einstellungen beim Abschluss
einer Sitzung für die nächste erhalten wollen, müssen Sie
die Bash- Konfigurationsdateien .bashrc oder .bash_profile
ändern. Welche Datei infrage kommt, ist abhängig davon, ob
Sie die Login-Shells, Subshells oder beide ändern möchten.
76

Projekte
Abgeschlossen wird der Block mit dem Schlüsselwort fi.
Bash ist von Haus aus in der Lage, vielfältige und nützliche
Tests durchzuführen. So wird mittels des Parameters -f geprüft,
ob eine Datei existiert, oder mithilfe von -nt, ob eine
Datei neuer als eine andere ist:
if [ -f /var/run/backup.lock ]; then
exit 1
else
touch /var/run/backup.lock
tar -czf /mnt/backup-$(date +%Y-%m-%d).tgz /
home/jon
rm /var/run/backup.lock
fi
In diesem Beispiel prüft Bash, ob eine .lock-Datei existiert.
Falls ja, brauchen wir kein neues Backup zu starten, da wir annehmen,
dass bereits ein älteres Backup läuft. Wenn die Datei
jedoch nicht existiert, nutzen wir else, um eine Datei zu erstellen,
lassen das Backup laufen und entfernen die .lock-Datei.
Nehmen Sie sich ein wenig Zeit für die man-Seite von
Bash, um sich mit anderen Tests vertraut zu machen.
Lassen Sie uns noch kurz den Bash-Befehl exit anschauen.
Immer wenn ein Bash-Programm oder Befehl endet, wird
ein numerischer Wert ausgegeben. Eine 0 bedeutet dabei,
dass alles erfolgreich abgeschlossen wurde. Ein anderer Wert
deutet jedoch darauf hin, dass irgendetwas schief gelaufen
ist. Das ist besonders in Kombination mit der Variablen ?
nützlich, welche den sogenannten Exit Code des Programms
speichert. Dies erlaubt die Kontrolle der Ausführung Ihres
Programms in der Hinsicht, dass sie als Indikator für die korrekte
oder inkorrekte Ausführung verschiedener Programmteile
dient.
for-Schleifen
Ein anderes nützliches Bindeglied in praktisch jeder Programmiersprache
ist die for-Schleife. Sie dient zur Wiederholung
einer Gruppe von Objekten, sodass wir einen bestimmten
Codeblock auf jedes Objekt in gleicher Weise
anwenden können. In Bash funktioniert das ähnlich wie die
if-Anweisung:
for file in $(ls); do
echo ${file}
done
Nur ein weiteres äußerst simples Beispiel, aber auch hier soll
ja nur die Syntax verdeutlicht werden. Nach dem Schlüsselwort
for kommt immer eine Platzhalter-Variable, welche auf
jeden Wert in dem Ausdruck nach dem Schlüsselwort in angewendet
wird.
Bringen Sie Ordnung in Ihre Projekte, indem Sie Ihren
Programmcode in kleine Häppchen aufteilen und jedes in
einer eigenen Datei ablegen.
Redirections und Pipes
Bei allen vorangegangenen Beispielen
wurden die Ausgaben auf dem Monitor
dargestellt, und zwar in der Shell-
Sitzung, die gerade auf Ihrem Terminal
ausgeführt wurde. Sie können die
Ausgabe aber auch „redirecten“, sprich
umleiten.
Programme senden ihre Ausgabe zu
einer „Pipe“ namens stdout. Diese Pipe
hat zwei Enden: Eine ist mit dem Programm
verbunden, das für die Ausgabe
verantwortlich ist, das andere Ende mit
der Stelle, die die Ausgabe erhält und
weiterleitet. In der Voreinstellung ist dies
der Monitor, aber das ist nur eine der
Möglichkeiten.
Diese Pipe können Sie auf zwei Arten
manipulieren. Zum einen können Sie
das Ausgabe-Ende neu verbinden,
sodass die Ausgabe in eine Datei
Eines haben alle guten Programmiersprachen gemeinsam:
Funktionen. Diese sind auch unter Bash verfügbar und sind
für Ihre Skripte praktisch unabdingbar. Die Erstellung und
das Abrufen von Funktionen sind dabei denkbar einfach: Um
eine neue Funktion zu definieren, geben wir ihr einen Namen,
gefolgt von zwei runden Klammern, und stellen den zugehörigen
Code in geschweifte Klammern:
func () {
echo ”My first function.”
echo $1
}
func ”hello”
Wie man an diesem Beispiel sehen kann, geschieht der Aufruf
einer Funktion analog zu jedem anderen Bash-Code: Wir
geben den Namen ein, gefolgt von einem beliebigen Argument.
Diese Argumente können dann als numerische Variablen
ausgeführt werden: $1 ist das erste Argument, $2 das
zweite und so weiter.
Derselbe Satz von Variablen gewährt uns auch Zugriff auf
Argumente der Befehlszeilen des Skripts, sodass wir Programme
schreiben können, die nur auf bestimmte Dateien
angewendet werden oder sich nach benutzerdefinierten Präferenzen
verhalten. Stellen wir uns vor, die folgende Datei sei
als name.bash abgelegt:
#!/bin/bash
echo $1
jon@adam ~$ ./name Jon
Jon
umgeleitet wird:
echo ”Hello world” > hello.txt
Die Umleitung geschieht dabei durch
das Größer-Zeichen.
Zum anderen verfügen Sie über die Pipe
stdin. Diese Pipe wird zur Kontrolle
einer Eingabequelle für ein Programm
genutzt. Eine der leistungs fähigsten
Funktionen von Bash ist die Möglichkeit,
die stdout-Pipe eines Programms
mit der stdin-Pipe eines anderen zu
koppeln:
ls | grep *.txt
Das Verkettungszeichen | verbindet die
Ausgabe des ls-Befehls mit der Eingabe
des grep-Befehls, der in diesem Beispiel
alle Ergebnisse bis auf jene ausfiltert, die
auf .txt enden. Auf diese Art können Sie
beliebig viele Programme miteinander
verknüpfen.
Nun sind Sie an der Reihe
Aufbauend auf diesen Grundlagen können Sie mithilfe eigener
Skripte alle möglichen Aufgaben auf Ihrem Linux-System
automatisieren. Falls Sie an eine schwierige Stelle kommen,
ziehen Sie bereits vorhandene Programme zur Unterstützung
heran oder koppeln Sie mehrere einfachere Programme
zur Lösung einer komplexen Aufgabe zusammen.
77

Projekte
dnsmasq: DNS
Mit dnsmasq können Sie leicht einen DNS-Server (Domain Name
System) aufsetzen.
Vor nicht allzu langer Zeit war es noch ziemlich cool,
wenn man überhaupt nur einen Computer zu Hause
stehen hatte. Dann trat das Internet seinen Siegeszug
an, und der eine Computer kommunizierte auf einmal mit der
Welt. Kam noch ein zweiter Rechner hinzu, so verband man
beide Maschinen ohne großen Aufwand miteinander, vergab
statische IP-Adressen, und den Rest erledigten das Modem
und der Internetprovider.
Heute haben wir mehrere vernetzte Geräte, und einige
davon klinken sich von verschiedenen Orten aus ein. Das
heißt, dass eine automatische Konfiguration notwendig ist,
um Adressen zu organisieren, sie Geräten zuzuordnen und
anderen Geräten mitzuteilen, unter welcher Adresse sie ein
weiteres Gerät erreichen können. Zwei Protokolle sind hierbei
wichtig. DNS (Domain Name System) ist quasi das Telefonbuch
des Internets, es findet die IP-Adresse des Computers,
mit dem Sie kommunizieren möchten, egal ob es die IP-Adresse
des PCs im Nachbarzimmer ist oder eine große Suchmaschine.
DHCP (Dynamic Host Configuration Protocol) ist
das Protokoll, mit dem sich ein neues Netzwerkgerät anmeldet,
um eine IP-Adresse zu erhalten. Dazu kommen weitere
nützliche Dienste wie Netzwerk-Routing-Informationen und
die Adressen von DNS-Servern.
Domain Name System
Normalerweise stellen Internetprovider oder große öffentliche
Server DNS-Server bereit. Doch diese haben nur Informationen
über öffentliche Adressen. Wie aber läuft das
Ganze im Heimnetzwerk ab? In der Vergangenheit wurde
dies mithilfe statischer Adressen und einer Liste aller Geräte
in der Datei /etc/hosts für jeden angeschlossenen Rechner
gelöst. Heutzutage ist das unpraktikabel, bedingt nicht nur
durch die wachsende Anzahl von Geräten, sondern auch dadurch,
dass die Vergabe statischer Adressen für mobile Geräte
in der Praxis schwierig bis unmöglich ist.
dnsmasq ist ein lokaler DNS-Server, der sich dem Management
von Heimnetzwerken widmet. Das Tool hat einige Vorteile
gegenüber Servern, die online arbeiten. Der erste Vorteil
ist, dass Sie dnsmasq alle nötigen Informationen zum Netzwerk
mitteilen können, dann löst das Tool Hostnamen für alle
Geräte auf. Der zweite Vorteil liegt im Caching, das dnsmasq
dnsmasq in Routern
Wir haben dnsmasq als Dienst auf einem
Computer beschrieben, doch einige
Router haben bereits dnsmasq, um DHCP-
Dienste und DNS-Caching bereitzustellen.
Fast alles, was wir beschrieben haben,
können Sie auch mit einer integrierten
Installation von dnsmasq umsetzen. Voraussetzung
ist, dass der Router Zugang
zu seinen Konfigurationsdateien gewährt.
Das geschieht über das Web-Interface
des Routers, wo Sie die Einstellungen
hineinkopieren können, die Sie normalerweise
in eine Konfigurations-Textdatei
tippen. Wenn ihr Router DD-WRT oder
OpenWRT unterstützt, dann können Sie
auch via SSH auf den Router zugreifen.
Das Speichern von Einstellungen für jedes Gerät macht
das Management eines dnsmasq-Setups einfacher.
anbietet. Wenn ein Hostname nicht in der Liste der hosts-
Datei gelistet ist, fragt das Tool die nötigen Informationen von
einem öffentlichen DNS-Server ab. dnsmasq merkt sich die
Antwort, sodass die Informationen bereitstehen, wenn sich
ein zweiter Computer danach erkundigt.
Sie können sich den Quellcode von dnsmasq von
www.thekelleys.org.uk/dnsmasq herunterladen oder das
Tool wie gewöhnlich mithilfe des Paketmanagers Ihrer Linux-
Distribution installieren. Es ist keine spezielle Konfiguration
nötig, damit Sie das Tool als DNS-Server für Ihr Heimnetzwerk
nutzen können. Wenn der Rechner, auf dem Sie dnsmasq
installieren möchten, Zugang zum Internet hat, können
Sie es direkt starten. Das funktioniert ohne Umschweife,
wenn Sie die Datei /etc/resolv.conf (mit den Adressen und
Name-Servern, die Sie verwenden möchten) und Ihr Netzwerk
bereits korrekt eingerichtet haben. Standardmäßig
schaut dnsmasq zuerst in /etc/hosts und dann in /etc/
resolv.conf nach, um Adressen aufzulösen. Die anderen
Computer im Netzwerk brauchen nur die IP-Adresse des
Rechners, auf dem dnsmasq eingerichtet ist, als primären
DNS-Server. Unter Linux hieße das, dass die Datei /etc/
resolv.conf die Information
nameserver 192.168.1.1
enthalten muss, wobei Sie die hier angegebene IP-Adresse
mit der IP des entsprechenden dnsmasq-Rechners in Ihrem
Heimnetzwerk ersetzen. Wenn Ihr Computer die Verbindungsinformationen
via DHCP vom Router erhält, dann benötigen
Sie die erwähnte IP-Adresse im Router-Interface.
Dann verwendet jedes angeschlossene Gerät dnsmasq anstatt
des entsprechenden Dienstes des Routers.
Ein lokaler Name-Server ist nützlich, wenn alle Geräte mit
einer statischen IP-Adresse ausgestattet sind. Dennoch erwarten
die meisten Geräte eine dynamische Konfiguration via
DHCP. Wie kann dnsmasq also die Adressen für jene Geräte
wissen? Die einfache Antwort: dnsmasq besitzt einen integrierten
DHCP-Server.
Da der DHCP-Server die IP-Adressen verteilt, kennt er alle
78

Projekte
Server
Adressen der im Netzwerk angeschlossenen Geräte. Es ergibt
also Sinn, die zwei Prozesse zu kombinieren, so wie dnsmasq
es tut. Wir müssen die Konfigurationsdatei anpassen,
um dnsmasq als DHCP-Server arbeiten zu lassen. Die Datei
befindet sich unter /etc/dnsmasq.conf. Sie enthält alle
Standardeinstellungen. Im Falle eines Updates besteht die
Gefahr, dass die Informationen überschrieben werden. Legen
Sie also eine separate Datei /etc/dnsmasq.d/ an, und kommentieren
Sie dann folgende Zeile am Ende der Datei /etc/
dnsmasq.conf aus:
conf-dir=/etc/dnsmasq.d
Sie müssen aber noch die Einstellung der dhcp-range vornehmen,
um den Server zu aktivieren. In der Standarddatei
dnsmasq.conf lautet die entsprechende Zeile:
#dhcp-range=192.168.0.50,192.168.0.150,12h
Kopieren Sie diese Zeile in die lokale Konfigurationsdatei, entfernen
Sie den Kommentar und passen Sie die beiden Adressen
mit den Informationen Ihres Heimnetzwerks an. Es handelt
sich um den Anfang und das Ende des Adressbereichs,
aus dem sich dnsmasq bedienen kann. Die dritte Option stellt
die Standardzeit für die Reservierung einer IP ein. Wenn Ihr
Router DHCP-Fähigkeiten hat, schalten Sie diese aus, denn
zwei DHCP-Server in einem Netzwerk können zu Verwirrungen
führen. Nach jeder Änderung der Konfigurationsdatei
von dnsmasq müssen Sie den Dienst neu starten. Alternativ
senden Sie ein SIGHUP-Signal, um die Einstellungen neu zu
laden. Das geht mit folgendem Befehl:
killall -HUP dnsmasq
Internet umleiten
Ab diesem Zeitpunkt bekommt jedes im Netzwerk angeschlossene
Gerät von dnsmasq eine IP-Adresse. Ins Internet
kommen diese jedoch wahrscheinlich noch nicht. Das liegt an
einer dritten Information, die ein DHCP-Server liefert: das
Standard-Gateway. Wenn Sie dnsmasq die Information vorenthalten,
dann geht das Tool davon aus, dass es sich um
dieselbe IP wie die des Computers handelt, auf dem es installiert
ist. Wenn Sie dnsmasq auf einem Router betreiben, dann
funktioniert das. Ansonsten fügen Sie die folgende Zeile in die
Konfigurationsdatei ein:
dhcp-option=option:router,192.168.1.2
Manchmal brauchen Sie eine statische Adresse, etwa für
einen Dateiserver. Ein solches Setup ließe sich manuell per
statischer Konfiguration einrichten, Sie müssen dnsmasq die
Details jedoch stets mitteilen, damit das Tool den Hostnamen
auflösen kann. Einfacher ist es, eine automatische Netzwerkkonfiguration
einzustellen und dem Tool zu sagen, dass
es eine bestimmte IP immer gleich vergeben soll. Hier erweist
sich eine zweite Konfigurationsdatei als nützlich. Sie können
eine allgemeine und für jeden Host eine spezielle Datei einrichten.
Ein Beispiel:
dhcp-host=B8:27:EB:8B:6F:CF,192.168.1.11,jeltz
txt-record=jeltz,”Raspberry Pi file server”
dnsmasq ist nicht BIND
Womöglich haben Sie beim Thema
DNS schon von BIND gehört. BIND
ist die Standardsoftware auf großen
DNS-Servern. Wenn Sie einen
für das Internet geöffneten DNS-
Server nutzen möchten, um Ihre
Domains zu organisieren, dann ist
BIND sinnvoll. dnsmasq arbeitet
anders, es ist für kleine private
Netzwerke gedacht. Es hat weder
die Leistungsfähigkeit noch die
Komplexität, die BIND mitbringt.
Die dhcp-host-Einstellungen haben Vorrang, sie enthalten
alle drei Informationen, getrennt durch Kommata: MAC-Adresse,
IP-Adresse und Hostname. Die zweite Zeile verknüpft
einen Computer mit einer einfachen Beschreibung. Sie wird
angezeigt, wenn Sie
dig +short hostname txt
eintippen. Das ist nützlich, sobald das Netzwerk größer wird
und andernfalls die Übersicht verloren geht. Wenn alle Netzwerkeinstellungen
unter einem Dach sind, dann sind Management
und Backups deutlich einfacher. Da alle Geräte im
Normalfall für eine automatische Einrichtung eingestellt sind,
müssen Sie keinerlei Einstellungen vornehmen.
Bei einem Laptop mit Kabel- und WLAN-Verbindung sind
zwei MAC-Adressen im Spiel. Wenn Sie wollen, dass sich der
Laptop stets mit derselben Adresse verbindet, dann müssen
Sie einfach beide MAC-Adressen spezifizieren, getrennt
durch Kommata:
dhcp-host=20:68:9d:bc:08:f5,50:46:5d:32:e2:51,192.168.1.8,
hostname
Haben Sie dies eingetragen, sollten Sie nicht probieren,
beide Verbindungen aufzubauen, da es sonst zu Problemen
kommen wird.
Die Informationen auf diesen Seiten kratzen nur an der
Oberfläche der Möglichkeiten, die dnsmasq bietet. Ist das
Tool einmal eingerichtet, lesen Sie sich die Kommentare in
der Standardkonfiguration sowie das FAQ auf der Projekt-
Website durch. So werden Sie neue Anwendungsgebiete für
das Tool kennenlernen und weitere Ideen sammeln.
Wenn Ihr
Router dnsmasq
verwendet, dann
können Sie die
gewünschten
Einstellungen
einfach in das
Web-Interface
kopieren.
79

Projekte
Syslog: Loggen per
System-Logger sind leistungsfähige Programme zur Überwachung – wir
erklären Ihnen, wie Sie den Datenwust filtern und nützliche Infos an Ihr E-Mail-
Konto senden.
Logwatch zeigt
Ihnen übersichtlich,
was in 24
Stunden auf
Ihrem Computer
passiert ist.
Das Programm syslog, ein System-Logger, läuft auf
Ihrem Computer im Hintergrund. Es sammelt Informationen
über andere Programme, die Sie auf Ihrem
Rechner ausführen – es weiß sogar mehr über Ihr System als
Google oder Facebook.
Programme müssen mit dem Anwender kommunizieren.
Ein Programm mit einer interaktiven grafischen Benutzeroberfläche
kann Ihnen beispielsweise direkt per Benachrichtigungsfenster
mitteilen, wenn es die ihm gestellte Aufgabe
ausgeführt hat oder wenn ein Fehler aufgetreten ist. Bei Hintergrundprogrammen
geht dies jedoch nicht. Jedes Programm
könnte zwar seine eigenen Log-Dateien anlegen, das
würde aber bedeuten, dass sich diese Dateien über den ganzen
Computer verteilen. Oder jedes Programm bräuchte eine
Root-Berechtigung, um Log-Daten an einem zentralen Sammelpunkt
abzulegen. Der syslog-Dämon schafft Abhilfe: Ein
Programm übermittelt Informationen an syslog, und syslog
schreibt die Informationen in eine Log-Datei. So benötigt nur
syslog tiefere Zugriffsrechte, nicht jedoch die anderen Programme.
Sie können alle Mitteilungen in einer einzigen Datei
sammeln und müssen sich dabei keine Gedanken über etwaige
Konflikte zwischen Programmen machen, die gleichzeitig
in diese Datei schreiben wollen – syslog organisiert dies einfach
im Hintergrund.
Wie meistens bei Linux gibt es eine Auswahl verschiedener
System-Logger – die wichtigsten Implementierungen sind
syslog-ng, rsyslog, sysklogd und metalog. Jeder Logger hat
spezifische Vor- und Nachteile, doch alle verfügen über die
gleiche Schnittstelle zum Rest des Systems. Der Hauptunterschied
betrifft den Ort des Mail-System-Logs. Dieses befindet
sich zwar immer in /var/log, aber je nach verwendeter
Distribution kann es messages, current oder syslog heißen.
Wir verwenden /var/log/messages in unseren Beispielen,
Sie müssen dies gegebenenfalls durch den entsprechenden
Begriff Ihres Systems ersetzen. Das Format des System-
Logs bleibt mit jeweils einem Eintrag pro Zeile immer gleich.
Jun 25 15:34:34 hactar sudo: nelz : TTY=pts/2 ; PWD=/
home/nelz ; USER=root ; COMMAND=/sbin/fdisk /dev/sda
Die beiden ersten Items – Datum und Zeit – sind offensichtlich,
es folgt der Hostname. System-Logger können auch
Nachrichten an andere Computer schicken, an dieser Stelle
wird der Hostname wichtig. Das nächste Item ist das Programm,
dass den Log-Eintrag vornimmt, in diesem Falle
sudo, und der Rest ist die Nachricht von sudo. Im Beispiel
wird Aufschluss darüber gegeben, welcher User von welcher
Stelle aus etwas ausgeführt hat.
Bleiben Sie auf dem Laufenden
Sie haben nun also eine Datei in /var/log, die sich mit allerlei
Informationen darüber füllt, was in Ihrem System vor sich
geht. Welchen Nutzen haben Sie davon? Zum einen dient die
Datei als Diagnose-Tool und hilft Ihnen herauszufinden,
woran es liegt, wenn etwas nicht wie erwartet funktioniert.
Zum anderen können Sie damit Ihr System auf verdächtige
Aktivitäten hin beobachten, wie zum Beispiel wiederholte
fehlgeschlagene Log-in-Versuche von immer derselben
Internetadresse.
Die einfachste Möglichkeit, die Diagnosefunktion zu nutzen,
ist, die Log-Datei mit einem Terminal-Pager wie less einzulesen
oder sie mit grep zu durchsuchen. Wenn Sie den
Namen des Programms kennen, ist es recht einfach, die relevanten
Zeilen aufzuspüren. Sie können die Datei aber auch
mittels tail interaktiv überwachen:
tail -f /var/log/messages
zeigt die letzten zehn Zeilen des Logs und dann jede neue
Nachricht, die hinzugefügt wird. Wenn Sie dies vor einer
80

Projekte
E-Mail
Aktion ausführen, bekommen Sie sogleich das Resultat der
Aktion angezeigt. Beispielsweise sehen Sie nach Einstecken
eines USB-Datenträgers:
Jun 25 15:38:34 hactar kernel: sd 9:0:0:0: Attached scsi
generic sg9 type 0
Jun 25 15:38:34 hactar kernel: sd 9:0:0:0: [sdi] 3893248 512-
byte logical blocks: (1.99 GB/1.85 GiB)
Hier ist der Kernel das Programm, welches die Nachrichten
sendet, und Sie können das Gerät sehen, das dem Datenträger
zugewiesen ist. Damit sind Sie auf der sicheren Seite,
wenn Sie mittels dd auf das Gerät schreiben möchten.
Logwatch und Logcheck
Eine Log-Datei öffnen Sie in der Regel nur dann, wenn Sie ein
Problem lösen müssen, und eher selten aus Spaß an der
Freud. Allerdings können wichtige Nachrichten geloggt werden,
während Sie nicht hinschauen. Es gibt eine ganze Anzahl
von Programmen, mit denen Sie Log-Dateien überwachen
können, etwa Logwatch (www.logwatch.org). Dieses Programm
liest Ihr System-Log einmal täglich aus, fasst ungewöhnliche
und verdächtige Einträge zusammen und sendet
Ihnen das Ganze in Form einer E-Mail zu. Die Standard-Konfigurationsdatei
befindet sich in /usr/share/logwatch/
default.conf/logwatch.conf, da diese jedoch bei einem Update
überschrieben wird, sollten Sie etwaige Änderungen
lieber in /etc/logwatch/conf/logwatch.conf vornehmen –
Letztere hat Vorrang vor Ersterer. Sie können die neue Konfigurationsdatei
selber von Grund auf erstellen oder einfach
die Standard-Datei kopieren und bearbeiten. Zuletzt müssen
Sie MailTo auf die E-Mail-Adresse setzen, zu der die Reports
geschickt werden sollen. Mithilfe eines entsprechenden
MailFrom-Eintrags erleichtern Sie das Filtern dieser E-Mails.
Weitere Schlüsseleinstellungen sind Detail (die Menge an
Informationen in den Mails), Range (der Zeitraum, den eine
Mail abdeckt) und Service (welches die auszuführenden
Scans festlegt). Die Grundeinstellungen für Service ist „All“,
aber Sie können einzelne Dienste mittels
Service = -foo
ausschließen (hier würde zum Beispiel foo ausgeschlossen).
Die Dienste werden in /usr/share/logwatch/scripts/
services festgelegt, mit einem Skript für jeden Dienst mit
einem beschreibenden Kommentar. Sie werden mit den betreffenden
Dateien in /usr/share/logwatch/default.conf/
services konfiguriert. Wie auch die Standard-Konfigurationsdatei
können alle diese Dateien in das entsprechende Verzeichnis
/etc/logwatch kopiert und dort Ihren Wünschen
entsprechend angepasst werden. Sie können dabei den Detailgrad
der Nachrichten für jeden Dienst unabhängig von der
Grundeinstellung wählen.
Falls Sie sich etwas Unmittelbareres wünschen als Logwatch,
dann schauen Sie sich in diesem Falle einmal Logcheck
an (http://packages.debian.org/sid/logcheck).
Dies ist zwar eine Debian-Seite, aber das Programm ist für
die meisten Distributionen verfügbar. Es arbeitet ähnlich wie
Logwatch, wurde aber entwickelt, um häufiger ausgeführt zu
werden; in der Voreinstellung genau einmal pro Stunde. Die
Reports sind nicht so detailliert wie bei Logwatch, beinhalten
dafür aber eine stündliche Zusammenfassung über
„interessante“ Einträge. Darüber hinaus merkt sich das Programm
den letzten Zugriff auf ein Log, sodass unabhängig
vom Intervall nur neue Einträge dargestellt werden. Die „interessanten“
Einträge sind dabei diejenigen, die übrig bleiben,
nachdem alle harmlosen Einträge – die stets einen großen
Teil eines System-Logs ausmachen – herausgefiltert wurden.
Nach der Installation von Logcheck können Sie zwei Konfigurationsdateien
editieren: In /etc/logcheck/logcheck.
conf setzen Sie das Reportlevel auf Workstation (für Desktopsysteme),
Server oder Paranoid. Sendmailto ist selbsterklärend,
muss aber eingeschaltet werden, während Syslogsummary
auf Einstellung 1 eine Übersicht über die Log-
Ereignisse anstelle einer bloßen Liste gibt (dafür müssen Sie
das Paket syslog-summary installieren). Die andere Datei ist
/etc/logcheck/log.logfiles, welche eine Liste der zu überprüfenden
Dateien enthält – bei syslog-ng ist dies /var/log/
messages.
Nun erhalten Sie stündlich E-Mails mit neuen Einträgen
Ihres System-Logs. Wenn Ihnen diese Mails zu ausführlich
sind, können Sie eine Liste bemühen, die harmlose Einträge
schlicht ignoriert. Diese geht allerdings auf Nummer sicher,
sodass Sie vermutlich nachjustieren möchten, insbesondere
wenn Sie öfters Cronjobs ausführen. Wenn Sie einen Blick in
/etc/logcheck/ignore.d.workstation (oder server, je nach
Profil) werfen, sehen Sie Dateien, die zu ignorierende Ausdrücke
enthalten. Editieren Sie diese Dateien nicht, sondern erstellen
Sie stattdessen selbst eine, beispielsweise mit dem
Namen local. Jede Zeile dieser Datei ist ein regulärer Ausdruck
zum Ignorieren. Das folgende Beispiel ignoriert das Anschließen
eines USB-Datenträgers:
Jun 25 15:38:34 hactar kernel: sd 9:0:0:0: Attached scsi
generic sg9 type 0
Sie können dafür folgenden regulären Ausdruck benutzen:
^\w{3} [ :0-9]{11} [._[:alnum:]-]+ kernel: sd .* Attached scsi
generic .*
Lassen Sie sich von der Syntax nicht beeindrucken, sie folgt
dem üblichen Format. Der erste Teil zeigt Zeit, Datum und
Hostnamen auf. Danach sucht das Programm nach „Kernel“,
gefolgt von einem String, der „Attached scsi generic“ enthält.
Sie sollten diese Ausdrücke so spezifisch wie möglich machen,
um falsche Übereinstimmungen auszuschließen. Sie
können die Ausdrücke mit egrep in einer Datei testen:
egrep -f /etc/logcheck/ignore.d.workstation/local /var/log/
messages
Dieser Code gibt alle übereinstimmenden Zeilen aus, die
Sie nicht im Report von Logcheck wünschen.
Logcheck liefert
stündliche Reports,
benötigt aber
Filtereinstellungen,
um Sie nicht
mit belanglosen
Ereignissen zu
belasten.
81

Projekte
Desktop: Eigene
Ja, Sie können Ihre eigene, hochgradig angepasste, genügsame
Desktopumgebung bauen, ohne dafür eine einzige Zeile Code schreiben zu
müssen. Wir verraten Ihnen, wie.
Titelleisten und Schnellzugriffe, Panels und Benachrichtigungsbereiche
sowie nicht zuletzt Desktophintergründe
sind allesamt Dinge,
Auswahl des Fenstermanagers
die wir von einer modernen Desktopumgebung erwarten.
Normalerweise werden diese Funktionen von unterschiedlichen
Einzelprogrammen zu Verfügung gestellt. Wenn Sie
also Xfce nutzen und ps ax in ein Terminal eingeben, so wird
xfwm als Fenstermanager genutzt, xfce4-panel für Panels –
und so weiter. Wenn Sie diese Programme beenden, werden
Teile Ihrer Desktopumgebung vom Bildschirm verschwinden.
KDE und Gnome funktionieren ganz ähnlich.
Schön und gut, aber wir sind schließlich Linux-Geeks. Die
Grundkonfiguration macht einen ordentlichen Job, aber wir
nutzen dieses Betriebssystem, um es unseren Bedürfnissen
anzupassen, um jene Teile herauszureißen, welche uns keinen
Spaß machen, und um die inneren Funktionsabläufe des
Systems zu verstehen. Sie können jedes dieser Programme
für sich genommen ersetzen, Sie können aber auch Ihre eigene
Kombination aus Fenstermanager, Panels, Desktop-Switcher
und so weiter anlegen.
Es gibt zahlreiche leichtgewichtige Fenstermanager, die
nur das unbedingt nötige Minimum an Funktionalität besitzen,
weshalb andere Entwickler die restlichen Teile geschrieben
haben, die man für eine voll funktionsfähige Desktopumgebung
braucht. Wir sehen uns die möglichen Optionen an
und zeigen Ihnen, wie Sie sie zu einem personalisierten Desktop
zusammensetzen. Falls Sie KDE, Gnome oder Xfce nutzen,
werden Sie feststellen, dass das Resultat ein wesentlich
flotterer und speichersparenderer Rechner sein wird.
Wenn Sie einen
Fenstermanager
über die Paketverwaltung
hinzufügen,
sollte
auch eine entsprechende
Session
erzeugt werden.
Wir zeigen
Ihnen aber auch,
wie das manuell
funktioniert.
Der Fenstermanager ist die weitaus wichtigste Komponente
einer Desktopumgebung. Ein Fenster ist im Normalfall mit
einer Titelleiste ausgestattet, sodass Sie es auf dem Bildschirm
umherschieben können, sowie mit Buttons zum Maximieren,
Schließen und so weiter. Der Fenstermanager ermöglicht
auch das Vergrößern und Verkleinern eines
Fensters an dessen Rändern. Ohne Fenstermanager würde
eine Anwendung zwar auch funktionieren, doch Sie wären
nicht in der Lage, sie zu verschieben oder zu skalieren. Es
gibt einige neuartige Fenstermanager, die anders an die
Sache herangehen, indem Sie beispielsweise die Programme
in einem Gitter anordnen und somit keine Titelleisten
nötig sind.
In diesem Tutorial beschreiben wir die besten Vertreter
und erklären, wie Sie sie benutzen.
Wenn Sie die Fenstermanager über den
Paketmanager installieren, sollte es
möglich sein, dass Sie nach dem Ausund
Wiedereinloggen zwischen den
Fenstermanagern wählen können.
Wenn Sie keinen Eintrag für Ihren Fenstermanager
sehen, probieren Sie eine
Fallback- oder Terminal-Option im Login-Bildschirm aus: Einige
Distributionen bieten diese Möglichkeit an. Über das Terminal
können Sie den Fenstermanager mithilfe der unten genannten
Befehle starten. Falls Sie das neue Programm gar
nicht starten können, brauchen Sie sich keine Sorgen zu machen.
Wir zeigen Ihnen später, wie Sie sich selbst eine neue
Login-Session erstellen können.
Name: JWM
Website: http://joewing.net/projects/jwm/
Befehl zum Starten: jwm
JWM ist sehr schlank, in C geschrieben und benötigt nur
die Bibliotheken des X-Displayservers als Abhängigkeiten.
Deshalb arbeitet er auch pfeilschnell. JWM hat ein brauchbares
Standardpanel mit allerdings wenigen Features wie Programme-Menü,
Desktop-Umschalter und Taskleiste. Standardmäßig
enthält das Programme-Menü (das auch per
Rechtsklick auf dem Desktop erreichbar ist) nur Einträge, die
Ihnen das Starten eines Terminals sowie das Abmelden oder
Sperren des Benutzerkontos erlauben. Sie editieren das
Menü in der Datei /etc/jwm/system.jwmrc. Die XML-basierte
Konfigurationsdatei ist leicht zu verstehen, über sie
können Sie die Schriftart und Tastenkombinationen des
82

Projekte
Schreibtische
Fenstermanagers anpassen.
Name: Openbox
Website: www.openbox.org
Befehl zum Starten: openbox
Openbox gehört – wie auch Fluxbox – zur „*box“-Familie
der Fenstermanager, die sich auf den Stammvater Blackbox
gründet. Openbox ist vermutlich der beliebteste Leichtgewicht-Fenstermanager
und wird beim LXDE-Desktop verwendet.
Die Standardkonfiguratuion von Obenbox ist so
knapp wie möglich gehalten: Sobald Sie ihn starten, sehen
Sie erstmal eines: nichts. Bis auf den Mauszeiger, der in der
Mitte des Bildschirms verweilt. Mit einem Rechtsklick öffnet
sich ein kleines Kontextmenü, über das Sie ein Terminal,
einen Browser oder das Konfigurationswerkzeug aufrufen
können. Genau dieses Tool ist der Grund dafür, dass Openbox
unsere erste Wahl für Eigenbau-Desktops ist: Hier können
wir nämlich fast alles konfigurieren, ohne in Textdateien
herumstochern zu müssen. Zudem ist Openbox sehr standardkonform
und arbeitet daher wunderbar mit anderen
Werkzeugen zusammen. Die Tastenkombinationen sind wie
gewohnt: Mit [Alt]+[Tab] wechseln Sie durch die Fenster,
[Alt]+[F4] schließt Programme, und [Strg]+[Alt]+[Links/
Rechts] wechselt die Desktops.
Name: Ratpoison
Website: http://ratpoison.wxcvbn.org
Befehl zum Starten: ratpoison
Hier haben wir eine sehr ungewöhnliche Art von Fenstermanager:
Ratpoison wurde um ein „Tiling“ genanntes Konzept
herum konstruiert. Anders als beim sonst üblichen Konzept
verschiebbarer, sich überlappender Fenster belegen bei
Ratpoison die Fenster eine bestimmte Fläche auf dem Bildschirm.
Es dauert eine Weile, sich daran zu gewöhnen, aber
sobald Sie sich die Tastenkombinationen für die Arbeit mit
den Fenstern eingeprägt haben, sind Sie weniger von der
Maus abhängig. Deshalb auch der Name „Rattengift“. Beim
ersten Start ist Ratpoison fast komplett nackt, und Sie werden
feststellen, dass die Maus keine Funktion erfüllt. Drücken
Sie [Strg]+[t], gefolgt von [!], und es erscheint ein kleiner
Kasten in der rechten oberen Ecke, in den Sie ein Kommando
eingeben können (zum Beispiel xterm). Wenn Sie ein Programm
starten, wird es standardmäßig im Vollbildmodus
ausgeführt. Haben Sie mehrere Fenster geöffnet, schalten
Sie mit [Strg]+[t], gefolgt von [n] und [p], zwischen ihnen
Die gleiche Sprache sprechen
Es ist kein Zufall, dass die genannten
Tools so wunderbar zusammenarbeiten.
Kritiker werfen Linux vor, ein Mischmasch
aus alten und neuen Technologien zu
sein, die kaum etwas zusammenhält, was
allerdings nicht gerecht ist. Richtig, es
gibt immer noch eine Menge alten Code
zu finden, aber die Programme arbeiten
dank Standards trotzdem zusammen.
EWMH, die „Extended Window Manager
Hints“-Spezifikation, legt die Interaktionsmöglichkeiten
zwischen den Fenstermanagern,
den Anwendungen und
den Werkzeugen fest. Sie ermöglicht
also den Komponenten, Informationen
auszutauschen, um dem Nutzer eine
Erfahrung aus einem Guss zu bieten. Ein
gutes Beispiel sind Desktop-Umschalter:
Diese bieten oft eine Miniaturansicht
der Desktops und der gerade laufenden
Programme. Normalerweise möchten Sie
in diesen Voransichten nur die Anwendungsfenster
sehen, nicht auch noch
das ganze Desktop-Drumherum. Dank
EWMH kann ein Panel oder ein Fenstermanager
dem Desktop-Umschalter
sagen, dass ein bestimmtes Fenster
dort nicht sichtbar sein soll. Die vollständige
Spezifikation finden Sie unter
http://standards.freedesktop.org/
wm-spec/wm-spec-latest.html. Sie
ist lang, aber zwingend notwendig, sollten
Sie den Ehrgeiz entwickeln, einen
eigenen Fenstermanager zu schreiben.
um. Geben Sie [Strg]+[t] [w] ein, um eine nummerierte Liste
aller Fenster zu erhalten, [Strg]+[t], gefolgt von einer Ziffer,
um auf das entsprechende Fenster umzuschalten. Der wirkliche
Spass beginnt mit dem Tiling-Modus: Drücken Sie
[Strg]+[t] [s] mit einem neu geöffneten Fenster, um den Bildschim
horizontal in zwei Flächen zu teilen, Rahmen genannt.
Das aktuelle Fenster wird im oberen Rahmen angezeigt, das
vorherige darunter. Das Drücken von [Strg]+[t] [S] (Großbuchstabe)
teilt den Bildschirm vertikal. Das ist besonders
toll, wenn Sie einen großen Monitor mit einer hohen Auflösung
benutzen, auf dem Sie beispielsweise einen großen
Rahmen für den Webbrowser anlegen können, während Sie
daneben mehrere kleine Rahmen für diverse Terminal-Sessions
nutzen. Die Tastenkombination [Strg]+[t], gefolgt von
einer der Cursor-Tasten, hilft Ihnen beim Umschalten zwischen
den Rahmen. Sie können einen Rahmen auch wieder
im Vollbild anzeigen, indem Sie [Strg]+[t] [Q] tippen. Eine
Liste aller Tastenkombinationen erhalten Sie über die Eingabe
von [Strg]+[t] [?]. Hier hilft auch das Ratpoison-Wiki unter
http://tinyurl.com/obcarv5.
Auch die folgenden Fenstermanager sind einen Blick wert:
Sawfish (http:/sawfish.wikia.com/wiki/)
WindowLab (http://nickgravgaard.com/windowlab/)
Pekwm (www.pekwm.org)
Auswahl des Panels
Den Job der Fensterverwaltung haben wir nun also vergeben.
Nun möchten wir ein Panel zum Starten von Programmen,
zum Umschalten zwischen ihnen und den Desktop-Flächen,
zum Anzeigen einer Uhr und so weiter. JWM beinhaltet ein
einfaches Panel, aber wir hätten gerne ein paar zusätzliche
Funktionen.
Name: Docky
Website: www.go-docky.com
Befehl zum Starten: docky
Docky ist ziemlich cool. Es ist ein umfangreiches Panel und
hat viele Abhängigkeiten – falls Sie also planen, einen Desktop
für Maschinen mit wenig Speicher zu entwerfen, sollten
Sie lieber zu einer anderen Option greifen. Docky sollten Sie
in den Repositorys der meisten Distributionen finden. Zur Installation
reicht ein sudo apt-get install docky, sofern Sie
mit einer Ubuntu-basierten Distribution arbeiten. Wenn Sie
Docky starten, sehen Sie ein kleines schwarzes Panel am unteren
Bildschirmrand. Es gibt ein einziges kleines Anker-Icon,
83

Projekte
welches den Einstellungsdialog öffnet. Hier aktivieren Sie den
Panel-Modus, welcher Docky auf die gesamte Bildschirmbreite
ausdehnt. Wechseln Sie zum Docklets-Tab des Einstellungsdialogs,
um dem Panel weitere statische Items hinzuzufügen
wie etwa eine Uhr, einen Umschalter für den Desktop
oder eine Batterieanzeige. Docky bringt kein Hauptfenster
mit, was eine gewisse Einschränkung darstellt. Starten Sie jedoch
Programme über Ihren Fenstermanager, tauchen diese
auf dem Panel auf. Rechtsklicken Sie die Icons und wählen
Sie „Pin to dock“, um sie im Panel anzuheften. Auf diese
Weise füllen Sie das Panel mit den meistgenutzten Programmen,
weshalb das Fehlen eines Hauptfensters dann doch
kein so großer Nachteil ist.
Name: Cairo-Dock
Website: http://glx-dock.org
Befehl zum Starten: cairo-dock
Wenn Sie auf ein schönes Design Wert legen, ist Cairo-
Dock vielleicht etwas für Sie. Sein Aussehen ähnelt stark dem
von OS X, mit edlen Reflexions-Effekten und feinen Linien, die
die verschiedenen Flächen voneinander trennen. Icons werden
größer, wenn Sie den Mauszeiger darüber bewegen. Machen
Sie dasselbe bei einem Ordner, zeigt dieser eine Voransicht
seines Inhalts an. Das Programm ist wunderschön
designt, nimmt aber auch Ihre Grafikkarte dementsprechend
in Beschlag. Im Gegensatz zu Docky bringt Cairo-Dock ein
Hauptfenster mit, basierend auf den Systemeinstellungen.
Mit anderen Worten: Es zeigt jene Icons, die Sie auch unter
anderen Fenstermanagern und Desktops sehen würden. Sie
können jedes Bild rechtsklicken und konfigurieren. Das Panel
selbst passen Sie unter Cairo-Dock > Configure an. Es ist
wirklich sehr konfigurierbar, zudem gibt es viele aktivierbare
Add-ons, anpassbare Tastenkombinationen sowie modifizierbare
Größen- und Positionseinstellungen.
Name: WBar
Website: http://code.google.com/p/wbar/
Befehl zum Starten: wbar
Hierbei handelt es sich um das schlankste der hier vorgestellten
Panels. Deshalb startet es auch fast ohne
Openbox hat sein eigenes Konfigurationswerkzeug, was
das Herumfummeln in Textdateien unnötig macht.
Verzögerung. Es bietet einen durchsichtigen Hintergrund,
animierte wachsende Icons, wenn Sie den Mauszeiger darüber
bewegen, und nicht zuletzt ein grafisches Konfigurationswerkzeug
(wbar-config; separat installieren). Standardmäßig
wird WBar vertikal angezeigt, Sie können dies jedoch ändern,
wenn Sie das oberste Icon anklicken. Über den Icons-Reiter
fügen Sie weitere Start-Icons hinzu. Wenn Sie sich vom Panel
wünschen, sich mehr wie eine Taskleiste zu verhalten, finden
Sie eine Option dazu im Preferences-Tab. In der Effects-Registerkarte
finden Sie die Einstellungen für die Zoomstufe, die
Transparenz und die Abstände zwischen den Icons.
Weitere Panels (teils jedoch etwas veraltet):
tint2 (http://code.google.com/p/tint2/)
PerlPanel (http://savannah.nongnu.org/projects/
perlpanel)
Avant Window Navigator (https://launchpad.net/awn)
Hinzufügen von Extras
Die meisten spärlich ausgestatteten Fenstermanager erlauben
es nicht, selber ein Hintergrundbild auszuwählen. Das
bedeutet, dass Sie dafür ein separates Werkzeug benötigen.
hsetroot ist ein kleines Programm, das als eigenständiges
Paket auf fast jeder Distribution zur Verfügung steht oder
manchmal als Teil der HackedBox (ein anderer schlanker
Fenstermanager). Sobald Sie hsetroot installiert haben, ist
es ganz einfach wie folgt zu verwenden:
hsetroot -full /path/to/image.jpg
Dieser Befehl bringt das komplette Bild auf den Bildschirm,
ohne irgendwelche Anpassungen. Andere Optionen sind
-center, -tile und -fill (um es zu strecken). Sie können auch
PNG-Bilder und andere Formate verwenden.
Falls Ihr Dock oder Panel keinen Umschalter für die
Desktops mitbringt, brauchen Sie einen eigenständigen. In
dieser Kategorie gibt es leider keine so große Auswahl, wir
empfehlen allerdings den NetWMPager, der aufgrund seiner
minimalen Abhängigkeiten fast überall funktioniert. Sie finden
ihn unter http://sourceforge.net/projects/sfxpaint/files/netwmpager/.
Laden Sie sich dort den aktuellsten
Quellcode herunter, und kompilieren Sie ihn wie folgt:
tar xfv netwmpager-2.04.tar.bz2
cd netwmpager-2.04
./configure
make
sudo make install
Wenn Sie beim make-Schritt der Fehlermeldung „undefined
reference to symbol XGetWindowAttributes“ begegnen,
Sie möchten
sich ein schicken
Desktop wie bei
OS X bauen?
Greifen Sie zu
Cairo-Dock!
84

Projekte
editieren Sie config.mk und ändern die Zeile XFT_LIBS wie
folgt:
XFT_LIBS = -lXft -lX11
Speichern Sie die Datei und führen Sie die letzten beiden
Schritte erneut aus. Nun können Sie das Programm mit
netwmpager starten. Sie sehen, wie Ansichten der Desktops
in der linken unteren Ecke des Bildschirms erscheinen. Standardmäßig
sind diese sehr klein. Um dies zu ändern, müssen
Sie die Datei /usr/local/share/netwmpager/
config-example editieren, speziell die Zeilen geometry und
auto_hide.
Falls Sie einen Benachrichtungsbereich (System-Tray)
benötigen, ist Stalonetray ein guter Tipp. Es gibt Stalonetray
in den Paket-Archiven von Ubuntu wie auch als Quellcode
unter http://stalonetray.sf.net. Falls Sie selbst kompilieren,
führen Sie dabei die Schritte ./configure, make und
sudo make install aus und starten Sie Stalonetray danach
mit:
stalonetray -geometry 5x1+50+20
Das erstellt einen Nachrichtenbereich, der fünf Spalten breit
und eine Zeile hoch ist und dabei von der oberen linken Ecke
des Bildschirms 50 Pixel nach rechts und 20 Pixel nach
unten entfernt liegt. Diese Parameter können Sie natürlich
nach Belieben anpassen.
Kombination der Komponenten
Nun sind wir bereit, alle Komponenten zusammenzufügen,
um daraus eine Desktopumgebung zu basteln. Sie können
jede x-beliebige Kombination der zuvor genannten Programme
verwenden, wir nutzen hier Openbox, Docky, hsetroot,
NetWMPager und Stalonetray. Der erste Schritt ist das
Schreiben eines Scripts, das alle Programme startet. Für unseren
Eigenbau-Desktop legen wir es in den Ordner /usr/
local/bin/mikedesk-start:
#!/bin/bash
docky &
hsetroot -fill /usr/share/backgrounds/space-02.jpg &
netwmpager &
stalonetray -geometry 5x1+0+0 &
openbox
Das & hinter dem Befehl bedeutet, dass die Programme im
Hintergrund laufen sollen, sodass sie alle zur selben Zeit laufen
und aufgerufen werden können und nicht darauf warten,
bis das vorhergehende Programm beendet ist. Es ist jedoch
wichtig, dass der Fenstermanager in der letzten Zeile ohne
ein & gestartet wird, weil die Sitzung ansonsten sofort beendet
wird.
Speichern Sie die Datei und machen Sie sie ausführbar
(zum Beispiel mit sudo chmod +x mikedesk-start). Der
nächste Schritt ist das Erzeugen einer Login-Screen-Sitzung.
Legen Sie dazu eine neue Datei à la /usr/share/xsessions/
mikedesk.session mit dem folgenden Inhalt an:
[Desktop Entry]
Name=MikeDesk
Comment=Mike Desktop Environment
Type=XSession
Exec=/usr/local/bin/mikedesk-start
TryExec=mikedesk-start
Speichern Sie wieder, melden Sie sich mit Ihrer aktuellen Sitzung
ab, und es sollte eine neue Starten, dieses Mal aber mit
dem Login-Manager. Wählen Sie den Benutzernamen, loggen
Sie sich ein und genießen Sie die Früchte ihrer Arbeit. Glückwunsch:
Sie sind nun offiziell großartig.
Hier sehen Sie
das Ergebnis unserer
Arbeit: Eine
Desktopumgebung
bestehend
aus den von uns
ausgesuchten
Komponenten.
Hilfe! Meine Gtk- und Qt-Programme sehen blöd aus!
Das ist leider ein häufiges Problem
beim Wechsel des Fenstermanagers.
Sie richten alles perfekt ein, suchen
sich einen atemberaubenden Desktop-
Hintergrund aus... aber Ihre Gtk- und
Qt-Anwendungen sehen aus, als entstammten
sie den 1980er Jahren: flache
Menüs, grob gezeichnete Widgets,
dunkelgraue Hintergründe und hässliche
Schriften. Qt und Gtk können nicht mehr
ermitteln, welches Thema sie nutzen
sollen, also verwenden sie die eingebauten
Standardeinstellungen. Falls Sie
Gnome oder Xfce verwenden, können
Gtk-Anwendungen beim Desktop nachfragen,
welches Thema genutzt werden
soll. Mit einem eigenständigen Fenstermanager
sind die Programme auf das
angewiesen, was in ihren Konfigurationsdateien
steht. Für Gtk gibt es einige
Optionen, die sie ausprobieren können.
gtk-chtheme lässt Sie das Thema einstellen,
das von Gtk-2.x-Anwendungen
verwendet werden soll, nicht allerdings
für 3.0. Für Letzteres editieren Sie die
Datei ~/.config/gtk-3.0/settings.ini,
sodass sie den Namen des Themas
angibt:
[Settings]
gtk-theme-name = Clearlooks
gtk-fallback-icon-theme = gnome
Falls keine dieser Vorgehensweise
den erwünschten Effekt hat und Sie
Gnome installiert haben, versuchen
Sie, den Dienst gnome-settingsdaemon
zu starten. Dieser wird die
Gtk-Programme anweisen, Ihr neues
Thema zu verwenden, aber auch Ihren
Desktophintergrund zurücksetzen. Um
Qt-Anwendungen zur Nutzung von Gtk-
Themen zu verwenden, öffnen Sie die
Datei ~/.config/Trolltech.conf und
fügen Folgendes hinzu:
style=GTK+
Alternativ können Sie das Paket qt4-qtconfig installieren
und es mit qtconfig ausführen.
So sieht VirtualBox (eine Qt-Anwendung) mit dem
Standard-Qt-Thema aus: Windows 95 lebt!
85

Coding
86

Coding
Coding
Coding ist das Handwerkszeug eines jeden Linux-
Enthusiasten. Wir erklären Ihnen die
grundlegenden Strukturen der höheren
Programmierkunst und geben Ihnen auch
Hilfestellungen zu Python.
Generation CODE........................................................................................88
Raspberry Jams...........................................................................................92
Geany: Editor de luxe...............................................................................96
Code-Konzepte: Datentypen...........................................................100
Designkonzepte: Komplexe Typen.............................................102
Designkonzepte: Abstraktion.........................................................104
Designkonzepte: Dateien und Module...................................106
Python: So fangen Sie an.................................................................108
Designkonzepte: Eine IDE nutzen...............................................112
Designkonzepte: Ein Unix-Tool.......................................................114
Designkonzepte: Ein echter Klon................................................116
Designkonzepte: Klassenobjekte.............................................. 118
Designkonzepte: Module...................................................................120
Designkonzepte: Massenspeicher.............................................122
Designkonzepte: Datenorganisation........................................124
GUI-Code: Mit Clutter hantieren...................................................126
Python: Clutter-Animationen...........................................................130
87

Coding
Generation: CODE
Ein Blick auf einige Initiativen, die der jungen Generation
das Programmieren nahebringen möchten.
Präsentationen erstellt. Doch nun ist die
IT-Ausbildung Chefsache bei den Schulbehörden
und wird zusehends entstaubt.
Beispielsweise hat die britische Regierung
angekündigt, dass ab September 2014 im
Lehrplan anstelle besagter Büroausbildung
wieder ein echter Kurs der Computerwissenschaften
stehen wird.
Dabei wurde schnell erkannt, dass die
Ausrüstung der meisten Schulen nicht mehr
zeitgemäß ist und dass die Lehrer der oberen
Schulklassen oftmals weniger über die Materie
Lehrer, Regierungen und Industrie versuchen
seit geraumer Zeit, den praxisnahen
Umgang mit Computern im
Schulunterricht zu verankern. Die
Anfänge dieses Unterfangens liegen in den
80er-Jahren und konnten bestenfalls diejenigen
begeistern, die später unter dem Begriff
Nerds belacht und anschließend erfolgreiche
Unternehmer wurden. Anschließend
beschränkte sich der Unterricht auf den
Umgang mit Microsoft Office, wie man damit
Briefe schreibt oder PowerPointwissen
als ihre Schüler. Die notwendigen
Investitionen in Technik und Weiterbildung
dürften so manche Schule überfordern.
Erfreulicherweise haben sich im
Vereinigten Königreich längst einige gemeinnützige
Organisationen der Sache angenommen
und bieten – oftmals von Eltern und
Gemeinden unterstützt – ihre Hilfe an.
Beispielsweise rüsten sie die Schulen mit
moderner Technik aus oder bieten kostenlosen
Nachmittagsunterricht in eigenen
Räumen an.
88

Coding
Neben gemeinnützigen Organisationen entstehen derzeit
auch immer neue Webseiten mit dem gleichen Ziel:
Sie wollen Schülern das Programmieren näherbringen. Unter
www.codeavengers.com oder www.codeacademy.com sind
die zwei derzeit erfolgreichsten kostenlosen Unterrichtsseiten
zu erreichen, Letztere übersetzt ihre Kurse momentan
sogar Stück für Stück ins Deutsche. Diese und andere Seiten
helfen Kindern und Erwachsenen dabei, eine Programmiersprache
auf strukturierte, interaktive und kontrollierte Weise
zu erlernen.
Weltweit haben es sich Programmierclubs mittlerweile
zur Aufgabe gemacht, dass der Schulunterricht eine vergleichbare
Qualität bekommt. In diesem Bericht befragen wir
zwei dieser Vereinigungen nach ihrer Herkunft, ihren Zielen
und ihren bisherigen Erfolgen: der ausschließlich aus
Jugendlichen bestehende Club Young Rewired State, der auf
der ganzen Welt Programmierfestivals veranstaltet, und der
von britischen Schulen unterstützte Code Club, der außerhalb
des normalen Unterrichts wöchentliche Seminare
abhält.
Young Rewired State
Young Rewired State, die Jugendorganisation von Rewired
State, ist momentan in Großbritannien, den Vereinigten
Staaten und mittlerweile auch in Deutschland vertreten.
Unter eigener Regie und auch zusammen mit lokalen
Organisationen veranstaltet YRS in diesen Ländern
Clubtreffen und Wettbewerbe, auf denen Kinder und
Jugendliche im Team die Grundlagen des Zeit- und
Projektmanagements erlernen und nebenbei erfahren, was
eine Deadline bedeutet.
Jedem Team ist mindestens ein Mentor zugeordnet, der
als Unterstützer und gegebenenfalls als Leiter die Gruppe
durch die Veranstaltung führt, dem Team aber ansonsten
keine Arbeit abnimmt. Auf den bis zu sieben Tage dauernden
Treffen versammeln sich bis zu 500 Schüler, die auf dem
abschließenden Wettbewerb ihre Projekte einer Jury vorstellen.
Zwar gibt es den Konkurrenzkampf um Finalteilnahme
und Gesamtsieg, im Vordergrund der Veranstaltungen stehen
für die Teilnehmer aber der erlebte Teamgeist und die
Chance, neue Programmiertechniken zu erlernen.
Wir sprachen mit Thom Brooks, PR- und
Kommunikationsspezialist von Young Rewired State.
PC Games Hardware: Hi Thom! Can you tell me what Rewired
State is, and what its goals are?
Thom Brooks: Rewired State und Young Rewired State wurden
beide von Emma MulQueeny gegründet, die auf Twitter unter
@hubmam bekannt ist.
Rewired State veranstaltet
Hack-Events, auf
denen Kreative,
Entwickler und
Industrieexperten
gemeinsam ausgeschriebene
Real-World-
Probleme lösen.
Unsere Kunden sind
Körperschaften des
Öffentlichen Rechts,
Industriegiganten,
YRS veranstaltet das
jährliche Festival of
Code für Jugendliche.
Messen und gemeinnützige Organisationen. Die erste „Hack“
genannte Veranstaltung fand im Jahr 2009 statt und war mit
über 100 Entwicklern die Geburtsstätte für die mittlerweile
legendäre Reihe „National Hack the Government Day“.
Damals wurde der Grundstein für die Website http://data.
gov.uk gelegt und das hat dazu beigetragen, dass sich die
britische Regierung nun offenen Standards verschrieben
hat..
PCGH: Was war die Idee für das Projekt Young Rewired
State? Wie lief das Projekt an?
TB: Noch im Jahr 2009 beschlossen wir, unter dem Namen
Young Rewired State eine Veranstaltung speziell für
Jugendliche zu organisieren. In der Londoner Niederlassung
von Google wollten wir ein Wochenende lang über die freie
Verfügbarkeit öffentlicher Regierungsdaten sprechen und
was jugendliche Programmierer mit diesen Daten anfangen
können. Da die Google-Büros nur eine begrenzte Kapazität
haben, erwarteten wir überfüllte Räume … aber es erschienen
gerade einmal
drei Jugendliche.
Anrufe in den
benachbarten
Schulen und eine
kurze Recherche
im Internet offenbarte
uns die
Ursache dieses vermeintlichen
Desinteresses: Es gab im Land einfach nicht
genügend Programmierer. Und die wenigen, die es gab,
haben sich daheim im stillen Kämmerlein das
Programmieren selber beigebracht und sich damit selbst
zum Außenseiter abgestempelt – sogar die meisten Eltern
vermuteten hinter dieser anspruchsvollen Beschäftigung
eine kindliche Entwicklungsstörung. Und an vielen Schulen
war der Programmierunterricht längst abgeschafft.
Daraufhin suchten wir drei Monate lang nach 50 geeigneten
Kandidaten und veranstalteten für diese ein Wochenende.
Mit großer Begeisterung sahen wir, wie sie unter Aufsicht von
Mentoren und Datenexperten in kurzer Zeit Apps und
Webseiten erstellten, die öffentliche Regierungsdaten auswerteten.
Vor unseren Augen hat sich eine längst überfällige
Gemeinschaft gebildet. Junge Genies, die sich nie mehr alleine
fühlen müssen und sich mithilfe von erfahrenen Beratern
zu Programmierern ausbilden.
PCGH: Welches Ziel verfolgt Young Rewired State?
TB: Das Ziel ist ein weltweites und unabhängiges Netzwerk
Der Höhepunkt
des Festival of
Code ist das
Wochenende
in der Custard
Factory in
Birmingham.
„Wir erwarteten überfüllte
Räume … aber es erschienen
gerade einmal drei
Jugendliche.“
89

Coding
junger Programmierer, die sich gegenseitig unterrichten und
bei der Lösung ausgeschriebener Aufgaben unterstützen.
PCGH: Wie hat sich Young Rewired State in den vergangenen
Jahren weiterentwickelt?
TB: Im Jahr 2009 fingen wir mit 50 Jugendlichen an, mittlerweile
besteht die Gemeinschaft aus über 1.000 Jugendlichen.
Seit 2013 sind wir auch in anderen Ländern aktiv. Unsere erste
internationale Veranstaltung war das „Everywhere“-Event
in New York, im September waren wir in Berlin und dann in
Johannesburg und San Francisco. In all diesen Gegenden
verfolgen wir den gleichen Plan wie damals in England: Wir
fangen mit 50 Jugendlichen an und wachsen dann. Bisher
haben wir diese 50 immer erfreulich schnell gefunden.
Auf dem jährlichen Festival of Code in Birmingham trafen
sich letzten August über 500 Leute, die an insgesamt 125
Projekten arbeiteten. Im Jahr zuvor waren es nur 100.
Für die Musik
auf dem Festival
of Code war
unter anderem
Theremin Hero an
der Laser-Harfe
zuständig
PCGH: Wie läuft die Gründung dieser lokalen Zentren ab?
TB: Die Community steht immer an erster Stelle. Es ist die
Gemeinschaft aus jugendlichen Programmierern und
Mentoren, die aus Young Rewired State etwas Besonderes
macht. Also wollen wir die Leute an einem Ort versammeln
– Young Rewired State stellt dabei nur eine Vorlage für die
Organisation eines Wochenendes zur Verfügung, die
Gemeinden setzen sie dann um. Lokale Firmen,
Medienzentren, Schulen und andere Einrichtungen stellen
dafür ihre Räume zur Verfügung und nur bei Bedarf senden
wir unsere Mentoren für Rat und Tat vor Ort.
Der Erfolg nährt sich selbst: Im Jahr 2013 hatten wir alleine in
Großbritannien 40 aktive Zentren und 160 Mentoren, die wiederum
die Organisation und Unterstützung weiterer Zentren
übernehmen. Es hat sich längst herumgesprochen, dass
Programmierer dringend gebraucht werden, und die
Arbeitgeber fragen sich mittlerweile, wie man deren
Ausbildung unterstützen kann.
Da bieten sich die Unterstützung
der Zentren und die
Veranstaltung der Events natürlich
an.
Botschafter der Mathematik
PCGH: Young Rewired State hat
schon viel erreicht. Welches
war das wichtigste Erlebnis
auf diesem Weg?
TB: Nur eins? Für mich ist das
aufregendste Erlebnis die
Erkenntnis, dass es funktioniert.
Hinter den Kulissen
arbeitet ein kleines Team, das
Clare Sutcliffe, Mitbegründerin von Code Club: „Wir
haben mittlerweile über 1000 Clubs.“
mit einem Twitter-Hype den Grundstein gelegt hat, aber mittlerweile
wächst YRS ganz von alleine. Für die Teilnehmer sollte
das größte Erlebnis der Sonntagabend sein, wenn sie auf
die letzten Tage zurückblicken und sich sagen „Ich war Teil
von etwas ganz Besonderem.“
PCGH: Welches sind die Ziele für die nächsten zwölf
Monate?
TB: Nach dem letztjährigen Erfolg wiederholen wir
„Everywhere“ in New York im Jahr 2014. Wir wollen dort fünf
Zentren aufbauen. Außerdem werden wir die Community
weiter vergrößern, die Gemeinschaftsidee propagieren und
auf die Bedeutung öffentlicher Daten hinweisen. Und bei all
dem wollen wir Spaß haben. Wenn die Leser uns dabei unterstützen
möchten: Auf unserer Website
https://youngrewiredstate.org kann man alles über
Zentren und Gruppen erfahren. .
Code Club
Nicht weniger einflussreich als YRS, aber mit einem völlig
anderen Ansatz angetreten, ist Code Club. Der Club veranstaltet
wöchentliche Treffen, auf denen die Kinder und
Jugendlichen nach einem echten Lehrplan das
Programmieren lernen. Dieser Lehrplan wird von Code Club
und von freiwilligen Helfern ausgearbeitet und beinhaltet die
Grundlagen der Programmierung, Scratch, moderne Web-
Technologien und jedes andere Wissen, welches die Helfer
im Klassenzimmer vermitteln wollen.
Wir sprachen mit Clare Sutcliffe, die im April 2012 zusammen
mit Linda Sandvik den Code Club gründete. Clare
erzählte uns mehr über das Projekt und wie Interessenten
der Initiative beitreten können.
Um Naturwissenschaften eine
größere Präsenz an britischen
Schulen zu verschaffen, wurde 1996
STEMNET gegründet. Die Non-Profit-
Organisation finanziert sich aus
Regierungsgeldern und unterstützt
Lehrer, Schüler und
Ausbildungsbetriebe bei der
außerschulischen Beschäftigung mit
diesen Themen. Die sogenannten
Ambassadors (Botschafter)
betätigen sich dabei als Ratgeber
oder als Lehrer und werden laufend
von STEMNET überwacht und auch
weitergebildet. Meist handelt es sich
bei den Helfern um aktive
Wissenschaftler, die ihre Freizeit dem
Gemeinwohl widmen möchten.
Weitere Details finden Sie auf der
Webseite www.stemnet.org.uk.
PC Games Hardware: Hallo Clare! Wer oder was ist Code
Club?
Clare Sutcliffe: Code Club wurde von Linda Sandvik, einer
Schnittstellen-Designerin, und mir, einer Grafik-Designerin
gegründet. Die treibende Kraft im Code Club sind aber all die
Freiwilligen, die für das Projekt ihre Zeit opfern
PCGH: Was hat euch dazu bewogen, den Code Club zu
gründen?
CS: Linda und ich saßen in einer Kneipe und stellten nach ein
paar Drinks fest, dass es an den Schulen keinen
90

Coding
Programmierunterricht mehr gibt. Also hatten wir die Idee
eines Hack Days, auf dem Kinder im Programmieren unterrichtet
werden. Nach dem nächsten Drink stand fest, dass
dies keine einmalige Veranstaltung sein darf, sondern ein
Club mit fortlaufenden Terminen. Wir hatten Glück, dass viele
unserer Freunde Programmierer sind und sich sofort
bereit erklärt hatten, uns bei dieser Idee zu helfen. Wir haben
den Code Club im Jahr 2012 gegründet und seitdem über
1.000 Clubs bei deren Gründung begleitet.
PCGH: Wer sind die freiwilligen Helfer?
Welche Anforderengen müssen sie erfüllen?
CS: Das ist ein bunter Querschnitt der Bevölkerung. Die größte
Gruppe sind die Lehrer derjenigen Schulen, in denen die
Clubs sich treffen. Der Rest sind Freiberufler, Eltern und
Programmierer im Ruhestand. Wer im Code Club unterrichten
möchte, der braucht ein polizeiliches Führungszeugnis.
Außerdem empfehlen wir allen Freiwilligen, sich als Science,
Technology, Engineering and Mathematics (STEM)
Ambassador zu registrieren. Diese Botschafter arbeiten mit
Schulen bei allen naturwissenschaftlichen Fragen zusammen
und unterstützen die Lehrer bei ihrer Arbeit. Für die meisten
Botschafter ist diese Aufgabe einfach eine gut organisierte
Möglichkeit, der Gesellschaft etwas zurückzugeben.
LXF: Wie sieht ein typischer Tag im Code Club aus?
CS: Ein Code Club trifft sich einmal pro Woche für eine
Stunde. Der Unterricht ist in Semester aufgeteilt, die jeweils
ein bestimmtes Ziel verfolgen. In Semester 1 lernen wir
Scratch. In Semester 2 lernen wir die tiefsten Tiefen von
Scratch und gehen dabei wirklich bis an die Leistungsgrenze
von Schülern und Lehrern. In Semester 3 behandeln wir
HTML und CSS, außerdem erklären wir die Funktionsweise
des Internets. In Semester 4 lernen wir dann Python. Mehr
Details sowie Unterrichtsmaterial zu den einzelnen
Abschnitten gibt es auf www.codeclub.org.uk/start-a-club/
volunteers unter „Term Outlines“.
Wir verlangen von unseren Lehrern, dass sie mit dem
Programmcode, den Beispielen, dem Unterrichtsmaterial,
den Handzetteln und dem Ziel einer Unterrichtsstunde bestens
vertraut sind. Jedes Code-Club-Projekt wurde mit einem
bestimmten Ziel entworfen und kann problemlos innerhalb
einer Stunde behandelt werden. Da aber jeder Club anders
ist, kann und soll die Unterrichtsstruktur von den Helfern entsprechend
angepasst werden.
PCGH: Was ist der bisher größte Erfolg?
CS: Für mich ist unser Wachstum der vergangenen zwölf
Monate der größte Erfolg: Dank unseres großen Netzwerks
von Freiwilligen haben wir über 1.000 Clubs und es werden
immer mehr.
Hilfsmittel für den Unterricht
Scratch Die derzeit wichtigste
Programmiersprache für Kinder ab 6
Jahren. Sie verwendet Befehls-
Bausteine, die visuell zu Programmen
zusammengesetzt werden.
http://scratch.mit.edu
Hackasaurus Eines von vielen
Einsteiger-Tools für JavaScript.
Hackasaurus nistet sich in Browser-
Bookmarks ein und ermöglicht die
lokale Bearbeitung fremder Websites.
Man besucht eine beliebige Webseite,
klickt auf das Bookmark und kann
sofort mit dem Programmieren
starten.
http://hackasaurus.org/en-US
PCGH: Wie kann ein Lehrer oder ein freiwilliger
Helfer einen Code Club gründen?
CS: Ein Schullehrer muss nur unsere
Webseite besuchen und seine Schule eintragen
– natürlich sollte er dies mit seinem
Chef und der Schulbehörde besprechen.
Freiwillige Helfer müssen sich zuerst mit
dem Rektor der jeweiligen Schule absprechen.
Die Schule registriert sich dann auf
unserer Webseite. Anschließend organisieren
beide gemeinsam die Räume für den
Unterricht.
Die Zukunft
Großbritannien hat gezeigt, dass es die aktuellen
Herausforderungen
erkannt hat, und
Code Academy Ein kostenloses,
webbasiertes Unterrichtssystem mit
Kursen für JavaScript, PHP, Python
und Ruby. Die Kurse sind kurz und
praxisnah.
www.codecademy.com/learn
Blender
Als Profiwerkzeug und
Unterrichtsmittel in einem bringt
Blender Kindern und Erwachsenen
Mathematik, Physik und Spieldesign
näher. Da Blender auch einen Python-
Interpreter enthält, kann man
gleichzeitig das Programmieren
lernen.
www.blender.org
„Wer unterrichten möchte,
braucht ein Führungszeugnis.“
scheint bereit, diese
anzugehen. Aber
ebenso wie in
Deutschland, wo
der Schulunterricht Sache der einzelnen Länder ist, werden
nicht Gesetze und Lehrpläne, sondern die Finanzen der einzelnen
Schulen darüber entscheiden, ob ein zeitgemäßer
IT-Unterricht möglich sein wird.
Umso wichtiger sind die privaten Initiativen von Lehrern,
Eltern und anderen Freiwilligen, den Nachwuchs in diesem
Bereich zu unterstützen. Wenn dabei Großunternehmen mit
Sachspenden und Expertenwissen ihre Hilfe
anbieten, dann ist dies nicht unbedingt eine
böswillige Werbemaßnahme: Schließlich sind es
genau diese Unternehmen, die derzeit unter
dem von unserem Bildungswesen verursachten
Fachkräftemangel leiden und nun auch unkonventionelle
Maßnahmen ergreifen, um in
zukünftige Arbeitneh mer zu investieren.
91

Coding
Raspberry Jams
Ein Erfolgsrezept
Das weltweite Netzwerk von RPi-Treffen wächst stetig.
Es bringt Fans aller Altersgruppen zusammen.
Seit Anfang 2012 ist der Raspberry
Pi auf dem Markt. Bei
seiner Einführung wurde er
enthusiastisch begrüßt. Doch
nach dem ersten Ansturm stellte sich die
Frage, wie man denn nun das Potenzial
des Rechners voll ausschöpfen könne.
In den letzten Jahren fanden deshalb in
Großbritannien mehrere Treffen rund um
den Raspberry Pi statt, die sogenannten
Raspberry Jams. Das Konzept wurde von
dem IT-Lehrer Alan O’Donohoe entwickelt.
Er setzt sich schon lange für die
Verbesserung des Computerunterrichts an
Schulen ein und hält Vorträge zu dem Thema.
Durch seinen unermüdlichen Einsatz ist er fast
„Nach dem ersten Ansturm
stellte sich die Frage, wie man
das Potenzial des Rechners
ausschöpfen könne.“
so etwas wie ein Botschafter für die Jams geworden,
ein Jambassador. Er steht in Kontakt
mit Gruppen auf der ganzen Welt, um
bessere Computerlehrgänge für Kinder zu
entwickeln. Alan arbeitet eng mit der Raspberry
Pi Foundation, Mozilla
und Google zusammen, mit
dem Ziel, dass Kinder und
Erwachsene mehr über
Computer lernen können.
Wir haben Alan und einige
Jam-Organisatoren interviewt,
weil wir mehr über das
weltweite Netzwerk der Raspberry Jams erfahren
wollten.
92

Coding
Frage: Würden Sie uns ein bisschen über sich erzählen –
für die Leser, die Sie noch nicht kennen?
Alan O’Donohoe: Ich bin der Fachbereichsleiter für Informations-
und Kommunikationstechnologie an der Our Lady’s
High School in Preston im Nordosten Englands. Dort unterrichte
ich seit zwanzig Jahren. Als Kind ist meine Familie von
Irland nach England gezogen, und als ich elf war, habe ich
meinen ersten Computer gesehen, einen BBC Micro.
Während meiner Schulzeit wussten die Lehrer nicht viel über
Computer. Als ich fragte, ob ich einen benutzen dürfte, wurde
mir gesagt, ich solle in der Pause wiederkommen, weil nur sehr
wenige Computer zur Verfügung standen. Mithilfe von Büchern
und Zeitschriften habe ich mir selbst das Programmieren
in BBC Basic beigebracht. Mir gefiel daran, dass ich einen
Computer dazu bringen konnte, das zu tun, was ich wollte.
Frage: Wie sind Sie auf die Idee mit den Jams
gekommen?
AO: Vor ein paar Jahren ist mir klar geworden, dass wir den
Computerunterricht an den Schulen ändern müssen. Ich wollte
die Informatik ins Klassenzimmer bringen. Weil ich selbst
keine Informatik studiert hatte, habe ich mich erst mal in das
Thema eingelesen und mich nach Ressourcen und Hilfsmitteln
umgeschaut. Eines der Probleme war, dass ich wegen
der starken Nutzungsbeschränkungen die nötige Software
nicht auf den Schulrechnern installieren konnte. Zur selben
Zeit hörte ich von diesem neuen Computer, diesem Raspberry
Pi. Mir wurde klar, dass ich mit dem Pi meinen Schülern
Programmieren beibringen konnte, weil die Nutzung nicht so
restriktiv war wie bei den Systemen, die wir in der Schule
benutzten.
Also startete ich an meiner Schule einen Programmier-Dojo.
So ein Dojo ähnelt einer Karate-Schule, die Schüler lernen Programmieren
mit kleinen Übungen, so wie Karateschüler mit
Katas Karate lernen. Die Übungen heißen auch Programmier-
Katas. Aus dem Dojo entwickelte sich eine viel größere Veranstaltung,
„Hack to the Future“, eine Unkonferenz für Kinder. Bei
dieser Veranstaltung saßen Macher, Hacker und Leute aus der
IT-Industrie mit den Kindern zusammen, die dabei sehr viel
übers Programmieren lernten. Und ich lernte bei „Hack to the
Future“ einiges über die Organisation solcher Events.
An dem Tag, als der Raspberry Pi auf den Markt kam,
stand ich, wie viele Leute, schon früh auf, um sofort meinen
Pi zu bestellen. Wegen der riesigen Nachfrage bekam ich
aber keinen. Aber, so dachte ich, wenn ich schon keinen Pi
bekommen hatte, dann würde ich sicher Leute treffen, die
einen hatten. Aber ich fand niemanden, der einen Pi besaß.
Da kam ich auf die Idee eines Treffens, auf dem sich Leute
gegenseitig zeigten, was sie mit ihren Raspberry Pis alles
anstellten.
Mehr Jams, überall
Jeder, der möchte, kann sein eigenes Raspberry Jam
veranstalten. Es gibt keine vorgeschriebene Struktur
– Sie können einfach das Format ausprobieren, das
Ihnen am sinnvollsten erscheint. In Manchester zum
Beispiel findet jeden Monat ein Raspberry Jam statt,
das sehr informell abläuft: der Raum und WLAN
werden gestellt, aber die Ideen kommen von den
Teilnehmern selbst. Für die Veranstalter funktioniert
das sehr gut, die Gruppe ist sehr aktiv. Das Preston
Raspberry Jam hingegen hat ein konventionelleres
Lehrformat, mit Vorträgen und Präsentationen.
Ein Jam initiieren Sie, indem Sie erst einmal
Ich war überzeugt, dass es zwei Arten von Pi-Besitzern gab
– solche, die tolle Projekte damit machten, und solche, die
ein bisschen herumprogrammierten und den Pi dann wieder
weglegten. Diese Leute wollte ich zusammenbringen. Mein
Event brauchte einen Namen, und meine Frau schlug Raspberry
Jam vor, wobei wir das Wort „Jam“ in dem Sinn benutzten
wie Musiker: ein Treffen, bei dem eine lose Gruppe
zusammen spielt.
Das erste Raspberry Jam fand in Räumlichkeiten meiner
Schule statt. Eine halbe Stunde, nachdem ich den Termin auf
Twitter gepostet hatte, waren alle 30 verfügbaren Plätze
vergeben. Als der Tag der Veranstaltung näherkam, erhielt
ich eine Anfrage aus Australien von einer Gruppe, die ein
Raspberry Jam in Melbourne veranstalten wollte. Ein paar
Tage später fragte Ben Nuttall, ob er ein Jam in Manchester
durchführen könne. Ich sagte natürlich Ja.
Frage: Welche Art von Unterstützung war wichtig für
Sie?
AO: Am Anfang hat mir Martin Bateman von der University of
Central Lancashire (UCLAN) sehr weitergeholfen. Er bot mir
einen größeren Raum an, in dem ich das Preston Raspberry
Jam abhalten konnte. Ich nahm sein Angebot begeistert an,
und beim nächsten Jam hatten wir 80 Tickets, die ebenfalls
sehr schnell ausverkauft waren. Mir wurde klar, dass die
Leute selbst für die Ausstattung sorgen mussten, damit die
Jams funktionierten. Also bat ich die Teilnehmer, ihre Projekte
mitzubringen und dazu überzählige Tastaturen, Bildschirme
und so weiter.
testen, ob in Ihrer Gegend überhaupt Interesse an
so einer Veranstaltung besteht. Fragen Sie einfach
Ihre Freunde, Kollegen und Familienmitglieder, ob
sie Lust hätten, an einem Jam teilzunehmen.
Als Nächstes brauchen Sie einen geeigneten Veranstaltungsort.
Der Ort sollte barrierefrei sein und,
wenn möglich, einen Internetzugang haben – vielleicht
stellt Ihnen eine Schule, ein Jugend- oder ein
Gemeindezentrum Räumlichkeiten zur Verfügung.
Machen Sie Ihr Event publik, posten Sie
auf Social-Media-Plattformen, versenden Sie
E-Mails und erstellen Sie, falls möglich, eine
Bilder vom
Raspberry Jam in
Manchester.
Website. Auf http://raspberryjam.org gibt es
eine Registrierungsseite, auf der Sie der Welt
mitteilen können, dass Ihr Jam stattfindet.
Fragen Sie zu Beginn des Events die Teilnehmer,
was sie tun möchten. Bringen Sie Leute, die Fragen
haben, mit Leuten, die diesen weiterhelfen,
zusammen. Als Einstieg eignen sich Scratch,
eine visuelle Programmier-Software für Kinder,
oder Infos über die GPIO-Schnittstellen. Jams
sind Orte zum Lernen und zum Austausch,
und einige spannende Raspberry-Pi-Projekte
sind bereits aus Jams hervorgegangen.
93

Coding
Eindrücke vom
sehr beliebten
Raspberry Jam in
Cambridge.
Es ist toll, wenn man endlich die nötigen Mittel hat, um ein
Jam zu organisieren. Aber die Interaktion innerhalb einer
Gruppe zu fördern und dabei zu helfen, dass Ideen Gestalt
annehmen – das ist noch viel besser. Allein für diese persönlichen
Begegnungen lohnt sich die Organisation der Jams.
Frage: Was hält die Raspberry Pi Foundation von dem
Jam-Phänomen?
AO: Die Leute dort unterstützen mich und meine Anliegen
voll, und so wie ich das sehe, profitieren alle von den Jams:
Sie tragen dazu bei, das Ziel der Foundation zu fördern, nämlich,
dass Kinder auf der ganzen Welt mit geringen Mitteln
programmieren lernen können.
Frage: Wie sehen Sie die zukünftige Rolle der Jams?
AO: Ich fände es gut, wenn mehr Raspberry Jams in den
Ferien oder an Wochenenden stattfänden. Dann könnten
mehr Kinder an den Events teilnehmen. Ich wünsche mir,
dass Leute, die normalerweise nicht zu einer Computerveranstaltung
gehen, mitkommen und es ausprobieren. Dass in
der ganzen Welt mehr Jams stattfinden, auch in ländlichen
Gegenden. Wenn es bei Ihnen noch kein Jam gibt, dann starten
Sie eins! Jeder kann ein Jam organisieren, sogar Kinder,
wobei die aber ihre Eltern oder einen Lehrer um Unterstützung
bitten sollten, damit alles problemlos abläuft. Die Jams
können jedes mögliche Format haben – von der kleinen
Hacker-Runde bis zu einer großen Konferenz.
Jedes Jam ist anders
Wir haben an einigen Jams in Großbritannien teilgenommen,
und zwar in Cambridge, Manchester und York. Alle
sind sehr unterschiedlich abgelaufen. Das Cambridge
Jam im Juli 2012 war eine sehr formelle Veranstaltung.
Es fand in einem Hörsaal statt, und Leute von der Raspberry
Pi Foundation hielten Vorträge. Die Veranstalter
der drei populärsten Jams haben wir interviewt: Michael
Horne aus Cambridge, Ben Nuttall aus Manchester und
Jack Wearden vom Birmingham Raspberry Jam.
Frage: Wer kommt zu Ihrem Raspberry Jam?
Ben Nuttall: Eine ganze Bandbreite von Leuten nehmen an
den Jams teil, Eltern, Kinder, Lehrer, Hobbyelektroniker mittleren
Alters und Technikfreaks zwischen 20 und 40. Manche
Leute bringen ihre Kinder mit, damit diese etwas über Computer
erfahren, weil ihnen das, was sie darüber in der Schule
lernen, nichts bringt. Und die Kinder kommen dann oft wieder
mit Freunden oder dem Rest der Familie.
Jack Wearden: Bei uns waren schon alle möglichen Leute,
von Eltern und Kindern bis zu Linux-Profis und einmal sogar
ein Herzchirurg.
Michael Horne: Bei dem letzten Jam haben vor allem
Erwachsene teilgenommen, aber altersmäßig war das sehr
gemischt, von Studenten bis zu älteren Leuten, die sich hobbymäßig
für Computer interessieren.
Frage: Was waren Ihre Beweggründe, Ihr erstes Jam zu
veranstalten?
BN: Ich habe mir sofort einen Raspberry Pi bestellt, gleich
morgens an dem Tag, als er offiziell auf den Markt kam. Und
ich habe bei MadLab angefragt, ob es eine Gruppe für Raspberry-Pi-User
gebe. Dort hat man mir vorgeschlagen, doch
selber eine zu gründen – und das habe ich gemacht. Das
erste Jam war eigentlich als einmaliges Event geplant, aber
die Leute wollten weitermachen, und da habe ich noch ein
Jam organisiert. Die Treffen kamen gut an, also erklärte ich
mich bereit, weiter welche zu organisieren, solange genug
Leute kommen. Bis jetzt hat das Interesse nicht
nachgelassen.
JW: Ich wollte vor allem das Gemeinschaftsgefühl der Raspberry-Pi-User
in ein akademisches Umfeld holen. Und den
jüngeren Teilnehmern sollte das Jam Einblicke in das Programmieren
auf Uni-Niveau geben.
MH: Ich war beim Milton Keynes Jam dabei und wollte unbedingt
eines näher an meinem Wohnort organisieren. Cambridge
war der logische Ort dafür, weil dort der Pi ja sozusagen
auf die Welt gekommen ist.
Frage: Wie häufig treffen Sie sich?
BN: Wir treffen uns monatlich, gewöhnlich an einem Samstag.
Der genaue Termin hängt davon ab, ob die Räume im
MadLab verfügbar sind, vor allem seit wir wegen der großen
Ressourcen für Ihr Raspberry Jam
Es gibt eine ganze Menge Ressourcen, die Sie
bei der Organisation eines Jams nutzen können.
Allerdings sollte sich das Format der Veranstaltung
nach den Bedürfnissen der Teilnehmer
richten, und richtig sinnvoll ist ein Jam nur dann,
wenn die Leute ihre Kenntnisse untereinander
austauschen können. Hier eine Auswahl relevanter
Websites:
http://raspberryjam.org Hier können Sie Ihr
Raspberry Jam registrieren, Ihre eigene Webseite
für das Jam erstellen, und Sie er halten News von
anderen Gruppen weltweit.
http://www.raspberrypi.org/forums Interessant
für Sie sind die Bereiche User Groups und
Events. Hier finden Sie jede Menge Infos über
Events auf der ganzen Welt, mit vielen Kommentaren
und Ideen.
http://learn.adafruit.com Eine großartige
Seite übers Hardware-Hacken, mit Arduinound
Raspberry-Pi-Projekten und Übungen zu
Elektronik-Grundkenntnissen.
http://codecademy.com/tracks/python
Auf dieser Seite finden Sie einige sehr gute
Python-Übungen, mit denen aus einer Gruppe
von Anfängern Experten werden können.
http://scratch.mit.edu Scratch ist ein
geniales Programm zur Einführung ins Programmieren
für Anfänger und Kinder.
http://raspberrycenter.de Eine deutschsprachige
Seite für Pi-Fans.
94

Coding
Nachfrage beide Stockwerke belegen!
JW: Wir haben uns einmal getroffen, und ein zweites Jam ist
geplant – die zeitliche Organisation um die Uni-Veranstaltungen
herum ist nicht ganz einfach. Aber wir hoffen, dass wir
Anfang des nächsten Semesters wieder ein Jam abhalten
können.
MH: Das Jam im Mai 2013 war das erste, das ich organisiert
habe und das erste in Cambridge nach über einem Jahr. Wir
haben uns noch nicht für einen festen Veranstaltungsort entschieden.
Ich hoffe, wir können die Jams immer auf Samstagnachmittage
legen, denn für die meisten Leute und vor
allem für Familien ist das die beste Zeit.
Vortrag über die Portierung von KI-Software für den Raspberry
Pi. Es ging darum, wie Software, die Künstliche Intelligenz
nutzt, auf verschiedenen Plattformen funktioniert –
oder auch nicht funktioniert.
MH: Mein erstes Projekt war der Versuch, einen Tricorder
(ein Gerät aus Star Trek) zu bauen. Im Grunde besteht er aus
ein paar Sensoren, die der Pi und ein Arduino auslesen, und
das Ergebnis wird in einem zweizeiligen LCD-Display angezeigt.
Die zweite Version ist eine Weiterentwicklung ohne
den Arduino, ein reiner Picorder. Und mein zweites Projekt ist
ein Schwenk- und Neigemechanismus für die offizielle Kameraplatine,
der über ein Browser-Interface gesteuert wird.
Das Raspberry
Jamboree ist
ein großes,
jährlich stattfindendes
Event,
auf dem es um
den Einsatz des
Raspberry Pi im
Schulunterricht
geht.
Frage: Welches Format hat Ihr Jam?
BN: Das ist in der Regel nicht vorgegeben, aber meistens
wollen die Leute hacken, weshalb wir auf dem Jam dann
genau das tun. Ein paar Neueinsteiger tauchen immer auf,
und da ist es wichtig, dass alle mit einbezogen werden. Es
finden immer irgendwelche Projekte statt, und Neuankömmlinge
können auch in ein Projekt einsteigen, an dem
eine Gruppe bereits arbeitet. Bei unserem großen Jubiläums-
Jam habe ich für die beiden Tage Vorträge und Vorführungen
organisiert, die im oberen Stockwerk standfanden – Scratchund
Python-Workshops, Robotik-Sessions, Kameramodul-
Einführungen sowie kurze Vorträge über Raspbian, Wetterstationen
und eine Einführung in Linux.
JW: Wir stellen zwei Räume zur Verfügung, einen Raum fürs
Hardware-Hacken und einen für Vorträge. Nach einem Einführungsvortrag
können die Teilnehmer entweder hacken,
oder sie stellen ihre Raspberry-Pi-Projekte in Referaten und
Vorführungen vor.
MH: Unser letztes Jam war in vier Sitzungen aufgeteilt. Zwei
Sitzungen waren Vorträge und Vorführungen vorbehalten,
die beiden anderen lockeren Präsentationen, bei denen sich
die Teilnehmer kennenlernen und ihre mitgebrachten Projekte
zeigen konnten.
Frage: Welche Projekte haben Sie oder Ihr Jam
entwickelt?
BN: Zuerst habe ich meinen Raspberry Pi nur als Medienzentrum
verwendet und um Python zu unterrichten, aber vor
Kurzem habe ich eine Wetterstation für die BBC gebaut. Ein
bisschen experimentiere ich mit dem Kameramodul herum,
und ich erkläre den Kids mit dem Pi, wie Webserver funktionieren.
Bei mir auf der Arbeit haben wir einen Raspberry Pi als
Fileserver und als gemeinsam genutzten Datenbankserver.
Als eines meiner nächsten Projekte will ich mir auf dem Pi
eine Offline-Bitcoin-Wallet einrichten. Und ich möchte in
Zukunft mehr mit GPIO machen.
JW: Ein Informatik-Professor hielt bei uns einen spannenden
„Ich bin wahnsinnig gerne
auf einem Jam. Da herrscht
eine tolle Atmosphäre.“
Frage: Was würde Sie gerne auf den nächsten Jams
machen?
BN: Das, was wir jetzt machen! Ich bin wahnsinnig gerne auf
einem Jam. Da herrscht eine tolle Atmosphäre, die Leute
haben Spaß, egal wie alt sie sind oder wie viel Erfahrung sie
mit dem Pi haben. Auf den ersten Events war es schwierig,
Vorträge zu organisieren, weil alles noch so neu war, für alle.
Aber jetzt gibt es so viele Projekte, die man vorstellen kann.
Bei unserem Jubiläums-Jam sind die Vorträge gut angekommen,
deshalb organisiere ich vielleicht für die nächsten Jams
etwas ähnliches – vielleicht
abwechselnd nur
Vorträge und nur Zeit zum
Hacken.
JW: Beim nächsten Jam
wollen wir uns mit Ressourcen
für Schulen beschäftigen.
Wir hoffen, dass wir geeignetes Material zusammenstellen
können, das es Lehrern leichter macht, die
Möglichkeiten des Pi im Unterricht zu nutzen.
MH: Ich möchte einmal ein richtig großes Jam in Cambridge
veranstalten, so wie das Manchester Jamboree, das vor
kurzem stattfand – mit Praxis-Workshops für junge Programmierer,
die an diesem Tag an ihren Projekten arbeiten.
Die Zukunft der Raspberry Jams
Die Jams sind nicht mehr aus der Raspberry-Pi-Welt wegzudenken.
Sie sind eine Institution geworden, ähnlich wie die
Linux-Usergruppen. Das offene Format der Events schafft
eine großartige Lernatmosphäre, und der Erfahrungsschatz,
der bei den Jams zusammenkommt, ist
unbezahlbar.
Auch im deutschsprachigen Raum haben bereits
erste Raspberry Jams stattgefunden, wenngleich der
Schwerpunkt bisher deutlich auf den englischsprachigen
Ländern liegt. Termine und Informationen sind auf
http://raspberryjam.org zu finden.
95

Coding
Geany: Editor de
Das perfekte Schreibprogramm für Programmierer: Jahrelang haben wir
danach gesucht, jetzt sind wir endlich fündig geworden.
Code schreiben ist eine sehr persönliche Sache. Jeder
hat seine Lieblingsprogramme und seine bevorzugten
Techniken und Herangehensweisen, wie man einen
Code schreibt, der gut funktioniert. Code schreiben ist fast so
etwas wie Zen-Meditation, und Hunderte von Büchern sind
darüber verfasst worden. Deshalb werden wir uns davor
hüten, Ihnen weismachen zu wollen, unsere Herangehensweise
wäre die beste.
Doch eigentlich geht es bei allen Debatten darum, ob als
Fenster, in dem der Code geschrieben wird, eine IDE, also
eine integrierte Entwicklungsumgebung, oder ein Editor verwendet
wird. Es ist interessant, dass neue Programmierer,
die gerade erst anfangen, sich oft für die IDEs aussprechen.
Sie halten IDEs vor allem deshalb für unverzichtbar, weil
damit mehr Leute neue Apps schreiben können. Viele erfahrene
Hacker dagegen bevorzugen Editoren, die überflüssigen
Programmcode vermeiden und mit denen sie sich direkt der
eigentlichen Programmierung widmen können. Wir sehen
Vorteile und Nachteile in beiden Argumenten. Es ist eine persönliche
Entscheidung, und keine der beiden Seiten hat letztendlich
recht.
Doch wir wollen Ihnen zumindest einen Editor vorstellen,
für den Sie sich mit vollster Überzeugung entscheiden können,
und dieser Editor heißt Geany. Er braucht so wenig
Strom und Speicherplatz, dass Sie ihn direkt auf Ihrem Raspberry
Pi laufen lassen können. Meistens ist er schon auf dem
Gerät vorinstalliert, und er sollte in allen Paketmanagern enthalten
sein.
Einfach und leistungsstark
Im Grunde ist Geany ein Texteditor, den man aufgebockt und
hochfrisiert hat mit all den schönen Dingen, von denen Programmierer
schwärmen. Geany ist weder eine IDE noch ein
normaler Texteditor – er ist ein Editor, der alle wichtigen
Funktionen hat, die man sich von einer IDE wünscht. Geany
versucht gar nicht erst, all die Assistenten, Einsteiger-Templates
und anderen Elemente einzubinden, die man für gewöhnlich
in einer IDE findet. Aber er bietet die Hauptfunktionen,
die man braucht, um Apps zu schreiben, darunter einen
guten Editor, einen Klassen-Navigator und Code-Folding.
Damit ist Geany die zurzeit beste Wahl für alle Hobby- und
Profiprogrammierer, die Apps in Linux schreiben.
Geany wurde mit dem GTK-Widget-Set geschrieben, deshalb
lässt er sich problemlos in die meisten Desktop-Umgebungen
integrieren, wenn Sie mit dem Pi selbst programmieren.
Software-Pakete sind im Ubuntu Software Centre
erhältlich, im Everything-Repository von Fedora. Für Debian,
Gentoo, OpenSUSE, Arch Linux, Centos, RHEL, ALT Linux,
SourceMage und Crux können Pakete hier heruntergeladen
werden: www.geany.org/Download/ThirdPartyPackages.
Integrierter Support existiert für alle möglichen Programmiersprachen,
darunter (O)Caml, Ada, Assembler, C, C#,
C++, COBOL, Cython, D, Fortran, FreeBasic, Genie, GLSL,
Haskell, Haxe, Java, Objective C, Pascal, Scala, Vala, VHDL
und Verilog. Und Geany unterstützt auch Skript- und Auszeichnungssprachen
wie ActionScript, CMake, Erlang, Ferite,
Forth, Javascript, LISP, Lua, Makefile, Matlab, NSIS, Perl,
PHP, Python, R, Ruby, Shell, Tcl, CSS, DocBook, HTML,
LaTeX, Markdown, reStructuredText, Txt2Tags und XML. Als
zusätzliches Extra gibt es auch einen guten Support für Abc-,
Config-, Diff-, Gettext-, SQL-, und YAML-Dateien. Andere Programmiersprachen
können ebenfalls mit Geany verwendet
werden, allerdings ohne automatische Syntaxhervorhebung
und andere Funktionen.
In diesem Artikel nehmen wir Sie mit auf eine Tour durch
Geany und schauen uns viele seiner Funktionen genauer an.
Zu Illustrationszwecken erstellen wir ein neues Projekt, für
das wir Code schreiben und an dem wir Ihnen beispielhaft
zeigen, wie Sie die verschiedenen Anwendungen und Konfigurationsoptionen
je nach Programmiererfahrung an Ihre Bedürfnisse
anpassen können.
Wir schreiben die Code-Beispiele in Python, aber Sie
können jede Sprache verwenden, die Sie wollen. Und jetzt
geht’s los.
Das Interface
Starten Sie Geany. Es erscheint ein Interface ähnlich wie in
Abb. 1. Das Interface besteht aus drei Hauptfenstern. Links
ist der Browser. Hier können Sie schnell die verschiedenen
Dateien, Klassen, Funktionen sowie andere Symbole finden,
die zu Ihrem Projekt gehören. Wir werden uns später, wenn
96

Coding
luxe
wir unseren Code schreiben, genauer damit befassen.
Rechts ist der Haupt-Texteditor. Hier werden Sie die meiste
Zeit verbringen. Ähnlich wie bei anderen modernen Texteditoren
können Sie mehrere Dateien gleichzeitig öffnen und
sie über die zugehörigen Registerkarten aufrufen.
Unterhalb des Texteditors ist das Meldungsfenster. Hier
finden Sie den Output Ihres Compilers/Interpreters, Fehlermeldungen
und andere nützliche Funktionen, etwa für Notizen,
und eine Anzeige der Schritte, die Sie bei Ihrem Projekt
noch durchführen müssen.
Am oberen Rand des Monitors sehen Sie die Menüleiste
(bei Ubuntu fügt sich das Menü wie bei den meisten anderen
Programmen in das obere Feld ein), dort finden Sie auch
Symbolleisten mit den gebräuchlichsten Funktionen des
Texteditors. Die Symbolleisten können Sie ebenfalls nach
Ihren Wünschen anpassen. Um sie zu ändern, klicken Sie mit
der rechten Maustaste auf die Symbolleiste und wählen Sie
„Toolbar Preferences“. Klicken Sie dann auf den „Customize
Toolbar“-Button, worauf der Symbolleisten-Editor erscheint.
Wählen Sie einfach die Funktionen links aus und klicken Sie
auf den Pfeil rechts, um sie zur Symbolleiste hinzuzufügen.
Code schreiben
Und damit sind wir soweit und können endlich ein neues Projekt
erstellen. Klicken Sie auf Project > New. Es öffnet sich ein
Dialogfenster. Geben Sie einen Namen für Ihr Projekt ein und
klicken Sie dann auf Create. Jetzt können wir ein paar Einstellungen
für das Projekt vornehmen. Klicken Sie dazu auf Project
> Properties. Die Registerkarte Indentation („Einrückung“)
ist ein guter Anfang. Hier können Sie einstellen, wie
Tabs/Leerstellen verwendet werden. Das ist besonders praktisch
für Python-Entwickler, die sowohl an Projekten arbeiten,
bei denen Tabs benutzt werden, als auch an Projekten, die
Leerstellen benutzen.
Wenn Sie an einem Projekt arbeiten, das einen Compiler
benötigt (wie etwa eine C/C++-App), können Sie auch über
die Registerkarte Build die Befehle einstellen, um das Projekt
zu erstellen. Dabei geben Sie einfach die Befehle und Ihr
Die Top Ten der Geany-Funktionen
Zehn Gründe, warum Sie Geany auf
jeden Fall ausprobieren sollten:
1 Einfache Handhabung Geany ist
einfach zu bedienen und fügt sich gut
in alle Programmier-Projekte ein.
2 Code-Navigation Funktionen
und Klassen in einem Code-Netz
sind mit dem Klassen- und Datei-
Browser leicht zu finden.
3 Sprachen-Support und Syntaxhervorhebung
Geany unterstützt
viele Programmiersprachen, darunter
C, C++, Python, PHP, Perl, Ada,
Java, Ruby, Tcl, HTML und CSS.
4 Auto-Vervollständigung von
Symbolnamen Sie erinnern sich
nicht an die Funktion, die Sie
brauchen? Geany schlägt Ihnen
Funktionen vor, mitsamt der
Argumente, die sie enthalten.
5 Automatisches Schließen von
XML- und HTML-Tags Wenn Sie HTML
und XML schreiben, macht die Vervollständigungsfunktion
von Endtags es
einfacher, Text fehlerfrei auszuzeichnen.
6 Code-Folding Code-Absätze,
an denen Sie nicht arbeiten, blenden
Sie mit dieser einfach zu
bedienenden Funktion aus und ein.
7 Plug-ins Es gibt etliche Komponenten
aktuelles Verzeichnis für die Programmierung ein. Wir gehen
so allerdings nicht vor, weil wir für dieses Beispiel Python
verwenden.
Wahrscheinlich ist Ihnen inzwischen schon aufgefallen,
dass beim Klicken auf Create Project kein Assistent erschienen
ist, der Ihnen Optionen anbietet, um Ihre App zu entwickeln
und darzustellen. Wie schon gesagt, Geany ist nicht
wirklich eine IDE, und deshalb gibt es hier auch keinen Assistenten.
Um Ihre App zu erstellen, müssen Sie ein anderes
Programmierwerkzeug verwenden, beispielsweise Quickly,
und dann kopieren Sie die Dateien in das Projektverzeichnis
von Geany.
Für unser Projekt erstellen Sie eine neue Datei, indem Sie
auf File > New (with Template) > main.py klicken. Dadurch
wird eine Python-Datei erstellt, die bereits Code enthält, darunter
einen Kommentar mit der mitgelieferten Lizenz sowie
den Standardcode, um die main()-Python-Funktion zu instanziieren.
Klicken Sie jetzt auf File > Save As, und speichern
Sie die Datei als app.py. Nun fügen wir das berühmte „Hello
World!“ in main() ein, damit wir etwas drucken können, wenn
wir das Programm ausführen.
print “Hello World!”
Speichern Sie die Datei und führen Sie sie aus. Sie können
die Programmdatei in Geany laufen lassen, indem Sie zuerst
auf die Terminal-Registerkarte im Output-Fenster unten klicken.
Wechseln Sie dann in das Verzeichnis mit dem Programm
(in unserem Beispiel ist das /home/jono/projects/
Super App/) und führen Sie dieses aus:
cd projects/Super App
python app.py
(Plug-ins) von anderen Anbietern für
Geany, mit denen man die Funktionen
des Texteditors erweitern kann.
8 Task-Support Geany zeigt alle
TODO und FIXME-Kommentare an
einem Ort an, so dass sie leichter ausgeführt
und korrigiert werden können.
9 Eingebettetes Terminal In dem
eingebetteten Terminal können Sie Teile
Ihres Codes in einem Interpreter testen
und Dateien einfach und schnell finden.
10 Debugger-Support Der integrierte
Debugger vereinfacht die
Suche nach Fehlern und problematischen
Stellen im Code.
Abb. 1 Der
Geany-Texteditor
ist einfach und
übersichtlich.
97

Coding
Abb. 2 Mit den
Funktionen von
Geany sind auch
große Projekte
einfach zu
handhaben.
Auf Ihrem Bildschirm sollte jetzt „Hello World!“ erscheinen.
Schauen wir uns nun kurz an, wie wir uns mit Geany einfacher
durch den Code bewegen können.
Klicken Sie im Browser auf der linken Seite auf die Registerkarte
Symbols. Diese Registerkarte werden Sie noch sehr
oft verwenden, um Code-Abschnitte zu finden. Wie Sie jetzt
schon sehen können, zeigt die Registerkarte unsere main()
-Funktion. Wenn Sie jetzt noch auf die Registerkarte Documents
klicken, dann sehen Sie auch unsere einzige Quelldatei.
Doch richtig deutlich wird die Nützlichkeit dieser Registerkarte
dann, wenn Sie mit vielen Quelldateien arbeiten.
Wenn Sie die main()-Funktion in der Symbols-Registerkarte
klicken, erscheint ein kleiner Pfeil am Rand des Editors, der auf
die Funktion hinweist. Ebenfalls im Editor erscheint neben
jedem Code-Block ein kleines weißes Kästchen mit einem -
darin. Mit diesem kleinen Kästchen können Sie Teile des
Codes „wegfalten“, die gerade nicht von Interesse sind. Wenn
Sie in das Kästchen klicken, verwandelt sich das - in ein + Symbol
als Hinweis, dass hier ein Code-Block ausgeblendet ist.
Wir wollen jetzt eine Klasse erstellen, um Ihnen noch einmal
zu zeigen, wie einfach Geany die Navigation in Ihrem
Code macht. Fügen Sie den folgenden Code zu Ihrem Programm
hinzu:
class MyClass:
def __init__(self):
print “Creating a MyClass object”
def show_info(self):
print “This class is MyClass”
def foo(self, value):
print “You provided me with %s “ % value
if __name__ == ‘__main__’:
obj = MyClass()
obj.show_info()
obj.foo(5)
In diesem Code erstellen wir eine einfache (und ziemlich
nutzlose) Klasse. Beachten Sie, dass wir die main()-Funktion
entfernt haben. Sie ist nicht mehr erforderlich.
Während Sie den Code geschrieben haben, ist Ihnen vielleicht
aufgefallen, dass die kleinen weißen Code-Folding-
Kästchen automatisch neben jeder neu hinzugefügten Klassen-Funktion
aufgetaucht sind. Geany denkt mit und versteht
den Code, den Sie schreiben. Der Editor wendet solche Funktionen
automatisch an und wartet nicht, bis Sie einen Absatz
zu Ende geschrieben oder die Datei gespeichert haben.
Wahrscheinlich ist Ihnen noch eine weitere Funktion aufgefallen:
Wenn Sie Ihre Klassen-Funktionen aufrufen (wenn Sie
also obj eintippen und dann den Funktionsnamen), springt in
Geany ein kleines Fenster auf, in dem Funktionen aufgelistet
werden, die dem Code entsprechen, den Sie bis jetzt geschrieben
haben. Das ist ein unglaublich nützliches Hilfsmittel,
und Geany schlägt oft sogar Funktionsnamen für unterschiedliche
APIs vor, die Sie verwenden.
Nachdem wir die Klasse zu unserem Programm hinzugefügt
haben, schauen Sie sich die Registerkarte Symbols im
Browser links im Fenster an. Sie sehen, dass hier neben unserer
erstellten Klasse ein kleines blaues Icon erscheint. Die
Funktionen innerhalb der Klasse werden als Teil der Klassenhierarchie
angezeigt. Für eine kleine Anwendung wie diese
bringt die Klassenansicht nicht viel, aber bei einer großen Anwendung,
wie zum Beispiel die in Abb. 2, ist dieser Klassen-
Navigator extrem hilfreich, wenn Sie etwas suchen und in der
Codebasis hin- und herspringen müssen.
Konfiguration
Einer der Hauptunterschiede zwischen einer IDE und einem
Editor liegt in den unterschiedlichen Konfigurationsmöglichkeiten.
Viele IDEs bieten eine Anzahl sinnvoller Standardeinstellungen
und erlauben darüber hinaus nur eingeschränkte
Konfigurationsänderungen, damit die IDE für die User nicht
zu kompliziert wird. Editoren hingegen besitzen nicht die
komfortable Frontend-Handhabung der IDEs, doch bei den
meisten können viel mehr Funktionen nach Bedarf konfiguriert
werden. Das gilt auch für Geany.
Geany bietet geradezu fantastische Konfigurationsmöglichkeiten
für alle möglichen Aspekte des Programmierens.
Sie können Geany in zwei Bereichen konfigurieren:
1 Edit > Preferences – hier konfigurieren Sie die Anwendung
an sich.
2 Edit > Plugin Preferences – hier konfigurieren Sie zusätzliche
Komponenten bzw. Plug-ins (mehr zu Plug-ins
später).
Schauen wir uns ein paar Elemente von Geany (ohne zusätzliche
Plug-ins) an, die Sie vielleicht konfigurieren
möchten.
Zuerst konfigurieren wir einmal die Information, die an die
Header-Kommentare angefügt wird, wenn Sie eine neue
Datei zu Ihrem Projekt hinzufügen. Klicken Sie Edit > Preferences
> Templates, dann sehen Sie die verschiedenen Felder,
die Sie ändern können. Geany füllt automatisch viele der
Felder für Sie aus, doch einige der Informationen wollen Sie
wahrscheinlich ändern.
In einigen Feldern steht etwas, das nach Zeichensalat aussieht,
zum Beispiel %Y-%m-%d im Datumsfeld. Dies sind
Codes, die wie Templates funktionieren und etwa wie hier
das Format der Datumsanzeige festlegen. %Y-%m-%d wird
als 2012-12-25 angezeigt. (%Y bedeutet 2012, %m 12 und
%d 25). Eine Liste all dieser Codes und ihrer Funktionen finden
Sie hier: http://man.cx/strftime.
Für viele Programmierer gehören die Tastaturbelegungen
zu den wichtigsten Funktionen, die sie selbst nach ihren Wünschen
einstellen möchten. Programmieren ist eine Kunst und
eine Wissenschaft, die ihren eigenen Takt und Rhythmus
Plug-ins
Einer der Riesenvorteile von Geany ist die große Anzahl von
Plug-ins von anderen Anbietern, die Sie installieren können.
Viele dieser Plug-ins sind schon in Ihrem jeweiligen Paketmanager
enthalten (wie im Ubuntu Software Centre oder über
yum). Sie finden aber auch bei http://plugins.geany.org
Informationen über Plug-ins.
98

Coding
Versionskontrolle?
Eine der häufigsten Fragen ist, ob Geany einen integrierten
Support für Git, Bazaar, Subversion, CVS und
andere Versionskontrollsysteme hat. Standardmäßig
unterstützt Geany diese Systeme nicht, doch auch
dafür es gibt ein Plug-in. Mehr Informationen finden
Sie auf http://plugins.geany.org/geanyvc.html.
braucht. Wenn man „drin“ ist, dann möchte man den Rhythmus
nicht unterbrechen, weil sonst die Produktivität im
Code-Schreiben beeinträchtigt wird. Das ist einer der Gründe,
warum die meisten von uns schon ganze Nächte durchgehackt
haben, weil sie nämlich den Programmierfluss nicht
stören wollten.
Nichts unterbricht den Fluss so sehr wie die Verwendung
der Maus. Bewegt man die Hände weg von der Tastatur zur
Maus und wieder zurück, wird man automatisch langsamer.
Tastaturbelegungen sind daher wichtig, um den Programmierfluss
aufrechtzuerhalten. Wenn Sie noch nie Tastaturbelegungen
benutzt haben, dann wird es Zeit, dass Sie sie lernen.
Zum Glück können Sie in Geany fast jede
Tastenbelegung selbst konfigurieren. Klicken Sie auf Edit >
Preferences und dann auf die Registerkarte Keybindings.
Ein anderer Bereich für die Konfiguration ist der eigentliche
Editor. Ein Texteditor scheint eigentlich eine simple Sache zu
sein – man gibt Text ein –, doch die Leute verwenden Texteditoren
auf ganz unterschiedliche Weise. Einzüge, Syntaxhervorhebung,
Zeilennummerierung, automatischer Zeilenumbruch,
Zeilenvorschub und überflüssige Leerzeichen,
Codevervollständigung und andere Funktionen sind dabei für
die User interessant.
Um einzustellen, welche Teile des Editors sichtbar sind
und welche nicht, klicken Sie auf View > Editor.
Wir empfehlen, dass Sie auf jeden Fall die Zeilennummerierung
einschalten. Vor allem, wenn Sie mit anderen Programmierern
zusammenarbeiten, ist es sehr hilfreich, wenn
Sie die Nummer der Zeile benennen können, in der Sie ein
Problem sehen. Sie können über View > Editor > Color Scheme
auch eine andere Farbgebung auswählen, falls Sie etwa
ein dunkleres Schema bevorzugen. Weitere Farbschemata
finden Sie unter www.geany.org/Download/
Extras#colors.
Tasks ausführen
Üblicherweise fügt man beim Programmieren Kommentare
zum Code dazu, mit Hinweisen, was in einem bestimmten
Absatz noch verbessert werden soll. Wenn beispielsweise
eine bestimmte Funktion eingeschränkt ist, dann können Sie
das Folgende zum Code hinzusetzen:
#TODO: Expand this to include support for XYZ.
Alternativen zu Geany
» Eclipse bereitete den Weg für die heutigen
IDEs. Das plattform- und sprachenübergreifende
Tool wurde zum Schreiben kommerzieller
Anwendungen entwickelt. Es ist
kompliziert und nicht sehr benutzerfreundlich,
unterstützt aber viele Programmiersprachen.
» KDevelop gehört zu den frühesten IDEs,
die speziell für eine Desktop-Umgebung
kreiert wurden. Es ist vor allem für KDE-
Programmierer gedacht und bietet eine
Sie können auch einen Kommentar neben ein Stück Code
schreiben, das noch korrigiert werden muss. Das sieht dann
oft so aus:
#FIXME: Make this thread-safe.
Das Problem an diesen kurzen Notizen ist, dass sie sich oft
kaum wiederfinden lassen, wenn man sie vor der Freigabe
des Codes bearbeiten möchte.
Zum Glück besitzt Geany eine praktische kleine Funktion,
mit der Sie sich alle diese Notizen gesammelt an einem Ort
ansehen können. Es wird sozusagen eine TODO-Liste erzeugt,
auf der all die Dinge stehen, um die Sie sich noch kümmern
müssen. Benutzen Sie einfach TODO und FIXME,
genau wie oben beschrieben, und stellen Sie unter Edit > Plugin
Preferences > Addons die Funktion „Show available tasks
in the Message window“ ein. Sie können dafür auch andere
Begriffe als TODO und FIXME definieren, wenn Sie das wollen,
doch TODO und FIXME sind sehr gebräuchlich, deshalb
ist es sinnvoll, wenn Sie diese Standardeinstellung belassen.
Geany ist ein kleiner und doch ungemein leistungsstarker
Texteditor, der Ihnen alle wichtigen Werkzeuge bietet, die Sie
brauchen, um Code zu schreiben. Die Entwickler von Geany
haben sich auf eine einfache Handhabung und auf die Bedürfnisse
von ernsthaften Programmierern konzentriert und
das Programm nicht mit Schnickschnack überfrachtet, den
die meisten Programmierer gar nicht brauchen.
Deshalb hat man das Gefühl, einen ausgereiften Texteditor
an der Hand zu haben. Und mit den vielen Konfigurationsmöglichkeiten
und der großen Auswahl an zusätzlichen Plugins
können Sie Geany auf Ihre individuellen Bedürfnisse
zuschneiden.
Geany ist ein leicht zu lernender Editor; in diesem Artikel
stehen schon die wichtigsten Dinge, die Sie wissen müssen,
damit Sie loslegen können. Wir empfehlen, dass Sie den Code
auf Ihrem Desktop-Rechner schreiben und ihn dann auf den
Raspberry Pi portieren. Doch es funktioniert genauso, wenn
Sie alles auf dem Pi machen. Happy programming trails!
umfassende Auswahl an Funktionen.
» GEdit könnte man auf den ersten Blick für
einen einfachen Texteditor halten, doch es
gibt eine ganze Reihe von Plug-ins und Erweiterungen,
mit denen sich GEdit in etwas verwandeln
lässt, das eher wie Geany aussieht.
» Qt Creator ist eine IDE, die speziell für Qtund
QML-Apps entwickelt wurde. Man kann
mit ihr nicht nur Code schreiben, sondern auch
Schnittstellen erstellen, Dokumentationen
Abb. 3 Geany
bietet eine großartige
Auswahl
von sinnvollen
Standardeinstellungen.
durchstöbern und mehr. Wenn Sie Qt-Apps
schreiben, empfehlen wir den Qt Creator.
» Anjuta ist das Produkt einer langen
Entwicklungsgeschichte. Diese große IDE
wurde für das Schreiben von Gnome-
Anwendungen entwickelt, unterstützt
aber auch andere Anwendungsarten.
» Bluefish ist ein genialer Editor, wenn
Sie nur Web-Content in HTML, PHP
oder Python erstellen möchten.
99

Coding
Code-Konzepte:
Datentypen
Die Auswahl
eines falschen
Datentyps in
einem Programm
kann Probleme
verursachen. In
diesem Fall erhalten
Sie einen
TypeError.
Funktionen sagen Programmen, was sie tun sollen, aber es sind
Daten, mit denen sie dies tun. Sehen wir uns also die Daten bei
Python an.
In diesem Artikel behandeln wir die Basisdatentypen bei
Python sowie die Konzepte, die mit ihnen einhergehen.
Auf den nachfolgenden Seiten sehen wir uns dann einige
weiterführende Themen an, die auf dem aufbauen, was wir
hier machen: Datenabstraktion, schicke Strukturen wie etwa
Bäume und anderes.
Was sind Daten?
Die Programme, die wir schreiben, enthalten eine Vielzahl
von Datentypen. In einen Zinsrechner sind beispielsweise der
Zinssatz, die Laufzeit des Kredits sowie die Höhe des Kredits
jeweils Datentypen; in einem Einkaufslisten-Programm gibt
es alle möglichen Arten von Essen sowie die Liste, in der sie
gespeichert sind. Der Computer kennt jedoch nicht den Unterschied
zwischen all diesen Datentypen. Er kann nur mit ein
paar ganz grundlegenden Datentypen etwas anfangen, und
als Programmierer muss man diese kreativ einsetzen, um
damit die Vielfalt der realen Welt abzubilden.
Wir beginnen mit drei Datentypen. Zunächst einmal haben
wir Zahlen. 3, 10 und 2580 sind Beispiele dieses Datentyps.
Um genau zu sein, sind das Integer-Werte (ganze Zahlen),
auch „ints“ genannt. Python kennt noch andere Arten von
Zahlen, beispielsweise „long“ (lange Integer), „float“ (Fließkommawerte
wie 10,35 oder 0,8413) und „complex“ (komplexe
Zahlen). Zweitens gibt es Strings wie etwa ’Hello
World’, ’Banane’ oder ’Pizza’. Hierbei handelt es sich jeweils
um eine Sequenz von Zeichen, die in einfachen oder doppelten
Anführungszeichen stehen. Unser dritter Datentyp sind
Listen wie zum Beispiel [’Banane’, ’Orange’, ’Himbeere’].
Listen ähneln Strings, jedenfalls unter dem Gesichtspunkt,
dass sie Sequenzen darstellen. Was beide Datentypen unterscheidet,
ist, dass in einer Liste jedes Element einem anderen
Typus angehören kann. Im obigen Beispiel sind alle Elemente
Strings, aber Sie könnten auch eine andere Liste anlegen,
welche die verschiedenen Datentypen mischt, wie etwa
[’Banane’, 10, ’a’]. Listen erkennt man an den eckigen Klammern,
die sie umgeben, und jedes Element ist vom nächsten
durch ein Komma getrennt.
Mit Daten arbeiten
Es gibt eine Vielzahl von Dingen, die Sie mit den verschiedenen
Datentypen in Python anstellen können. Sie können zwei
Zahlen addieren, subtrahieren, teilen und multiplizieren und
Python wird das Ergebnis zurückgeben:
>>> 23 + 42
65
>>> 22 / 11
2
Wenn Sie mehrere Arten von Zahlen mischen, wird Python
das Ergebnis so ausgeben, dass die höchste Genauigkeit gewährleistet
ist. Addieren Sie beispielsweise eine ganze Zahl
und einen Fließkommawert, wird das Ergebnis eine Fließkomma-Zahl
sein. Sie können das mit der Funktion type()
überprüfen. Sie gibt als Antwort den Datentyp des Wertes
zurück, den Sie ihr übergeben haben:
>>> type(8)
>>> type(23.01)
>>> type(8 + 23.01)
Sie können auch die gleichen Operationen auf Strings und
Listen anwenden, wobei sie dort allerdings unterschiedliche
Funktionen haben. Der +-Operator fügt zwei Strings oder
zwei Listen zusammen, während der *-Operator den Inhalt
einer Liste oder eines Strings wiederholt.
>>> ”Hallo” + ”Welt”
”Hallo Welt”
>>> [”Apfel”] * 2
[”Apfel”, ”Apfel”]
Strings und Listen haben zudem ihr eigenes Set an Operationen,
wie zum Beispiel das Schneiden. Damit lassen sich bestimmte
Teile eines Strings über einen numerischen Index
auswählen. Die Zählung beginnt dabei bei 0.
>>> word = ”Hallo”
>>> word[0]
’H’
>>> word[3]
’ l’
>>> list = [’Banane’, ’Orange’, ’Himbeere’]
>>> list[2]
100

Coding
’Orange’
Indizes funktionieren auch umgekehrt. Wenn Sie auf das letzte
Element einer Liste oder in einem String zugreifen möchten,
können Sie als Indexnummer -1 nutzen. -2 würde das
vorletzte Element adressieren, -3 das drittletzte und so weiter.
Beachten Sie, dass, wenn Sie mit negativen Indizes arbeiten,
die Zählung nicht bei 0 beginnt.
Methoden
Listen und Strings haben noch weitere Spezialoperationen,
diese werden Methoden genannt. Sie ähneln Funktionen wie
type(), weil auch sie eine Prozedur ausführen. Was sie davon
unterscheidet, ist, dass sie auf ein spezielles Datum angewendet
werden, das sie bearbeiten. Deshalb unterscheiden
Sie sich auch hinsichtlich der Syntax. Zwei Methoden für Listen
sind zum Beispiel append und insert.
>>> list.append(’Birne’)
>>> list
[’Banane’, ’Orange’, ’Himbeere’, ’Birne’]
>>> list.insert(1, ’Pflaume’)
>>> list
[’Banane’, ’Pflaume’, ’Orange’, ’Himbeere’, ’Birne’]
Wie Sie sehen können, wird die Methode aufgerufen, indem
Sie einen Punkt an das Datenelement anhängen, das Sie bearbeiten
möchten, gefolgt vom Namen der Methode. Die Argumente
der Methode werden in den Klammern übergeben,
wie Sie es auch bei Funktionen tun würden. Genauso funktioniert
es bei Strings und allen anderen Datenobjekten:
>>> word = ”HALLO”
>>> word.lower()
’hallo’
Es gibt viele verschiedene Methoden, die auf Listen und
Strings angewendet werden können, auf Tupel oder Wörterbücher
(mehr dazu weiter unten). Um alle Methoden und die
Reihenfolge der Argumente kennenzulernen, konsultieren Sie
die Dokumentation von Python.
Variablen
In unseren Beispielen haben wir die Variablen genutzt, um
die Arbeit mit Daten zu vereinfachen. Variablen sind eine
Möglichkeit der Benennung von Werten – bestimmten Datenstücken.
Sie erleichtern die Verwaltung der einzelnen
Daten, mit denen Sie arbeiten, die Programmierung wird
deutlich weniger komplex (sofern Sie aussagekräftige
Namen verwenden).
Wie wir oben gesehen haben, erstellen Sie in Python eine
Variable mit einer Zuweisung. Zuerst kommt der Name der
Variablen, dann ein Gleichheitszeichen, gefolgt von der Information,
die Sie der Variablen zuweisen möchten. Von diesem
Zeitpunkt an werden Sie jedes Mal, wenn Sie auf den
zuvor angegebenen Namen verweisen, mit den Daten arbeiten,
denen Sie diesem Namen zugewiesen haben. In den
Beispielen haben wir dies gesehen, als wir uns auf das zweite
Zeichen eines Strings oder das dritte Element einer Liste bezogen
haben, indem wir einen Ausdruck an die Variable anhängten.
Auch wenn wir die type()-Funktion verwenden,
greifen wir auf den Inhalt der Variablen zu:
>>> type(word)
>>> type(list)
Andere Datentypen
Es gibt zwei weitere gängige Datentypen, die bei Python
Anwendung finden: Tupel und Wörterbücher.
Tupel sind ähnlich wie Listen – ein Sequenzdatentyp, welcher
Elemente diverser Art enthalten kann. Der große Unterschied
ist, dass Tupel unveränderlich sind: Wenn ein Tupel
einmal erstellt wurde, können Sie ihn nicht mehr modifizieren.
Tupel werden mithilfe runder Klammern angelegt:
(’Banane’, ’Baum’, ’Katze’).
Wörterbücher beinhalten – wie auch Listen und Tupel –
eine Sammlung zusammengehöriger Elemente, allerdings
werden die Elemente nicht durch Nummern indexiert, sondern
durch Schlüssel. Zur Erstellung von Wörterbüchern nutzen
Sie die geschweiften Klammern {}. Bei Wörterbüchern
innerhalb von Python können Sie jeden nicht wandelbaren
Datentyp als Schlüssel verwenden (dazu gehören auch
Strings), sofern der Schlüssel nicht schon im Wörterbuch
vorkommt. Wenn Sie einen bereits existierenden Schlüssel
verwenden, wird sein alter Wert überschrieben und ist dauerhaft
verloren.
>>> english = {’free’: ’as in beer’, ’linux’: ’operating system’}
>>> english[’free’]
‘as in beer’
>>> english[’free’] = ’as in liberty’
>>> english[’free’]
’as in liberty’
Schleifen
Eine häufig vorkommende Aufgabenstellung ist die Anwendung
einer bestimmten Operation auf alle Elemente eines sequenziellen
Datentyps wie etwa einer Liste. Sehen Sie sich
folgendes kleines Python-Programm an:
list = [’Banane’, ’Orange’, ’Kirsche’]
for item in list:
print item
Zuerst legen wir ganz normal eine Liste an, dann verwenden
wir das for … in …-Konstrukt, um die print-Funktion auf
jedes Element der Liste anzuwenden. Das zweite Wort in diesem
Code-Konstrukt muss nicht item sein, das ist nur ein
Variablenname, der temporär jedem Listenelement zugewiesen
wird, um darauf die print-Funktion anzuwenden. Wir hätten
auch for letter in word schreiben können, und es hätte
ebenso funktioniert.
Mit diesen Basisdatentypen im Gepäck sind Sie bereit,
Aufgabenstellungen aus der realen Welt anzugehen, wie wir
auf den nächsten Seiten sehen werden.
Lesen Sie die Python-Dokumentation, um auch mit anderen
Methoden vertraut zu werden, welche die Sprache für die
Datentypen bietet. Sie werden viele nützliche Werkzeuge wie
etwa sort und reverse finden.
Der Python-
Interpreter ist
ein großartiges
Werkzeug, um
mit Python-Code
zu experimentieren
und herauszufinden,
wie
verschiedene Datentypen
zusammenarbeiten.
101

Coding
Designkonzepte:
Komplexe Typen
Wie unterschiedliche Datentypen zusammenspielen,
um die Häufigkeit von Wörtern zu ermitteln.
Wenig überraschend:
Das
häufigste Wort
in der englischen
Originalausgabe
von HG Wells‘
The Time
Machine ist der
Artikel „the“.
Pythons meistgebrauchte Datentypen wie int und float
bedürfen kaum einer Erklärung. Es sind Zahlenwerte
mit den typischen Operationen für mathematische
Anwendungen. Die etwas komplexeren Typen wie String,
Liste, Tupel und Dictionary sind in ihrer Anwendung weniger
intuitiv, daher zeigen wir in diesem Artikel, wie man sie in der
Praxis verwendet.
Wir werden ein kurzes Programm schreiben, das die
Häufigkeit einzelner Worte in einer Textdatei ermittelt.
Satzzeichen werden ignoriert und Worte, die in Groß- und
Kleinschreibung auftauchen (zum Beispiel Python und
python), werden in der Statistik zusammengefasst. Nach der
Analyse gibt das Programm das Ergebnis auf dem Bildschirm
aus. Dies soll folgendermaßen aussehen:
the: 123
you: 10
a: 600
...
Als Beispieltext verwenden wir den Roman The Time
Machine von HG Wells, den Sie von der Website des Project
Gutenberg herunterladen und im gleichen Verzeichnis unter
dem Namen timemachine.txt abspeichern können, in dem
Sie Ihre Python-Datei ablegen möchten.
Im ersten Schritt machen wir den Text unserem Python-
Programm verfügbar. Dazu verwenden wir die open()-Funktion:
tm = open(‘timemachine.txt’, ‘r’)
In diesem Beispiel erhält open() zwei Parameter. Der erste
ist der Name der zu öffnenden Datei. Läge die Datei in
einem anderen Verzeichnis, dann müssten wir hier den kompletten
Dateipfad angeben. Der zweite Parameter legt fest, in
welchem Modus die Datei geöffnet werden soll. Wir geben r
für Lesezugriff an; andere gültige Werte wären w zum
Schreiben und rw zum Lesen und Schreiben.
Das zurückgegebene Datei-Handle weisen wir der
Variable tm zu, damit wir im Weiteren auf die Datei zugreifen
können. Dazu gibt es zahlreiche, auf den jeweiligen Zweck
spezialisierte Möglichkeiten. In unserem Fall verwenden wir
eine einfache for-in-Schleife. Deren Funktion können Sie testen,
indem Sie im interaktiven Modus des Interpreters timemachine.txt
öffnen und Folgendes eingeben:
>>> for line in tm:
print line
...
Auf Ihrem Bildschirm sollte nun jede einzelne Zeile des
Romans erscheinen. Wenn wir diesen Code nun unter dem
Namen cw.py in einer Datei abspeichern, dann haben wir
bereits ein erstes Programmgerüst fertig..
Aufräumarbeiten
In der Programmbeschreibung haben wir festgelegt, dass
Interpunktionszeichen entfernt und Groß-/Kleinschreibung
ignoriert werden sollen, außerdem wollen wir ja Worte und
nicht Zeilen zählen. Bisher lesen wir aber nur ganze, unveränderte
Zeilen inklusive aller Satzzeichen und seltsamer
Sonderzeichen (wie \r\n) ein.
Die string-Dokumentation von Python (http://docs.
python.org/library) verrät uns, dass es bereits vier vorgefertigte
Methoden gibt, die uns unserem Ziel bedeutend
näherbringen: strip(), translate(), lower() und split().
Alle diese Methoden werden auf das String-Objekt angewendet,
das sie verändern sollen – sie sind also Funktionen.
Beispielsweise entfernt strip() bestimmte Zeichen vom
Anfang und vom Ende des jeweiligen Strings:
>>> line.strip()
Wenn man strip() keine Argumente übergibt, dann entfernt
die Funktion alle nicht sichtbaren Zeichen wie
Leerzeichen und Zeilenumbrüche.
Die Funktion translate() tauscht einzelne Buchstaben
gegen andere aus, sie kann aber auch zum Löschen
bestimmter Zeichen genutzt werden. Da wir nur alle
Satzzeichen entfernen möchten, übergeben wir der Funktion
zwei Argumente: Als erstes None und als zweites die Liste
102

Coding
der zu löschenden Zeichen:
>>> line.translate(None, ‘!”#$%&\’()*+,-./:;?@[\\]^_`{|}~’)
lower() verwandelt einzelne Zeichen in deren kleingeschriebene
Pendants. split() zerlegt einen String in eine Liste
mehrerer Strings, indem es den Ursprungstext an all jenen
Stellen auseinanderbricht, die dem Funktionsargument entsprechen:>>>
line.split(‘ ‘)
In diesem Beispiel übergeben wir in einzelnes Leerzeichen
als Trennzeichen. Da alle Satzzeichen bereits entfernt sind,
erzeugt dies eine Liste aller Worte des Ursprungstextes.
Wenn wir all dies in die oben erstellte for-Schleife packen,
dann erkennen wir bereits einen bemerkenswerten
Fortschritt. Der Code sollte nun so aussehen:
tm = open(‘timemachine.txt’, ‘r’)
for line in tm:
line = line.strip()
line = line.translate(None, ‘!”#$%&\’()*+,-./:;?@
[\\]^_`{|}~’)
line = line.lower()
list = line.split(‘ ‘)
Alle String-Methoden geben einen neuen, modifizierten
String zurückgeben; das ursprüngliche String-Objekt bleibt
unverändert. Daher weisen wir jedes Funktionsergebnis
erneut der Variable line zu und „vergessen“ damit deren vorherigen
Wert.
Einzigartig
Bisher haben wir mit String-Funktionen alle Daten entfernt,
die uns nicht interessieren. Wir haben außerdem mehrere
lange Strings, die jeweils einer Textzeile entsprachen, in kleinere
Häppchen zerlegt und diese in einer Liste gespeichert.
Damit haben wir nun exakt das abstrakte Datenkonzept
erzeugt, das uns eigentlich interessiert: Wörter.
Aber noch sind wir nicht am Ziel. Wir müssen noch herausfinden,
welche eindeutigen Wörter es gibt – nicht nur in
einer einzelnen Zeile, sondern in der gesamten Textdatei.
Das Identifizieren eindeutiger Werte kann uns Python mit
der dictionary-Klasse abnehmen. Diese Klasse speichert
Schlüssel/Wert-Paare und legt fest, dass jeder Schlüssel nur
ein einziges Mal vorkommen darf. Wenn wir also Wörter als
dictionary-Schlüssel verwenden, eliminieren wir garantiert
alle Duplikate.
Außerdem können wir das dictionary verwenden, um die
Häufigkeit eines Worts zu speichern, indem wir den Wert des
jeweiligen Eintrags bei jedem Wortvorkommen um 1 erhöhen.
Wir erstellen also ein leeres dictionary. Da es für die
gesamte Textdatei gültig sein soll, machen wir dies außerhalb
der for-Schleife:
dict = {}
Nun brauchen wir eine Methode, die jedes einzelne Wort
im dictionary speichert. Hierzu reicht eine einfache
Zuweisung aus, also könnten wir mit einer weiteren
for-Schleife über unsere Wortliste iterieren und dem dictionary
jedes Wort als Schlüssel und 1 als Wert (da das Wort ja
einmal vorkam) zuzuweisen:
for word in list:
dict[word] = 1
Ärgerlicherweise wird – falls dieser Schlüssel bereits existierte
– der alte Wert einfach überschrieben. Um stattdessen
diesen Wert zu erhöhen, bauen wir eine if-else-Verzweigung
in die Schleife ein:
if word in dict:
count = dict[word]
count += 1
dict[word] = count
else:
dict[word] = 1
In diesem Code wird dict[word] auf zwei verschiedene
Weisen verwendet. In der zweiten Zeile gibt es den dictionary-Wert
zurück und weist ihn der Variable count zu. In der
vierten und sechsten Zeile wird hingegen dem dictionary-Wert
der Variablenwert von count bzw 1 zugewiesen.
Die dritte Zeile ist einfacher: Wenn ein Wort bereits im dictionary
enthalten ist, dann wird dessen bisherige Häufigkeit
um 1 erhöht.
Zusammenführen
Aus der Sicht eines Computers haben wir damit unser Ziel
erreicht: Die Wörter sind eingelesen, identifiziert und gezählt.
Um aber auch dem Benutzer das Ergebnis unserer Mühen zu
präsentieren, benötigen wir noch eine Ausgaberoutine. Der
print-Abschnitt sollte am Ende des bisherigen Codes außerhalb
jeder Schleife stehen und in etwa folgendermaßen aussehen:
for word,count in dict.iteritems():
print word + “: “ + str(count)
Diese for-Schleife unterscheidet sich von den bisher kennengelernten
Schleifen. Indem wir die iteritems-Funktion
verwenden, erhalten wir gleichzeitig Zugriff auf den Schlüssel
(word) und auf den Wert (count) des aktuellen dictionary-Eintrags.
Außerdem verwenden wir die str()-Funktion,
um den Ganzzahlwert count in einen String zu konvertieren.
Der Grund dafür ist der +-Operator, der Ganzzahlen und
Strings nicht miteinander verknüpfen kann.
Wenn Sie nun das Programm starten, dann sollten Sie so
etwas auf dem Bildschirm sehen:
...
other: 20
sick: 2
ventilating: 2
...
Daten? Verarbeiten!
Wir haben gesehen, wie einige Datentypen und deren
Funktionen eingesetzt werden, um praxisnahe Aufgaben zu
lösen. Außerdem haben wir gezeigt, wie wichtig die richtige
Auswahl des Datentyps für das Erreichen des Ziels ist.
So hatten wir zunächst einen String für jede Textzeile,
dann speicherten wir jedes Wort in einer Liste und schließlich
speicherten wir jedes eindeutige Wort in einem dictionary.
Das Programm lässt sich natürlich verbessern.
Beispielsweise könnte man die Worte nach Häufigkeit sortieren.
Und man könnte den Benutzer nach einem Wort suchen
lassen.
In der
Dokumentation
von Pythons
Standard-
Bibliothek,
http://docs.
python.org/
library lassen
sich selten
genutzte
Funktionen
und deren
Anwendung
entdecken.
103

Coding
Designkonzepte:
Abstraktion
Abstraktion macht Ihren Code robuster, wiederverwendbar
und wartungsfreundlicher.
Hat man eine Programmidee, dann geht es meist darum,
mit welchen Daten man zu einem bestimmten
Ergebnis gelangt. Auf welche Weise die Daten verarbeitet
werden, spielt anfangs keine Rolle – was später zu
unlesbarem Code und unbehebbaren Fehlern führt. In diesem
Tutorial betrachten wir daher die Technik der
Abstraktion. Zunächst geht es um die Abstraktion im
Allgemeinen, dann um ihren Einfluss auf das Programmieren
von Methoden.
Quadratwurzeln
Um das Konzept der Abstraktion zu verstehen, betrachten
wir Quadratwurzeln und die unterschiedlichen Ansätze für
deren Berechnung. Ein Ansatz wurde von Newton entwickelt
und ist daher als das Newton-Verfahren bekannt.
Es besagt, dass wir zur Bestimmung der Quadratwurzel
der Zahl (x) mit einem geschätzten Wert (y) dieser Wurzel
beginnen. Wir verbessern dann diesen Wert (y) mit dem
Mittelwert von (y) und dem Ergebnis der Division von (x) und
(y). Wenn wir diesen Vorgang wiederholen, dann nähert sich
der errechnete Wert immer mehr dem tatsächlichen Wert an.
Meist werden wir kein finales Ergebnis erhalten, aber die
Näherung wird besser und besser. Irgendwann werden wir
eine Genauigkeit erreicht haben, die für unseren Zweck ausreicht.
Um das Verfahren besser zu verstehen, werfen Sie
einen Blick auf die Tabelle,
die ein Beispiel für die
Quadratwurzel von 2 zeigt.
Diese Verfahren bedeutet
eine Menge Rechenarbeit,
nur um eine Quadratwurzel
zu bestimmen. Stellen Sie
sich vor, dass Sie diese Methode jedes Mal angewandt hätten,
wenn Sie im Mathematikunterricht eine Quadratwurzel
benötigten. Den Satz des Pythagoras hätten Sie vermutlich
weitaus seltener genutzt.
Glücklicherweise wurden ab einem bestimmten Zeitpunkt
Taschenrechner in den Schulen erlaubt und die Berechnung
Newtons Verfahren
Näherung (y) Division (x/y) Mittelwert (((x/y) + y)/2)
1 2/1 = 2 (2 + 1)/2 = 1.5
1.5 2/1.5 = 1.33 (1.33 + 1.5)/2 = 1.4167
1.4167 2/1.4167 = 1.4118 (1.4118 + 1.4167)/2 = 1.4142
„Die Technik verbirgt die
Komplexität der Gesamtaufgabe
vor uns.“
einer Quadratwurzel war mit einem einzigen Tastendruck erledigt.
Beide Ansätze führten zum gleichen Ergebnis – und
genau das ist Abstraktion. Wenn wir ein Problem wie beispielsweise
den Satz des Pythagoras lösen müssen, dann ist es uns
vollkommen egal, wie eine Quadratwurzel berechnet wird. Uns
ist wichtig, DASS eine Quadratwurzel berechnet wird. So gesehen
ist die Wurzeltaste des Taschenrechners eine Blackbox:
Wir sehen nie hinein und wir kennen den Inhalt nicht, aber wir
verlassen uns darauf, dass sie das korrekte Ergebnis liefert.
Diese Sichtweise ist ein wertvoller Ansatz beim
Programmieren, da er die Komplexität der Gesamtaufgabe vor
uns verbirgt. Um zu zeigen, wie Abstraktion die Entwicklung
vereinfacht, betrachten wir folgenden Python-Code. Er
bestimmt die Hypotenuse eines rechtwinkligen Dreiecks:
import math
def pythag(a, b):
a2b2 = (a * a) + (b * b)
guess = 1.0
while (math.fabs((guess * guess) - a2b2) > 0.01):
guess = (((a2b2 / guess) + guess) / 2)
return guess
Als Erstes wird Ihnen auffallen, dass der Code kaum lesbar
ist. Zwar ist er kurz genug, dass man sich hindurcharbeiten
könnte, aber auf den ersten Blick ist der Zweck dieser Zeilen
nicht zu erkennen. Schlimmer noch: Diesen Code auf logische
oder programmatische Fehler zu testen
ist nahezu unmöglich. Und sollte
doch ein Fehler auftreten, dann hilft
nur die Neuerstellung der gesamten
Funktion.
Wie würden Sie beispielsweise
diesen Code daraufhin testen, ob
eine Näherung ausreichend gut ist? Wie würden Sie den Code
identifizieren, der die Näherung verbessert? Was wäre, wenn
der Code nicht die gewünschten Ergebnisse liefert – wo würden
Sie beginnen, nach dem Fehler zu suchen?
Außerdem findet sich in dieser Funktion Code, der auch an
anderer Stelle nützlich sein könnte – beispielsweise wenn wir
eine Quadratwurzel berechnen möchten oder wenn wir den
Mittelwert zweier Zahlen benötigen. Nichts davon ist wiederverwendbar,
da es in der Funktion verborgen ist. Wenn wir die
jeweiligen Codeteile an andere Stellen kopieren, dann vergrößern
wir die Codemenge und kopieren möglicherweise enthaltene
Programmfehler, die wir vermutlich nie mehr beheben
können.
Also schreiben wir den Code erneut, diesmal sollen aber
einige Abstraktionen die eben genannten Probleme vermeiden.
Im Folgenden sind nur die Definitionen einiger Hilfsfunktionen
aufgeführt, den jeweiligen Code dürfen Sie selbst eingeben:
104

Coding
„Der Scope bestimmt
den Gültigkeitsbereich
einzelner Elemente.“
import math:
def square(x):
...
def closeEnough(x, guess):
...
def improveGuess(x, guess):
...
def sqrt(x, guess):
...
def pythag(a, b):
a2b2 = square(a) + square(b)
return sqrt(a2b2)
Wir haben den Code in mehrere kleine Funktionen aufgeteilt,
die jeweils eine eigene, exakt definierte Aufgabe erfüllen.
Dies hat mehrere Vorteile: Beispielsweise ist die
pythag()-Funktion nun sehr einfach zu lesen und zu verstehen.
In der ersten Zeile steht sehr deutlich, dass a2b2 die
Summe zweier Quadratzahlen ist. Die zweite Zeile sagt ebenso
klar, dass die Funktion die Wurzel dieser Summe zurückgibt.
Darüber hinaus können wir den Code, da er nun in einzelne
Funktionen aufgebrochen ist, sehr einfach testen. Um beispielsweise
herauszufinden, ob improveGuess() sinnvolle
Werte liefert, übergeben wir der Funktion einfach einige
Werte für x und guess und überprüfen das Ergebnis von
Hand.
Und wenn die pythag()-Funktion nicht das gewünschte
Ergebnis liefert, dann müssen wir zwar all die verschiedenen
Hilfsfunktionen einzeln auf Fehler testen, deren einfacher
Aufbau macht dies aber zum Kinderspiel.
Ein weiterer Vorteil dieses Ansatzes ist die
Wiederverwendbarkeit. Jede dieser Funktionen kann auch
von anderen Programmstellen aufgerufen werden, die damit
ihrerseits lesbarer werden. Wenn beispielsweise eine andere
Funktion die Quadratwurzel einer Zahl ermitteln soll, dann
ruft sie einfach sqrt() auf: sechs einfache Buchstaben anstelle
von vier Programmzeilen, in denen sich Fehler eingeschlichen
haben könnten.
Ein letzter Vorteil der Abstraktion: Da die Ermittlung der
Quadratwurzel nur noch in einer einzigen Funktion geschieht,
könnten wir den verwendeten Rechenweg komplett ersetzen.
Sofern wir die Funktion weiterhin sqrt nennen und diese
Funktion exakt ein Argument hat, müssen wir die aufrufenden
Programmteile nicht verändern und sie würden dennoch
Abstraktion
Java
All unsere Tätigkeiten auf einem Computer durchqueren
zahllose Abstraktionsschichten.
C
Assembler
Objectcode
wie erwartet funktionieren.
Sollte Ihnen also eine effizientere Methode zur Berechnung
einer Quadratwurzel einfallen, müssen Sie sich nicht durch
Tausende Codezeilen hindurcharbeiten und jeden Abschnitt
verändern, der sich mit Quadratwurzeln beschäftigt. Sie
ändern nur diese eine Methode und das gesamte Programm
profitiert davon.
Der Code kann noch weiter verbessert werden, indem man
Pythons Scope-Konzept nutzt. Scope bestimmt den
Gültigkeitsbereich einzelner Variablen (beispielsweise ist eine
im Funktionsrumpf definierte Variable nur innerhalb dieser
Funktion bekannt). Gleiches gilt auch für Funktionen: Da closeEnough()
und improveGuess() sehr speziell sind und
voraussichtlich nur für die sqrt()-Funktion genutzt werden,
platzieren wir diese beiden Funktionen innerhalb der
sqrt()-Funktion:
def sqrt(x, guess):
def closeEnough(x, guess):
...
def improveGuess(x, guess):
...
...
Die zwei Funktionen sind nun nur noch für Code innerhalb
der sqrt()-Definition sichtbar; sie befinden sich im Scope von
sqrt(). Programmteile außerhalb von sqrt() wissen nichts von
der Existenz der beiden Hilfsfunktionen.
Abstraktionsschichten
Dieses Beispiel hat gezeigt, wie hilfreich Abstraktion ist. Zwar
bedeutet Abstraktion zunächst mehr Tipparbeit, diese macht
sich bei der Fehlersuche aber schnell bezahlt.
Was wissen Sie zum Beispiel darüber, wie Python
Ganzzahlen im Arbeitsspeicher Ihres Computers ablegt? Oder
wie die CPU arithmetische Operationen wie Addition und
Subtraktion ausführt? Vermutlich ebenso wenig wie die meisten
anderen Programmierer: nämlich nichts. Wir akzeptieren
einfach, dass der Python-Interpreter nach der Eingabe von 2 +
3 das richtige Ergebnis liefert.
Der finale Code,
mit dem wir die
Hypotenuse
eines rechtwinkligen
Dreiecks
bestimmen, ist
länger als die
erste Lösung.
Aber er ist besser
lesbar und
robuster.
105

Coding
Designkonzepte:
Dateien und Module
Wussten Sie, dass Sie mit nur zwei Zeilen Python-Code eine
Funktionsbibliothek erweitern und externe Daten lesen können?
Die meisten
Programmiersprachen
laden
Dateiinhalte nur
häppchenweise
ein. In diesem
Beispiel lesen
wir immer bis
zum nächsten
Zeilenumbruch.
Mit den meisten Software-Projekten kommt man nicht
allzu weit, bevor man sich der Frage stellen muss, wie
denn all die Daten in die Anwendung gelangen. Ob es
um Lochkarten geht, mit denen im 19. Jahrhundert die Webstühle
gesteuert wurden, oder um Googles Robots, die Webseiten
für die Suchmaschine auslesen, stets sind externe
Daten ebenso wichtig wie das Programm selbst.
Auch auf der Kommandozeile werden Sie Zeuge der
Verarbeitung externer Daten: Wenn Sie beispielsweise ls eintippen,
um sich den Inhalt
„Das System verhindert den
Zugriff, wenn eine Datei
verändert wird.“
des aktuellen Verzeichnisses
anzeigen zu lassen, dann liest
dieses Kommando den Inhalt
einer Datei ein und gibt das
Ergebnis in eine andere (das
Terminal) aus.
Zwar entspricht dies nicht dem klassischen Verständnis
von externen Daten, ober so wurde das Linux-Dateisystem nun
einmal konzipiert – nahezu alles ist eine Datei. Diese
Sichtweise vereinfacht es, das Ergebnis eines Kommandos zu
speichern oder das Ergebnis als Input eines weiteren
Kommandos zu verwenden.
Beispielsweise leitet ls >list.txt die Ausgabe des
Kommandos in eine Datei namens list.txt um. Die Ausgabe
selbst kann ebenfalls wie eine Datei behandelt werden: ls |
sort –r leitet das Ergebnis von ls direkt als Eingabe an das
sort-Kommando um und erstellt eine alphabetisch sortierte
Liste des Verzeichnisinhalts. Der vertikale Balken nennt sich
Pipe, englisch für Rohrleitung. Wie weit dieses Konzept in der
Praxis geht, hängt von Ihrem System ab. Zwar bietet jede
Programmiersprache Funktionen zum Laden und Speichern
von Dateien, wie hoch der notwendige Programmieraufwand
aber tatsächlich ist, ist sehr unterschiedlich. Lediglich die
Reihenfolge der Operationen ist stets dieselbe: Zuerst wird
eine Datei geöffnet oder erstellt. Dann wird in diese Datei
geschrieben oder aus ihr gelesen
und schließlich muss die
Datei explizit geschlossen werden,
damit sie anderen
Prozessen zur Verfügung steht.
Die meisten Sprachen verlangen
nach der Angabe des
Zugriffsmodus, da dieser dem Dateisystem verrät, ob
Änderungen am Inhalt zu erwarten sind. Auf diese Weise
können mehrere Prozesse gleichzeitig eine Datei lesen, wenn
keine Änderung droht. Wenn aber ein Prozess in die Datei
schreiben möchte, dann erhält dieser meist exklusiven
Zugriff. Bei Datenbank ist der gleichzeitige Zugriff auf die
Tabellen und Zellen sehr ähnlich geregelt.
In Python – wie in den meisten anderen Sprachen auch
– wird eine Datei zum Lesen mit einem Einzeiler geöffnet:
>>> f = open(“list.txt”, “r”)
Wenn die Datei nicht existiert, dann quittiert Python dies
mit einem „No such file or directory“-Fehler. Um dies zu vermeiden,
haben wir die Ausgabe unseres Kommandozeilenbeispiels
in die Datei namens list.txt gespeichert. Sie liegt in
dem Verzeichnis, von dem aus wir den Python-Interpreter
gestartet haben..
Umgebungsvariablen
Wo genau eine Datei gesucht bzw. gespeichert wird, kann
schnell eine unübersichtliche Angelegenheit werden. Denn
jedes System hat seine eigene Strategie, das „aktuelle“
Verzeichnis zu bestimmen: mal ist es das zuletzt genutzte
Verzeichnis, mal das Programmverzeichnis und mal ist es
das Benutzerverzeichnis. Das wäre nicht weiter schlimm,
wenn es nur um Dateien ginge, die Ihr Programm selbst
erzeugt hat. Wenn es sich aber um Konfigurationsdateien
oder Dateisymbole handelt, dann ist deren Verzeichnis nur
schwer zu bestimmen. Auch auf Python kann man sich hier
nicht verlassen, da diese Sprache auf vielen Plattformen läuft
und sich den jeweiligen Gegebenheiten anpasst. Die Lösung
dieses Problems heißt Umgebungsvariable.
Diese kann man sich wie globale Variable vorstellen, nur
dass sie nicht im Programmcode definiert werden, sondern
106

Coding
in der Linux-Sitzung eines einzelnen Benutzers. Wenn Sie auf
der Kommandozeile env eintippen, dann sehen Sie alle
Umgebungsvariablen, die für Ihre Terminalsitzung definiert
wurden. Bei genauem Hinsehen zeigt sich, dass einige
Variablen auf Verzeichnisse zeigen; insbesondere ist uns an
dieser Stelle HOME wichtig. Der Wert dieser Variable entspricht
dem Ihnen auf diesem Rechner zugewiesenen, persönlichen
Home-Verzeichnis. Um diese Variable in einem
Python-Programm zu verwenden, müssen wir betriebssystemspezifische
Funktionen importieren:
import os
Solche Importe heißen in Python-Module und fügen der
Programmiersprache zusätzliche Funktionen, Klassen und
Definitionen hinzu. Module erweitern die meist sehr einfachen
Schlüsselworte und Funktionen einer Programmiersprache
um komplexere Elemente, die oftmals einem
bestimmten Einsatzzweck dienen. In anderen
Programmiersprachen heißen Module Bibliothek oder
Assembly. Mit Modulen kopiert man eigentlich den
Programmcode anderer Leute in ein eigenes Projekt – das
ist im Normalfall kein Diebstahl geistigen Eigentums, sondern
ist erwünscht und hilft, dass nicht jeder Programmierer
das Rad neu erfinden muss. Da Module wie os von nahezu
jedem Python-Programm verwendet werden, setzen sie
sogar weltweite Standards.
Standards setzen
Es gibt Bibliotheken namens std, die einer Programmiersprache
all die grundlegenden Funktionen unterschieben, die
die Sprache nicht selbst bereitstellt: mathematische
Funktionen, Datentypen, String-Bearbeitung und Input/
Output für spezielle Dateitypen. Meist listet eine Dokumentationsdatei
auf, welche Funktionen eine Bibliothek enthält,
welche Argumente diese erwarten und welche Werte sie
zurückgeben. Oftmals findet sich sogar der Quellcode dieser
Bibliotheken. Auf den meisten Linux-Systemen enthält beispielsweise
das Verzeichnis /lib/python2.x sämtliche
Module. Wenn Sie die Datei os.py in einen Texteditor laden,
dann sehen Sie den Code, den Sie soeben Ihrem Projekt hinzugefügt
haben, und außerdem, welche Funktionen Ihnen
nun zur Verfügung stehen. Oftmals steht am Anfang einer
solchen Datei, ob und unter welchen Umständen Sie das
Modul verwenden und weitergeben dürfen.
Python liefert zahllose
Module für jeden denkbaren
Verwendungszweck mit – und
mit wenigen Mausklicks im
Paketmanager lassen sich
Hunderte weitere nachinstallieren.
An dieser Stelle sei jedoch
vor dem hässlichen Haupt der Modul-Abhängigkeiten
gewarnt: Wenn Ihr Code auf einem Modul basiert, dann müssen
Sie dieses Modul auf jedem Rechner installieren, auf dem
Ihr Programm laufen soll. Und wenn dieses Modul seinerseits
auf weiteren Modulen basiert … Gleiches gilt übrigens ebenfalls
für C oder C++: Auch in solch kompilierten Sprachen linkt
der Programmcode gegen Bibliotheken, die bei Auslieferung
des Programms mitgeliefert werden müssen. Paketmanager
helfen dabei, solche Installationsprobleme zu meistern.
Das os-Modul
Zurück zu unserem Projekt. Das os-Modul dient dem Zweck,
einen plattformunabhängigen Zugriff auf plattformspezifische
Elemente zu haben. In unserem konkreten Fall wollen
wir eine Datei an „der richtigen Stelle“ finden. Was wir damit
„Wenn Sie os.py in einen
Editor laden, sehen Sie den
hinzugefügten Code.“
meinen, wird mit folgender Zeile klar:
f = open(os.environ[“HOME”]+”/list.txt”,”r”)
Diese Zeile öffnet die Datei file.txt in Ihrem Home-
Verzeichnis. Python weiß, welches Home-Verzeichnis Ihnen
gehört, da die os.environ-Funktion aus dem os-Modul denjenigen
String liefert, welcher dem Wert der genannten
Umgebungsvariablen entspricht – in unserem Fall HOME.
Nachdem wir die Datei nun geöffnet haben, können wir
deren Inhalt auslesen:
f.readline()
Dieser Code liest eine einzelne Zeile aus der Textdatei und
zeigt sie an. Da sich Python merkt, an welcher Stelle innerhalb
der Datei diese Zeile endete, liest ein erneuter Aufruf
dieses Codes eine weitere Textzeile ein. Auch dies hat Python
mit nahezu allen anderen Sprachen gemein.
Wenn Sie hingegen den kompletten Dateiinhalt lesen möchten,
dann verwenden Sie f.read(). Da es sich in unserem
Beispiel um eine Textdatei handelt, lässt sich der Dateiinhalt
problemlos in einen String umwandeln. Dies gilt allerdings
nicht für binäre Dateien: In diesen sind die Bits und Bytes
durch den Datentyp bestimmt, der hier abgespeichert wurde.
Es ergibt daher keinen
Sinn, eine solche Datei in
einem Texteditor zu öffnen
oder mit f.readline() zu
lesen – meist endet der
Versuch mit einer
Fehlermeldung. Die Lösung
in diesem Fall ist, dem Dateimodus ein b hinzuzufügen. So
wird Python gewarnt, dass binäre Daten zu erwarten sind,
und ein f.readline() zeigt Ihnen die hexadezimalen Werte
des Dateiinhalts an.
Um auch solche Daten sinnvoll einzusetzen, ist etwas
Mehrarbeit notwendig. Um beispielsweise ein jpg-Bild anzuzeigen,
müssen Sie sich zunächst in das Dateiformat einlesen,
die komprimierten Daten in ein unkomprimiertes Bitmap
schreiben und schließlich die einzelnen Pixel auf den
Bildschirm malen. Für dieses Tutorial wollen wir es aber
dabei belassen, die Datei noch ordentlich zu schließen und
damit die Datenintegrität zu gewährleisten:
f.close
Nun, da Sie auch mit Dateien arbeiten können, sind Sie mit
Ihren Code-Experimenten flexibler als je zuvor.
Binäre Dateien
haben ohne
bekannten
Datentyp und
ohne Verarbeitungsmethoden
keinen Sinn.
Daher sehen Sie
die einzelnen
Bytewerte,
wenn Sie ein
Bild in unserem
Programm
öffnen.
107

Coding
Python: So fangen
Alle Abenteuer mit dem Raspberry Pi starten mit einer einzelnen Codezeile.
Und genau damit wollen wir hier beginnen.
Python-Programme
können Sie auf
unterschiedliche
Weisen laufen
lassen: direkt vom
Interpreter, durch
Aufruf der Python-
Anwendung oder
durch Hinzufügen
eines Shebang zu
einer Skriptdatei.
Der Raspberry Pi wurde hauptsächlich als Bildungsinstrument
entwickelt. Aber das wichtigste pädagogische Ziel
war nicht das Betriebssystem oder die Hardware, sondern
die Produktion einer billigen und leicht zugänglichen Plattform
für die Programmierung. Die Pi-Erfinder liebten an den
Heimcomputern der 1980er Jahre, dass man sie einschalten
und sofort Code eingeben konnte, ohne vorher irgendetwas installieren
zu müssen. Man konnte ohne Umschweife mit dem
System herumexperimentieren und dadurch viel über das
Programmieren und die Funktionsweise des Computers lernen.
Wenn Sie Zugriff auf das Innerste Ihrer Maschine erhalten
möchten, stellt Programmieren die beste Methode dar.
Moderne Computer arbeiten nicht mehr in der gleichen
Weise. Hier haben Betriebssysteme und Befehlszeilen die BA-
SIC-Interpreter der alten Maschinen ersetzt. Aber Programmierung
ist auch heute noch der beste Weg, etwas über Ihren
Rechner zu erfahren, und was vielleicht noch wichtiger ist, es ist
eine der besten Möglichkeiten, Kompetenzen zu erlangen, die
auf fast alle Plattformen, Systeme und Programmiersprachen
übertragen werden können. Außerdem benötigen Sie keine besondere
Erfahrung, um anzufangen. Weil die meisten Anweisungen,
die wir verwenden, über die Befehlszeile eingegeben werden,
ist es sinnvoll, sich als Erstes mit dieser vertraut zu
machen. Es hilft, wenn Sie wissen, wie Programmiersprachen
arbeiten, aber selbst dann ist der beste Weg zu lernen, ins
kalte Wasser zu springen.
Die offizielle Programmiersprache des Raspberry Pi heißt
Python. Dies ist eine fest etablierte Sprache, die bereits von
Millionen Entwicklern benutzt wird. Python wurde für den Raspberry
Pi in erster Linie deshalb ausgewählt, weil es einfach zu
lernen und ideal zum Experimentieren geeignet ist. Aber diese
Programmiersprache ist auch eine mächtiges Werkzeug, das für
viele ambitionierte Projekte bei Google und vielen neuen Technologien
eingesetzt wird. Python ist überdies plattformunabhängig
und beinhaltet die gleichen Konzepte und Paradigmen wie
fast jede andere Programmiersprache. Wenn Sie sich also
näher mit Python beschäftigen, wird Ihnen dies nicht nur helfen,
das Maximum aus Ihrem Raspberry Pi herauszuholen, sondern
es kann Ihnen auch die Welt des Computers eröffnen, so wie
das 1983 die alten 8-Bit-Maschinen taten.
Python-Grundlagen
Python ist bereits auf Ihrem Raspberry Pi installiert, aber Sie
können es auch auf jeder anderen Maschine, die Sie besitzen,
installieren. Es gibt Versionen für Windows, OS X und Linux
sowie für weitere Systeme. Sie können testen, ob Python bereits
installiert ist, indem Sie ein Terminalfenster öffnen und
das Wort python eingeben. Wenn alles funktioniert, sehen Sie
ein paar Zeilen Ausgabe, die mit der Zeichenkette >>> beginnen.
Es handelt sich um den Python-Interpreter und damit um
das, was Python zu einer solch guten Sprache macht. Vielleicht
wissen Sie noch nicht, was ein Interpreter überhaupt ist, doch
das ist schnell erklärt: Alles, was er im Grunde macht, ist, Ihre
Eingaben zu übersetzen und ihre eingegebenen Wörter in
Aktionen umzuwandeln. Geben Sie zum Beispiel print(“Hello
world!”) ein. Sobald sie die Enter-Taste gedrückt haben, wird
der Python-Interpreter Ihre Eingabe decodieren und entsprechend
Ihrem Kommando den Text „Hello world!“ anzeigen.
Allerdings besitzen die meisten Programmiersprachen keinen
Interpreter mehr. Stattdessen schreiben Sie die Anweisungen in
eine Datei und benutzten ein anderes Kommando, um Ihren
Code in die Aktionen umzusetzen, die Sie benötigen. Mit Python
können Sie dies ebenfalls tun. Geben Sie quit() ein, um den Interpreter
zu beenden, und öffnen Sie anschließend einen Texteditor.
Einen einfach zu bedienenden Editor namens Nano
108

Coding
Sie an
können Sie aus der Kommandozeile heraus aufrufen. Wenn Sie
beispielsweise nano hello.py eingeben, wird Nano geöffnet, eine
Textdatei mit dem Namen hello.py kreiert und der Cursor an
oberster Stelle in der Datei platziert, sodass Sie direkt mit der
Eingabe beginnen können. Schreiben Sie nun wieder
print(“Hello world!”) und drücken Sie Steuerung + X. Sie werden
gefragt, ob Sie die Datei speichern wollen, und beantworten
dies mit Y. Sie haben damit eine neue Quelldatei erstellt,
deren Inhalt Sie mit der Eingabe python hello.py ausführen
können.
Die Endung .py der Datei ist nur dazu da, dass Sie wissen,
dass es sich um Python-Code handelt, und wird sonst nicht von
Linux verwendet. Wenn Sie der Kommandozeile mitteilen möchten,
dass es sich um Python-Code handelt, können Sie einen
sogenannten Shebang (die Zeichenkombination !#) verwenden.
Für Python sieht die Shebang-Zeile folgendermaßen aus, und
Sie fügen ihn in die erste Zeile Ihrer Quelldatei ein:
#!/usr/bin/python. Danach geben Sie chmod +x hello.py ein
und können Ihre Datei ohne weitere Kommandos öffnen.
Geben Sie einfach ./hello.py ein, um das Skript aufzurufen.
Es ist nützlich, wenn Sie mit der Kommandozeile umgehen
können, da diese einen guten Überblick bietet und einfach zu
benutzen ist. Es gibt allerdings eine bequemere Möglichkeit der
Befehlseingabe, nämlich die sogenannte Entwicklungsumgebung.
Im Grunde handelt es sich dabei um nichts anderes als
einen aufgemotzten Texteditor. Es gibt stets einen Bereich für
die Eingabe von Text, aber häufig auch noch Bereiche für spezielle
Features, die die Programmiersprache, in der Sie entwickeln,
mitbringt. Zum Betriebssystem Raspbian gehört eine integrierte
Entwicklungsumgebung (IDE) namens IDLE. Sie sollten
ruhig ein bisschen damit herumprobieren, um herauszufinden,
ob IDLE Ihre bevorzugte Entwicklungsumgebung werden könnte.
IDLE startet im interaktiven Modus, deren große Vorteile darin
bestehen, dass der eingegebene Code gemäß den unterschiedlichen
Arten von Anweisungen spezifisch hervorgehoben wird,
dass Pop-ups Informationen zu den bei Python verwendeten Objekten,
Variablen und Methoden liefern und dass alle Einrückungen
automatisch vorgenommen werden. Geben Sie beispielsweise
zunächst value = 1 in IDLE ein und danach value., dann
erscheint ein Menü, das Ihnen die möglichen Methoden zu der
Variablen liefert.
Anweisungen
Nun da wir die Grundlagen von Python-Skripten kennengelernt
haben, ist es an der Zeit, sich die Sprache selbst etwas
genauer anzusehen. Wir haben bereits den Befehl print
(“Hello world!”) ausgeführt, und dieser sagt uns schon viel
über das Programmieren in Python. Vorn steht die Anweisung
print. Anweisungen sind Wörter mit einer vordefinierten Bedeutung
in Python, insgesamt gibt es nur einige wenige davon. Die
Vorschrift print nimmt wie gesehen den in Klammern und Anführungszeichen
stehenden Wert und übergibt ihn an das Standard-Ausgabegerät,
was in den meisten Fällen der Bildschirm
sein wird. Dies ist ein Beispiel für etwas, das Funktion genannt
wird, und alles, was dabei geschieht, ist, dass Daten an einen
anderen Teil des Codes übergeben und von diesem bearbeitet
werden. print ist eine der wenigen in Python vorab definierten
Anweisungen – gewöhnlich schreibt man eigene Anweisungen
oder übernimmt welche von anderen Programmierern. Würden
wir unsere „Hello world!“-Zeile in eine Funktion umwandeln,
sähe diese folgendermaßen aus:
def helloworld():
print(“Hello world!”)
return
Geben Sie dies doch einmal direkt in den Interpreter ein,
dann können Sie sofort mit der Ausgabe experimentieren. Bei
dem oben angegebenen Text sehen Sie außerdem etwas, das
Sie unbedingt beherzigen sollten, nämlich die Einrückung von
Codezeilen. Die erste Zeile – in der die Funktion definiert wird –
beginnt am linken Rand, und alle weiteren Zeilen der Funktion
werden mit der Tab-Taste (oder mittels Leerzeichen) eingerückt.
Das erleichtert die Lesbarkeit des Codes ungemein und erlaubt
es dem Programmierer, auf einen Blick zu sehen, wo ein Block
beginnt und endet. Wenn Sie nun helloworld() in eine neue
Zeile tippen, sehen Sie die Ausgabe der soeben erstellten Funktion.
Sie haben nun Ihren ersten logischen Block Code
geschrieben!
Bedingte Anweisungen
Wenn Sie bisher noch nie programmiert haben, fragen Sie sich
vielleicht, wie Sie die Logik in Ihrem Code aufbauen sollen.
Dazu gibt es viele Möglichkeiten, doch die einfachste ist es,
sich an die Reihenfolge zu halten, in der Bedingungen durchlaufen
werden. Damit ist der Ablauf von Anweisungen zu einem
Entscheidungspunkt, der von dem Zustand eines Parameters
abhängt, gemeint. Der Ablauf kann in verschiedene Richtungen
weitergehen. Der Grundstein für eine Bedingung ist if:
Integrierte
Entwicklungsumgebungen
wie
IDLE sind im
Grunde Texteditoren
mit
erweitertem
Funktionsumfang.
109

Coding
if something == 1:
print(“It’s true!”)
Das ist das korrekte Format einer if-Anweisung in Python.
Hier gibt es einiges Neues, etwa das Wort something. Es
handelt sich hierbei um eine Variable, ihr Name ist beliebig
gewählt. Eine Variable beinhaltet einen – eben variierenden –
Wert, und im Fall der if-Anweisung wird geprüft, ob der Inhalt der
Variablen der Wert 1 ist. Wenn dies der Fall ist, wird die Zeile
„It’s true!“ ausgegeben. Ist dies jedoch nicht der Fall, wird die
print-Anweisung übersprungen. Variablen sind extrem wichtig,
und im Gegensatz zu anderen Programmiersprachen müssen
Sie in Python nicht einem vordefinierten Datentyp zugewiesen
werden. Um den oben genannten Codeschnipsel laufen zu
lassen, müssen wir something einen Wert zuweisen:
something = 1
Vielleicht fragen Sie sich, warum wir diesmal nur ein einfaches
Gleichheitszeichen in der Zuweisung benutzt haben und
nicht – wie bei der if-Bedingung – ein doppeltes. Dies liegt
daran, dass die beiden Varianten unterschiedliche Aufgaben
haben, die man gut auseinanderhalten sollte. Das doppelte
Gleichheitszeichen ist ein Vergleichsoperator. Es gibt daneben
noch weitere Operatoren dieser Sorte:
< kleiner
größer
>= größer gleich
== gleich
!= ungleich
Diese Operatoren können Sie benutzen, um den Wert einer
Variablen zu überprüfen, während das einfache Gleichheitszeichen
der Variablen einen Wert zuweist. Daher wird es Zuweisungsoperator
genannt. Das = ist der häufigste Zuweisungsoperator,
doch es gibt noch andere:
+= Addition und Zuweisung
-= Subtraktion und Zuweisung
*= Multiplikation und Zuweisung
/= Division und Zuweisung
%= Zuweisung des Teilungsrestes
Diese Operatoren erlauben es Ihnen, Werte in Parametern zu
manipulieren, wie Sie es aus mathematischen Formeln kennen.
Und genau wie in mathematischen Formeln können Sie Klammern
verwenden, um die Operationen in genau der Reihenfolge
ablaufen zu lassen, die Sie wünschen. Zum Beispiel:
total = (10/2) * (20/10)
Geben Sie print(total) ein, um sich das Ergebnis anzeigen zu
lassen und zu sehen, wie es berechnet wurde. Es gibt noch
viele weitere Operatoren, aber für die meisten Projekte werden
diese nicht notwendig sein. Haben Sie bemerkt, dass wir ein
weiteres wichtiges Konzept in dem Beispiel behandelt haben?
Wir übergaben print einen Variablennamen und keinen Wert,
und zudem war der Wert der Variablen eine Zahl und kein alphanumerisches
Zeichen. print war trotzdem in der Lage, daraus
eine sinnvolle Ausgabe zu erstellen.
Die Fähigkeit, ein Argument in Klammern an eine Funktion zu
übergeben, ist ebenfalls wichtig, und Sie können dies bei Ihren
eigenen Funktionen genauso machen, indem Sie in der Funktionsdefinition
einen Variablennamen in die Klammern schreiben.
Um unsere „Hello world!“-Funktion vollständig allgemein zu halten,
ändern wir sie folgendermaßen ab:
def helloworld(message):
print(message)
return
Wenn Sie nun helloword(“This is a test”) aufrufen, wird der
Wert innerhalb der Klammern an die Variable „message“ innerhalb
der Funktion übergeben und per print ausgegeben. Dank
der print-Funktion in Python brauchen wir uns im Gegensatz zu
Der for-Loop
ist eine der am
häufigsten vorkommenden
Anweisungen.
Ohne ihn
kann man kaum
ein Python-Skript
schreiben.
110

Coding
Welche Python-Version habe ich?
Es gibt zwei Versionen von Python, die weit
verbreitet sind – Version 2 und Version 3 (auch
bekannt als Python 3000) –, was zu Verwirrung
führen kann. Die am häufigsten verwendete Version
ist die ältere Version Python 2.x, die lange
Zeit der Standard für alle Python-Entwicklungsprojekte
war. Das ist auch die Version, die der
Raspberry Pi standardmäßig verwendet. Sie
können das überprüfen, indem Sie python in die
Kommandozeile eingeben. Die erste Ausgabezeile
sollte im Prinzip ungefähr so aussehen:
Python 2.7.3rc2 (default, May 6 2012, 20:02:25)
Das bedeutet in diesem Fall, dass Sie Python
2.7.3 (release candidate 2) verwenden, was der
letzte Stand des 2.x-Zweigs ist. Obgleich das
Kommando python bei Raspbian zu dieser Version
der Programmiersprache führt, ist Version 3 überraschenderweise
ebenfalls standardmäßig installiert.
Wenn Sie in die Kommandozeile lediglich
pyth tippen und dann die Tab-Taste drücken,
schlägt die Auto-Vervollständigung Ihnen alle
weiteren möglichen Eingaben vor,
etwa python2.7 und python3.2, die
jeweils eine eigene Anwendungsdatei
besitzen. Falls Sie Ihr Skript
mit der neueren Python-Version
starten möchten, geben Sie an
dieser Stelle einfach python3.2
ein. Analog dazu können Sie auf
dem Raspbian-Desktop mit IDLE
beziehungsweise IDLE3 auswählen,
ob sie die Entwicklungsumgebung
für Python 2.7 oder Phython 3
verwenden möchten. Zumindest
am Anfang spielt es jedoch
kaum eine Rolle, mit welcher
Python-Version Sie arbeiten.
Aus Kompatibilitätsgründen
sind die meisten unserer Tutorials für
die ältere Version geschrieben.
Standardmäßig sind zwei Versionen von Python installiert.
Per Kommandozeile können sie zwischen diesen auswählen.
vielen anderen Programmiersprachen keine Gedanken zu machen,
welchen Datentyp eine Variable hat, bevor wir sie an print
übergeben. Die einzelnen Datentypen sind trotzdem wichtig,
weil sie vorgeben, wie Funktionen aufgebaut werden und was
sie tun.
„Es gibt bei Python jede
Menge zu entdecken und
auszuprobieren.“
Datentypen
Auch wenn Sie einer Variablen keinen Datentyp zuweisen müssen,
sind Datentypen bei Python genauso wichtig wie bei anderen
Programmiersprachen. Das liegt daran, dass Datentypen
normalerweise nicht von einem Typ in einen anderen Typ konvertiert
werden können, ohne dass es zu Fehlern kommt. Wenn
Sie eine lange Fließkommazahl wie Pi in eine Ganzzahl und
dann zurück in eine Fließkommazahl konvertieren würden, gingen
alle Nachkommastellen verloren. Das ist wichtig zu verinnerlichen,
damit Sie schon im Vorfeld planen können, mit welchen
Datentypen ihr Code arbeiten wird, bevor Sie den Code
geschrieben haben. Dieses Wissen öffnet Ihnen auch den
Zugang zu einigen Extrafunktionalitäten von Python.
Zum Beispiel haben wir in unserer „Hello world!“-Ausgabe
bereits mit dem string-Datentyp gearbeitet, auch wenn wir ihn
nicht explizit so benannt haben. Wenn Sie einer Variablen eine
Zahl zuweisen, wird diese normalerweise
eine Ganzzahl sein,
solange sie kein Komma enthält,
und andernfalls vermutlich
eine Fließkommazahl. Abgesehen
von den Datentypen, die
einzelne Werte enthalten, gibt
es spezielle Datentypen, die eine Auflistung von Werten enthalten
können. Diese werden Arrays genannt. Arrays sind sehr
nützlich, wenn Sie eine Gruppe von Werten zusammengruppieren
möchten. Hier ist ein Beispiel:
mylist = [8,2,6,4,10]
Die obige Zeile erstellt eine Liste von Zahlen und weist sie
der Variablen mylist zu. Wenn Sie bestimmte Elemente des
Arrays ansprechen wollen, können Sie dies zum Beispiel über
mylist[0] tun. So würden Sie das erste Element im Array ansprechen.
Arrays beginnen immer mit einer 0, nicht mit einer 1.
Zum Schluss möchten wir noch zwei weitere Dinge veranschaulichen,
bevor wir Sie in die Welt der Python-Tutorials entlassen.
Das erste ist das Prinzip der Loops. Ein Loop führt den
gleichen Abschnitt Code so lange aus, bis eine Bedingung erreicht
wird. Wir können zum Beispiel jedes Element in unserer
zuvor erstellten Liste mit einem solchen for-Loop ausgeben:
for i in mylist:
print i
8
2
6
4
10
Alles, was der Loop tut, ist, für jedes Element in der Liste die
nachfolgende print-Anweisung auszuführen. for-Loops werden
sehr häufig verwendet, um Aufgaben dieser Art zu erledigen,
und Sie werden sie bald als festen Bestandteil in Ihren Programmen
verwenden. Ein genauso wichtiger Bestandteil sind
Methoden. Es handelt sich dabei um Funktionen, die die von
Ihnen verwendeten Datentypen erben. Bei unserer Beispielliste
wäre sort eine solche Methode.
Wenn Sie dem Beispiel vor
der print-Anweisung den Methodenaufruf
mylist.sort() hinzufügen,
wird die Anordnung der
Elemente im Array verändert.
Lassen Sie den for-Loop jetzt
laufen, so werden die Elemente in aufsteigender Reihenfolge
ausgegeben.
Mit diesen Ausführungen haben wir Python nur ein klein
wenig angerissen. Es gibt noch jede Menge mehr zu entdecken
und auszuprobieren. Eine gute Informationsquelle ist die offizielle
Website http://docs.python.org, und daneben gibt es
noch viele andere Anlaufstellen im Internet, wenn Sie Unterstützung
brauchen oder sich mit anderen Python-Anwendern
austauschen möchten.
111

Coding
Designkonzepte:
Eine IDE nutzen
Die Arbeit in einem Texteditor ist Ihnen zu mühsam? Dann brauchen
Sie eine integrierte Entwicklungsumgebung.
Tippfehler finden, Schlüsselworte markieren, den Code
hübsch formatieren – es gibt viele stupide Tätigkeiten,
die ein Computer übernehmen könnte. Da ist es ärgerlich,
dass die Kommandozeile des Python-Interpreters all
dies nicht kann. Editoren wie Kate oder Gedit markieren hingegen
die diversen Elementtypen mit unterschiedlichen
Farben und machen so dem Programmierer das Leben einfacher:
Auch wenn einem die Sprache neu ist, erkennt man auf
einen Blick, wenn ein Element nicht erkannt wird, wenn eine
Klammer nicht stimmt oder wenn man einen einfachen
Formatierungsfehler vor sich hat. Aber auch viele Experten
vertrauen auf die farbigen Markierungen, die ihnen einen Teil
der Arbeit abnehmen – gerade wenn man Code so schnell
tippt wie der berühmte Richard Stallman. Was wiederum der
Grund dafür sein könnte, dass Stallmans Emacs-Editor selbst
über dieses Syntax-Highlighting verfügt.
Syntax-Highlighting ist für Anfänger und Experten gleichermaßen
sinnvoll. Man sieht Fehler schneller und man kann
schneller Code schreiben oder verbessern. Sie sollten sich
also auf die Suche nach
einem Editor begeben, mit
dem Sie sich wohlfühlen und
der Sie und Ihr Projekt in allen
Stadien der Software-
Entwicklung unterstützt.
Syntax-Highlighting und Autovervollständigung sind zwei der besten Gründe
für eine Integrierte Entwicklungsumgebung wie Komodo.
„Syntax-Highlighting ist
für Einsteiger ebenso
wichtig wie für Experten.“
Reine Texteditoren sind für interpretierte Sprachen und einzelne
Dateien sinnvoll, sie stoßen aber schnell an ihre Grenzen,
wenn das Projekt wächst. Für solche Fälle wurde Integrierte
Entwicklungsumgebungen (Englisch: Integrated Development
Environment, IDE) entwickelt. Sie verwalten die diversen Code-
Dateien eines Projekts und kümmern sich darum, wie diese zu
einer ausführbaren Datei verarbeitet werden. Zudem haben sie
ein Auge darauf, ob Funktionen und Objekte aus einer Datei
auch in einer anderen Datei verwendet werden dürfen.
Die meisten IDEs haben eine sehr ähnliche Funktionsweise
und können mit den Besonderheiten zahlreicher
Programmiersprachen umgehen. Um Ihnen eine Vorstellung
der Möglichkeiten zu geben, zeigen wir im Folgenden einige
ihrer typischen Funktionen und wie Sie diese für Ihre Projekte
nutzen können.
Komodo auf dem PC
In fast allen Beispielen in diesem Heft nutzen wir Python, um
Ideen und Konzepte vorzustellen. Für diese Sprache gibt es
etliche IDEs wie beispielsweise
Eric, aber – vermutlich weil
Python eine Cross-Plattform-
Sprache ist – es gibt nicht die
EINE IDE, die von jedem Python-
Programmierer verwendet wird.
Zudem sind viele IDEs nur gegen
Geld zu haben, was insbesondere für Programmieranfänger
wenig sinnvoll ist.
Also ignorieren wir diese kommerziellen Optionen und verwenden
die Freeware-Alternative Komodo Edit. Sie läuft nicht
direkt auf dem Pi, da es keine spezielle ARM-Version gibt, aber
da ein Desktop-PC ohnehin stets die bessere Variante zum
Erstellen großer Textmengen ist, stellt Komodo eine großartige
Python-IDE dar. Wenn Sie doch lieber direkt auf dem Pi
programmieren wollen, dann empfehlen wir Ihnen Geany.
Die Installation ist denkbar einfach: Sie laden Komodo auf
Ihren Linux-PC, entpacken das Paket und starten die
Installation mit ./install.sh im gewünschten Verzeichnis. Die
meisten Distributionen präsentieren Ihnen nun ein entsprechendes
Programmsymbol auf dem Desktop, alternativ starten
Sie die IDE mit bin/komodo von Ihrem Home-Verzeichnis
aus. Lassen Sie sich vom ersten Anblick nicht entmutigen –
die Standardkonfiguration zeigt eine große Anzeige für die
kommerzielle Vollversion und zudem viele Fenster, die Sie
bald kennenlernen werden. Die zwei Fenster auf der linken
Seite zeigen oben einen einfachen Dateimanager und unten
eine Projektansicht. Unter „Projekt“ versteht die IDE alle
Dateien, die zur Anwendung gehören: den Code,
Konfigurationsdateien und mehr. Um ein neues Projekt anzu-
112

Coding
legen, klicken Sie auf das kleine Symbol rechts daneben. Wir
empfehlen, mit einer Python-3-Vorlage anzufangen. Um dem
Projekt existierende Dateien hinzuzufügen, ziehen Sie sie mit
der Maus auf den Projektnamen oder öffnen Sie mit einem
Rechtsklick das Kontextmenü. Der Datei-Dialog gestattet die
Auswahl zwischen all den von Komodo unterstützten
Sprachen und setzt daraufhin die Definition einer Umgebungsvariablen
an den Dateianfang.
Code-Erzeugung
Wir gehen nun von einer leeren, im Editor geöffneten Code-
Datei aus, um die Vorteile einer IDE zu demonstrieren. Geben
Sie import ein. Mit diesem Schlüsselwort wird Python veranlasst,
externe Module zu laden, um dem Programm neue
Funktionen hinzuzufügen. In einem einfachen Texteditor
müssen Sie den genauen Namen des gewünschten Moduls
kennen. In Komodo wird Ihnen hingegen eine Liste der installierten
Module angezeigt, aus der Sie nur noch den gewünschten
Eintrag auswählen. Wählen Sie math, um mathematische
Funktionen zu importieren, und fügen Sie der Datei folgenden
Code hinzu.
def square(x):
return x * x
Diese Funktion errechnet das Quadrat von x. Wie Sie
bemerkt haben sollten, fiel die Texteingabe leichter als in
einem Texteditor, denn beispielsweise wurde der Zeileneinschub
automatisch erzeugt. Wenn Sie in einer weiteren
Zeile print square() eingeben, dann kennt Komodo bereits
die square-Funktion und fordert Sie auf, zwischen den
Klammern einen Wert einzugeben.
Leider integriert Komodo Edit den Interpreter nicht selbst
in seine Oberfläche, weshalb immer etwas Handarbeit gefordert
ist. Wenn Sie [Strg]+[R] drücken oder ‘Tools > Run
Command’ aus dem Menü wählen, dann erscheint ein kleiner
Dialog, in den Sie %(python)
%F eingeben. Dies veranlasst
Komodo, %(python)
durch den Dateinamen des
Python-Interpreters zu
ersetzen, der im
Preferences-Fenster festgelegt
wurde. %F wird noch durch den Dateipfad zum
aktuellen Skript ersetzt. Dies startet nun Ihr Skript und
öffnet ein weiteres Fenster, in dem die Ausgaben des
Programms gesammelt werden. Auch Fehler werden in
diesem Command-Output-Fenster angezeigt und erfreulicherweise
genügt ein Mausklick auf eine Fehlermeldung, um
die betreffende Code-Zeile im Editor anzuzeigen.
Syntax-Überprüfung
Sie sollten außerdem ein Auge auf das Syntax Checking
Status-Fenster werfen. Dessen Inhalt wird in Echtzeit aktualisiert
und zeigt alle Syntaxfehler wie beispielsweise inkorrekte
Einrückungen, die im Projekt entdeckt wurden. Aus diesem
Grund müssen Sie stets sicherstellen, dass im Drop-down-
Menü am rechten unteren Ende des Bildschirms die richtige
Sprache eingestellt ist – nur so weiß Komodo, welche
Syntaxregeln gelten. Wenn Sie im Editor eine Funktion
erstellt haben, dann werden Ihnen kleine eckige Klammern
am linken Bildschirmrand auffallen. Sie markieren Codebereiche,
die vom Kontrollfluss der umgebenden Funktion
unabhängig sind. Wenn Sie auf das kleine Pluszeichen klicken,
dann werden diese Bereiche zusammengefaltet und
geben den Blick auf andere Codestellen frei.
„Werfen Sie einen Blick auf
den Reiter Syntax Checking
Status.“
Komodo beinhaltet Vorlagen, mit denen Sie ein Projekt starten können. Für
wiederkehrende Projekttypen können Sie eigene Vorlagen erstellen.
Viele IDEs und sogar einige Texteditoren haben ganz ähnliche
Fähigkeiten. Tatsächlich erklärt das obige Beispiel, wie
der Großteil aller IDEs funktioniert: wie eine fortschrittliche
Textverarbeitung, die externe Tools und eine Sandbox für die
Programmausführung unter ihrer Oberfläche verbirgt.
Nachdem wir das run-Kommando ausgeführt haben, können
wir es zu Komodos Toolbox hinzufügen und ihm eine
Tastenkombination für den späteren Gebrauch zuweisen. Im
Run-Dialog aktivieren Sie dazu „Add to toolbox“, woraufhin
ein weiteres Fenster mit dem soeben verwendeten Python-
Kommando erscheint. Nach einem Rechtsklick darauf wählen
Sie „Properties“. An dieser Stelle können Sie dem
Kommando einen freundlichen
Namen geben und auf der Key-
Binding-Seite eine Tastenkombination
zuweisen.
Definieren Sie nun eine weitere
Funktion, indem Sie
zunächst nur die Deklaration
def square_root(x): eingeben. Wenn Sie im Funktionsrumpf
nun math. eingeben, dann sehen Sie die Liste all jener
mathematischen Funktionen, die wir mit dem import-
Schlüsselwort importiert hatten. Wählen Sie math.sqrt und
geben Sie eine öffnende runde Klammer ein. Ein kleines Popup
informiert Sie nun darüber, was die Funktion macht und
welche Argumente Sie erwartet. Solche Details sind es, die
eine IDE auch zum Erlernen von neuen Sprachen wertvoll
macht. Sie hilft Einsteigern bei ihrer Arbeit, indem sie das
Nachschlagen in der Dokumentation übernimmt.
Produktivität
In den Augen einiger Entwickler ist diese sogenannte Autovervollständigung
ein Zeichen für faule Programmierer – nur
wer selbst den gesamten Code eingibt und Fehler selber findet,
sei ein echter Kerl. Da auch wir echte Kerle sein möchten,
pflichten wir diesen Meinungen natürlich bei – weisen
aber darauf hin, dass sich auch in der professionellen Software-
Entwicklung die Vorteile der stets verfügbaren Dokumentation
und des schnelleren Schreibens herumgesprochen haben.
Sprachen zu beherrschen bedeutet in der Software-
Entwicklung vor allem das Verständnis der zugrunde liegenden
Konzepte. Bei allem anderen darf die IDE gerne helfen.
113

Coding
Designkonzepte:
Ein Unix-Tool
Wir bauen ein Unix-Tool nach, um unsere Python-Kenntnisse zu
verbessern und ein echtes Programm zu erstellen.
Ein vollwertiges Programm! Das ist das erklärte Ziel
der nächsten Seiten. Mit den nächsten Tutorials
werden wir eine Python-Implementation des
bekannten Unix-Tools cat entwickeln. Wie die meisten
Unix-Tools bietet sich cat für solch ein Unterfangen an,
da es klein und auf eine einzige Aufgabe spezialisiert ist.
Zudem nutzt es nicht triviale
Techniken wie Dateien, Pipes
und ähnliche Betriebssystem-
Interna.
Daher wird die
Programmierung nicht lange
dauern und uns gleichzeitig
tief in die Features von Pythons Standardbibliothek einführen.
Sobald sie diese Grundlagen gemeistert haben,
Der Programmcode unseres Tools. Er ist zwar nicht lang, aber er verwendet
sehr viele wichtige Sprachfeatures, die Sie immer wieder benötigen werden.
„Sie wissen mehr als
genug, um echte Tools
zu entwickeln.“
steht Ihren größeren Projekten bestenfalls das
Kennenlernen zusätzlicher Bibliotheken im Weg. Unsere
Ziele für das aktuelle Projekt sind:
Ein Python-Programm namens cat.py zu erstellen, das
beim Aufruf ohne jegliches Argument Benutzereingaben von
der Standard-Input-Pipe entgegennimmt und mit dem ersten
Zeilenumbruch die
Eingaben an die Standardausgabe
sendet.
Wenn die Argumente Dateinamen
sind, dann soll cat.py
jede Zeile der ersten Datei an
die Standardausgabe senden
und dann mit den weiteren Dateien ebenso verfahren.
Es soll zwei optionale Argumente entgegennehmen: Mit -E
soll cat.py ein $-Zeichen an das Ende jeder Zeile stellen und
mit -n soll es die Zeilennummer an den Beginn einer jeden
Zeile stellen.Unser cat-Klon wird mit beliebig vielen
Dateinamen umgehen können, die ihm als Argument übergeben
wurden. Dazu verwenden wir Python 3 – sollte Ihre
Python-Version also noch 2.x lauten, dann installieren Sie
nun die neuere Version: Einige unserer Programmfeatures
sind zu Python 2.x nicht rückwärtskompatibel.
Python-Dateien
Fangen wir mit dem einfachsten Teil der Aufgabe an: den
Inhalt einer Datei Zeile für Zeile an die Standardausgabe zu
übergeben. In Python greift man auf eine Datei mittels der
open-Anweisung zu, die ein Dateiobjekt zurückliefert. Mit diesem
Objekt können wir die Datei lesen oder verändern. Um
das Dateiobjekt für den späteren Gebrauch griffbereit zu
haben, speichern wir das Ergebnis von open in einer Variable:
file = open(“hello.txt”, “r”)
Dies erstellt eine Variable namens file und ermöglicht es,
später den Inhalt der Datei hello.txt zu lesen. Wir werden nur
lesen und nicht schreiben können, da das zweite Argument r
des Funktionsaufrufs angibt, dass die Datei im Lesemodus
geöffnet werden soll.
Nun, da wir Zugriff auf den Dateiinhalt haben, müssen wir
diesen Inhalt Zeile für Zeile an die Standardausgabe senden.
Dies ist in Python sehr einfach, da Dateien sogenannte „iterierbare“
(in anderen Sprachen „enumerable“) Objekte sind.
Iterierbare Objekte wie beispielsweise Listen, Strings, Tupel
und Dictionarys gestatten den Zugriff auf die in ihnen gespeicherten
Elemente mittels einer for-Schleife. Für eine
Textdatei bedeutet dies, dass eine for-Schleife alle in ihr enthaltenen
Textzeilen durchläuft:
for line in file:
print(line)
114

Coding
Die print-Funktion ihrerseits sendet jedes ihr übergebene
Argument an die Standardausgabe des aktuellen
Programms. Wenn Sie die drei Code-Zeilen in eine Datei
schreiben, diese ausführbar machen und eine Datei hello.txt
im gleichen Verzeichnis mit ein paar Textzeilen füllen, dann
werden Sie sehen, dass wir das erste Ziel fast erreicht haben.
Allerdings ist hinter jeder ausgegebenen Textzeile eine
Leerzeile aufgetaucht.
Der Grund dafür liegt in der print-Funktion verborgen, die an
das Ende jeder Ausgabe selbständig einen Zeilenumbruch
anhängt. Da die einzelnen Zeilen der Textdatei bereits einen
Zeilenumbruch enthalten, haben wir nun einen zu viel.
Dies lässt sich leicht beheben, indem man der print-Funktion
ein zweites, mit Namen versehenes Argument übergibt:
print(line, end=““). Damit wird print angewiesen, anstelle
eines Zeilenvorschubs einen leeren String (vulgo „nichts“)
anzuhängen.
Argumente empfangen
Im Vergleich mit dem echten cat-Programm hat unser
Dreizeiler noch einen entscheidenden Nachteil: Um den
Inhalt einer anderen Datei auszugeben, müssten wir den
Programmcode ändern. Da dies wenig benutzerfreundlich
ist, benötigt unser Programm nun eine Möglichkeit, die auf
der Kommandozeile eingegebenen Programmargumente
(beispielsweise cat.py hello.txt) zu verarbeiten.
Der Python-Interpreter zeichnet automatisch alle von der
Kommandozeile stammenden Argumente auf und stellt sie
mithilfe des Moduls sys einem Programm zur Verfügung.
Obwohl sys Teil der Standardbibliothek ist, kann der
Programmcode nicht direkt darauf zugreifen. Stattdessen
muss das Modul importiert und auf dessen Elemente mit der
Punktnotation zugegriffen werden. Den Anfang macht der
Import
import sys
am oberen Ende der cat.py-Datei. Am sys-Modul interessiert
uns nur das argv-Objekt, das eine Python-Liste ist und
alle auf der Kommandozeile eingegebenen Argumente enthält.
Hier gilt es, zwei Dinge zu beachten: Das erste Argument
ist der Programmname selbst, die Programmargumente folgen
dahinter. Zudem können Sie auf argv nur mit der
Punktnotation zugreifen. Um
also auf das erste Argument
zuzugreifen, schreibt man
sys.argv[1].
Mit diesem Wissen sollten
Sie nun den Programmcode
so anpassen können, dass anstelle von hello.txt der Wert
von sys.argv[1] verwendet wird. Fortan können Sie cat.py
mit dem Namen jeder beliebigen Textdatei aufrufen.
Mehrere Dateien
In den Spezifikationen haben wir angegeben, dass cat mehr
als nur eine Datei entgegennehmen und deren Inhalte Stück
für Stück anzeigen soll. Um auch dieses Feature einzubauen,
müssen wir in einer Schleife über alle Elemente von argv iterieren
und den bisherigen Programmcode innerhalb dieser
Schleife ausführen. Hierbei müssen wir auf das erste
argv-Element achten, das ja der Programmname ist uns
nicht weiter interessiert. Um die Schleife mit dem ersten
„richtigen“ Argument beginnen zu lassen (und weil der
Programmname an Listenposition [0] gespeichert wurde),
genügt folgende Anweisung:
for file in sys.argv[1:]:
„Am sys-Modul interessiert
uns nur das argv-Objekt.“
In diesem einfachen Beispiel sind die Ausgaben des echten Unix-Tools und
unserer Python-Nachbildung völlig identisch.
Da die Entgegennahme mehrerer Dateinamen über
Argumente und die anschließende Verarbeitung dieser
Dateien eine sehr häufige Tätigkeit ist, hat Python für den
dazu notwendigen Code bereits eine vollwertige Funktion in
petto. Um das dazu notwendige
Modul fileinput zu
importieren,
stellen Sie wieder import
fileinput an den Anfang der
Code-Datei und ersetzen den
gesamten Code durch
for line in fileinput.input():
print(line, end=””)
Dieser Zweizeiler öffnet alle auf der Kommandozeile
genannten Dateien und gibt deren Inhalt zeilenweise an die
eine for-Schleife weiter. Und sollte dem Programm kein
Dateiname übergeben worden sein, dann liest die Funktion
automatisch aus der Standardeingabe sys.stdin.
Zugegebenermaßen hat dieses Tutorial darauf verzichtet,
Sie größere Mengen Code abtippen zu lassen, Sie sollten
aber dennoch einen Eindruck davon bekommen haben, welche
Schätze sich in Pythons riesiger Standardbibliothek verbergen.
Vieles davon ist nur in Ausnahmefällen wirklich wichtig,
eine umfassende Kenntnis der jeweiligen Bibliothek kann
Ihnen aber in jedem Fall sehr viel Arbeit oder eine aufwendige
Fehlersuche ersparen.
115

Coding
Designkonzepte:
Ein echter Klon
Die Reise in die Welt von Python geht mit einem
verbesserten Klon des Unix-Tools cat in die nächste Runde.
Auf den letzten Seiten haben wir angedeutet, wie
man mit der Standardbibliothek von Python einen
einfachen cat-Klon entwickelt. In diesem Tutorial
werden wir zusätzliche Features einbauen und eine
Möglichkeit entwickeln, Optionsargumente auszuwerten.
Wir beginnen mit der Dateneingabe aus der Standardeingabe-Pipe.
In Linux werden alle Pipes wie Dateien
behandelt: Ob Sie nun einem Programm eine Datei als
Argument übergeben oder
„Glücklicherweise hat
Python eine mächtige
Alternative zu sys.argv.“
ob Sie eine Pipe als
Argument übergeben,
macht keinen Unterschied
– grundsätzlich gibt es keine
Abweichungen zwischen
beiden.
Dies gilt auch für Python selbst. Ihr Programm benötigt
lediglich Zugriff auf das sys-Modul, das es – wenn
Sie dem vorigen Tutorial gefolgt sind – bereits hat.
Fangen wir mit einem kleinen Testprogramm an:
import sys
for line in sys.stdin:
print(line, end=””)
Die erste Zeile importiert das sys-Modul. Die folgende
Zeile ist derjenigen sehr ähnlich, die wir bereits hatten, allerdings
wird für die for-Schleife statt einer geöffneten Datei
das Objekt stdin aus dem sys-Modul verwendet. Wie eine
richtige Datei ist auch Pythons Standardeingabe-Pipe ein iterierbares
Objekt und gibt daher Zeile für Zeile an die Schleife
weiter. Da die Standardeingabe im Allgemeinen leer sein
dürfte, funktioniert stdin dennoch etwas anders: Anstatt
alles auszugeben, was bereits in der Pipe vorhanden ist, wartet
stdin auf Eingaben des Benutzers. Erst wenn der
Benutzer einen Zeilenumbruch eingegeben hat (also die
Python verfügt über alle Features, die man für die Erstellung nützlicher
Programme benötigt. In diesem Beispiel sehen Sie, wie die replace-Methode
genutzt wird, um Zeilenumbrüche zu entfernen. Im Tutorial verwenden wir die
etwas elegantere rstrip-Methode für den gleichen Zweck.
[Return]-Taste gedrückt hat), gibt stdin den Text an die
Schleife weiter. Die print-Funktion sendet nach wie vor den
Inhalt von line an die Standardausgabe.
Wir haben jetzt zwei unterschiedliche Versionen unseres
Programms und müssen sie irgendwie zusammenführen.
Wenn das Programm mit Argumenten gestartet wird, dann
soll es die Dateiinhalte sammeln und ausgeben. Wenn es ohne
Argumente gestartet wird, dann soll es alle in die
Standardeingabe eingegebenen
Zeilen ausgeben. Mit unserem aktuellen
Wissen können wir dies problemlos
umsetzen, da wir lediglich
die Länge von sys.argv untersuchen
müssen. Wenn sie größer als
1 ist, dann kommt die Dateiversion
zum Zug, anderenfalls die stdin-Version:
if len(sys.argv) > 1:
[Dateien ausgeben...]
else:
[stdin ausgeben...]
Das einzig Interessante an diesem Code ist die len()-Funktion.
Sie ist in Python eingebaut und kann auf jedes
Aufzählungsobjekt (String, Tupel, Liste, Dictionary …) angewendet
werden. Sie gibt an, wie viele Elemente in dem Objekt
enthalten sind. Es gibt etliche ähnlicher Funktionen, die auf
http://docs.python.org/3/library/functions.html
beschrieben sind.
Argumente und Optionen
Dieser Ansatz funktioniert zwar wie gewünscht, scheitert aber
an den optionalen Argumenten, die wir ja noch einbauen wollten.
Glücklicherweise hat Python eine mächtige Alternative zu
sys.argv, die sich genau um solche Zwecke kümmert. Zur
Erinnerung: Das Original-cat hat zahlreiche Optionen, von
denen wir zwei in unserem Programm nachbilden werden. Die
Option -E zeigt am Ende jeder Zeile ein $-Zeichen und die
Option -n stellt jeder Textzeile eine Zeilennummer voran.
Um diese Optionen nicht selbst aus argv herauslesen zu
müssen, erstellen wir uns ein OptionParser-Objekt. Dieses
Objekt ist Teil des optparse-Moduls und wird uns den größten
Teil der Arbeit abnehmen. Es entdeckt nicht nur automatisch
Argumente und Optionen, es erzeugt auch automatisch einen
Hilfetext. Dieser wird immer dann angezeigt, wenn der
Benutzer fehlerhafte Argumente übergeben hat oder wenn er
-h oder -help angibt:
[jon@LT04394 ~]$ ./cat.py --help
Usage: cat.py [OPTION]... [FILE]...
Options:
-h, --help show this help message and exit
116

Coding
Auf der Python-
3-Webseite
findet sich eine
herausragende
Dokumentation
aller eingebauten
Klassen und
Funktion. In
vielen Fällen enthalten
die Texte
auf http://docs.
python.org/3/
sogar detaillierte
Anwendungsbeispiele.
-E Show $ at line endings
-n Show line numbers
Um mit dem OptionParser loszulegen, importieren
wir die notwendigen Komponenten:
from optparse import OptionParser
Diese Zeile sieht etwas ungewohnt aus, denn anstatt ein
ganzes Modul zu importieren, importieren wir lediglich das
OptionParser-Objekt. Auf diese Weise startet das Programm
schneller und wir sparen Speicherplatz.
Als Nächstes erstellen wir eine Instanz dieses Objekts, nennen
ihr mit add_option die zu entdeckenden Optionen und
übergeben ihr einen Hilfetext im benannten Parameter usage:
usage = “usage: %prog [option]... [file]...”
parser = OptionParser(usage=usage)
parser.add_option(“-E”, dest=”showend”, action=”store_true”, help=”Show
$ at line
endings”)
parser.add_option(“-n”, dest=”shownum”, action=”store_true”,
help=”Show line numbers”)
Der %prog-Teil des usage-Strings wird von
OptionParser automatisch mit dem Programmnamen
ersetzt. Der dest-Parameter gibt den Bezeichner an,
den wir im Programmcode
„Die letzte Zeile einer
Textdatei hat oftmals
keinen Zeilenumbruch.“
verwenden, um das
Vorhandensein einer
bestimmten Option abzufragen.
action gibt an, welchen
Wert dieser
Bezeichner haben soll – im
Fall von store_true wird der Wert ein boolesches
Wahr sein, wenn die entsprechende Option Teil der
Programmargumente war, und anderenfalls ein boolesches
Falsch. Mit add_option kann man auch
Standardwerte angeben oder neben Optionen auch
Optionsargumente auslesen. Weitere Anwendungsgebiete
und andere gültige Werte für action sind auf
http://docs.python.org/3/library/optparse.html
dokumentiert.
Nach diesen Vorbereitungen kann OptionParser an
seine Arbeit gehen und uns seine Erkenntnisse in
zwei Array-Variablen übergeben:
(options, args) = parser.parser_args()
Die options-Variable enthält alle zuvor definierten
Optionen, also -E und -n. Die Variable args enthält alle übrigen
Argumente.
Während wir uns an die Implementierung der beiden
Optionen wagen, werfen wir einen Blick auf Pythons String-
Funktionen: Die Option -E bzw. showend soll am Ende jeder
Zeile ein Dollarsymbol anhängen – also direkt vor dem
unsichtbaren Zeilenumbruch, der das Ende jeder Zeile markiert.
Da die letzte Zeile einer Textdatei allerdings oftmals keinen
abschließenden Zeilenumbruch hat, dürfen wir von dessen
Existenz nicht ausgehen.
Also löschen wir den möglicherweise vorhandenen Zeilenumbruch
mit der Funktion string.rstrip(). Diese entfernt
alle unsichtbaren Zeichen am Ende eines Strings – und wenn
da kein Zeilenumbruch zu finden ist, dann hat die Funktion
eben keinen Effekt. Wenn wir der Funktion einen String als
Argument übergeben würden, dann würde sie anstelle
unsichtbarer Zeichen diesen String vom Zeilenende entfernen.
Anschließend geben wir der Variable end, die wir der
print-Funktion übergeben werden, den Wert $\n. Auf diese
Weise übernimmt es print, das $-Zeichen an das Zeilenende
zu setzen.
Letzte Ideen
Die Option -n bzw. shownum werden
wir einfacher aufbauen. Wir
verketten einfach die aktuelle
Zeilennummer mit der jeweiligen
Textzeile (inklusive des möglicherweise
vorhandenen Zeilenumbruchs) und übergeben der
Print-Funktionen einen leeren String als end-Parameter.
Damit sind wir immer noch nicht ganz am Ziel angelangt.
Da das Programm vier mögliche Kombinationen übergebener
Optionen berücksichtigen muss, bedarf es noch nach einer
Kontrollflusslogik. Außerdem müssen wir irgendwo die kumulative
Zahl der ausgegebenen Zeilen ablegen, falls -n angegeben
bzw. nach shownum verlangt wurde.
Für all dies gibt es mehrere Ansätze. Da es sich hier
aber um ein Tutorial handelt, werden wir die Lösung mit
einem Einstieg in die Objektorientierte Programmierung
angehen und die gewünschte Funktionalität in einer eigenen
Klasse implementieren.
117

Coding
Designkonzepte:
Klassenobjekte
Wir führen die Ergebnisse der vorhergehenden Seiten
zusammen und stellen den cat-Klon fertig.
Auf den letzten Seiten haben wir große Fortschritte
gemacht. Wir haben die Fähigkeit implementiert, den
Inhalt mehrerer Textdateien auf dem Bildschirm anzuzeigen.
Wir können Eingaben aus der Standardeingabe-Pipe
ausgeben und unser Programm kann
Kommandozeilenoptionen
erkennen und entsprechend
reagieren. Was nun noch
fehlt, ist die Implementation
der Zeilennummern;
anschließend müssen wir die
einzelnen Bestandteile zu
einem funktionierenden Programm zusammenfassen.
„Die Herangehensweise
entspricht dem Aufbau
der realen Welt.“
Objekte
Wie bereits angekündigt, gibt es mehrere Wege zu diesem
Ziel. Wir könnten die Aufgabe mit einigen verschachtelten
Schleifen lösen, dieser Ansatz führt bei größeren Projekten
aber schnell zu einem unleserlichem Code. Wir wählen daher
Hier ist unsere cat-Implementation in allen Varianten: mit und ohne Optionen,
mit und ohne Dateiangabe.
den objektorientierten Weg, der zwar überdimensioniert
erscheinen mag, aber einen guten Eindruck der Eleganz der
Objektorientierten Programmierung gibt.
Wenn man größere Programme entwickelt, ist deren
Lesbarkeit eine der größten Herausforderungen. Nur gut lesbare
Programme können (selbst
vom Entwickler) nach längerer Zeit
noch problemlos verstanden werden,
lassen sich leicht erweitern und
ermöglichen die effiziente Fehlersuche.
Daher wurden im Lauf der
Zeit Paradigmen entwickelt, welche
die Komplexität großer Programme gering halten.
Eines dieser Paradigmen ist die Objektorientierte
Programmierung. Hier sind die einzelnen Elemente eines
Programms diversen Objekten zugeordnet, die jeweils einen
eigenen Status (also Variablenwerte) haben können und so
den aktuellen Zustand des Objekts beschreiben. Auch
Funktionen sind Objekten zugeordnet und ermöglichen es,
diesen Zustand zu verändern.
Diese Herangehensweise entspricht dem Aufbau der realen
Welt: Sie können Ihre Hand mit deren Eigenschaften
beschreiben, beispielsweise mit der Anzahl und Position der
Finger. Und Sie können mit Ihrer Hand Funktionen ausführen,
zum Beispiel einen Finger krümmen, eine Taste drücken oder
eine Tasse halten. Ihre Hand ist ein Objekt mit einem Status
und mit Funktionen, die diesen Status verändern.
Wir werden einen Teil unseres cat-Programms zu einem
Objekt machen, dessen Status die Anzahl der gezeigten
Zeilen beschreibt und dessen Funktion das Anzeigen von
Datei-Inhalten ist.
Python-Objekte
Python implementiert Objekte auf Basis eines
Klassensystems. Eine Klasse ist eine Vorlage und ein Objekt
ist eine bestimmte Instanz dieser Klasse, modelliert nach dieser
Vorlage. Ähnlich wie bei einer Funktion definieren wir
auch eine Klasse mit einem Python-Schlüsselwort:
class catCommand:
Innerhalb dieser Klasse definieren wir Methoden (die
unseren altbekannten Funktionen entsprechen) und
Eigenschaften, die jede Instanz dieser Klasse haben soll. Es
gibt einige besondere, häufig genutzte Methoden. Eine davon
ist die init-Methode. Sie wird aufgerufen, wenn eine Instanz
erzeugt wird, und ermöglicht es, die Eigenschaftswerte des
neu geschaffenen Objekts zu initialisieren.
def __init__(self):
self.count = 1
In diesem Fall weisen wir der Variable count den Wert 1
118

Coding
zu, da dies die erste Zeilennummer sein wird, die wir anzeigen
werden. Wichtiger aber ist das self-Argument, das der
init-Funktion übergeben wurde – hier handelt es sich um den
großen Unterschied zwischen Methoden und Funktionen.
Jede Methode hat – selbst wenn sie sonst keine
Argumente benötigt – diese self-Variable. Sie wird automatisch
vom Interpreter geliefert und ihr Wert entspricht der
Klasseninstanz, für die die Methode aufgerufen wurde. Daher
ist self.count diejenige count-Variable, die der individuellen
Instanz der catCommand-Klasse zugeordnet ist.
Die run-Methode
Das Objekt benötigt noch eine Methode, die abhängig von
den gewünschten Optionen die Textzeilen verändert. Wir
nennen sie run-Methode:
def run(self, i, options):
#set default options
e = “”
for line in i:
#modify printed line according to options
if options.showend:
[...last month]
if options.shownum:
line = “{0} {1}”.format(self.count, line)
self.count += 1
print(line, end=e)
Beachten Sie, dass auch diese Methode ein self-Argument
hat. Die beiden anderen Argumente werden der
Methode wie einer normalen Funktion beim Aufruf übergeben.
Das erste Argument i wird eine Referenz auf die Datei
sein, die diese Methode anzeigen soll. Das zweite Argument
options ist eine Referenz auf die vom OptParse identifizierten
Programmoptionen.
Die Logik dieser Methode ist recht einfach: Jede einzelne
Zeile der aktuellen Datei wird abhängig von den gewählten
Optionen verändert. Es wird möglicherweise – wie im vorherigen
Tutorial beschrieben – das Zeilenendezeichen zu „$\n“
verändert. Anschließend wird eventuell die Zeile mit der format-Methode
derart umgebaut, dass ihr die in der init-Methode
definierte count-Variable vorangestellt wird.
Anschließend inkrementieren wir den Wert von count und
geben die Zeile aus.
Der wichtigste Aspekt dieser Methode ist die Verwendung
von self. Dieses Schlüsselwort gestattet uns den Zugriff auf
Variablen, die innerhalb der aktuellen Objektinstanz definiert
sind. Da diese Variablen der
„Ein besonders schönes
Beispiel gelungener
Programmiererlyrik.“
Instanz gehören, behalten sie
ihren Wert so lange bei, wie die
Instanz existiert. Sofern wir
immer die run-Methode des
gleichen Objekts aufrufen, kann
der nächste Aufruf mit exakt
dem count-Wert weiterarbeiten, mit dem der vorhergehende
Aufruf beendet wurde.
Nun müssen wir nur noch unsere bisherigen Ergebnisse
zusammenführen. Dies machen wir in der main-Funktion –
diese wird in Python zwar nicht benötigt, da aber viele
Programmiersprachen zwingend eine main-Funktion voraussetzen,
hat es sich auch in Python eingebürgert:
def main():
[option parsing code ...]
c = catCommand()
if len(args) > 1:
for a in args:
Das fertige Programm hat es uns trotz seiner Kürze ermöglicht, zahlreiche
Aspekte der Python-Programmierung kennenzulernen.
f = open(a, “r”)
c.run(f, options)
else:
c.run(sys.stdin, options)
Da sich der OptionParser-Code des letzten Tutorials nicht
verändert hat, haben wir ihn an dieser Stelle unterschlagen.
Neu hingegen ist die Zeile c = catCommand(): Sie erstellt eine
neue Instanz der catCommand-Klasse, also ein catCommand-Objekt.
Das c-Objekt besitzt eine Variable count, die
von all seinen Methoden mittels self.count zugreifbar ist.
Dies ermöglicht es uns, die Zeilennummern zu zählen.
Anschließend prüfen wir, ob dem Programm Argumente
übergeben wurden, und rufen in diesem Fall für jede entsprechende
Datei die run-Methode des Objekts c auf, der wir auch
noch die vom OptionParser ermittelten Optionen mitgeben.
Falls hingegen keine Argumente vorliegen, dann rufen wir einfach
die run-Methode mit
sys:stdin anstelle eines
Dateiobjekts auf.
Zu guter Letzt rufen wir
die main-Funktion mit einem
besonders schönen Beispiel
von Programmiererlyrik auf:
main__”:
if __name__ == “__
main()
Dieses Konstrukt ruft die main-Funktion auf – aber nur
unter bestimmten Umständen. Die Variable __name__ hat in
Python eine besondere Bedeutung: Wenn ein Programm von
der Kommandozeile oder sonst wie gestartet wurde, dann ist
der Wert dieser Variable „__main__“. Wenn es hingegen als
externes Modul in ein anderes Python-Programm importiert
wurde, hat es diesen Wert nicht. Auf diese Weise wird verhindert,
dass ein importiertes Modul unerwünschte
Nebenwirkungen hat oder dass main unbeabsichtigt mehrmals
aufgerufen wird.
119

Coding
Designkonzepte:
Module
Wir zeigen, wie wir große Code-Mengen entwirren
und Struktur in unsere Programme bringen.
Beim Programmieren geht es häufig darum, eine komplexe
Aufgabe in kleine, handliche Elemente aufzubrechen.
Auf den letzten Seiten haben wir bereits etliche
Werkzeuge und Techniken kennengelernt, die dem
Programmierer dabei helfen. Von Variablen über Funktionen
bis hin zu Objekten – sie alle strukturieren das ursprüngliche
Problem. Ein Hilfsmittel haben wir noch nicht besprochen,
weil man es erst dann benötigt, wenn des Programm ob seiner
schieren Größe nicht mehr handhabbar ist: das Konzept
der Module und Namensräume.
Sie werden mittlerweile festgestellt haben, dass Code-
Dateien mit zunehmender Länge immer schwieriger zu lesen
sind. Auch wenn das Programm nur aus wenigen Hundert
Zeilen besteht, so scheinen die Funktionen nach kürzester
Zeit ineinander zu verlaufen, und wenn Sie auf der Suche
nach der Ursache eines Programmfehlers sind, dann können
Sie sich kaum noch daran erinnern, wo genau eine bestimmte
Variable definiert wurde.
Wenn der ganze Code in nur einer einzigen Textdatei
steht, dann ist es
„Ab einer bestimmten
Code-Menge wird man auf
Konflikte stoßen.“
schwierig festzustellen,
welche
Abhängigkeiten zwischen
den einzelnen
Programmelementen
bestehen – also welche
Variablen von mehreren Funktionen genutzt werden,
welche Funktionen einander aufrufen etc. Auch der Weg der
Daten durch den Programmfluss ist kaum noch zu visualisieren.
Ab einer bestimmten Code-Menge wird man auch auf
Namenskonflikte stoßen, wenn beispielsweise zwei
Funktionen aufgrund ihrer Tätigkeit den Namen add bekommen
sollen. Und wenn dann auch noch die einzige
Möglichkeit, eine irgendwann einmal geschriebene Funktion
im neuen Projekt zu verwenden, darin besteht, sie zu kopieren,
dann ist klar: Dem Code fehlt es an Struktur.
Das Chaos beherrschen
Module sind Pythons Antwort auf solche Herausforderungen.
Mit dem Einsatz von Modulen strukturiert sich der
Code wie von selbst, Namenskonflikte treten seltener auf und
sie machen es zum Kinderspiel, einzelne Code-Elemente in
mehreren Projekten zu verwenden.
Zweifellos haben Sie in Ihren ersten Python-Programmen
bereits Module verwendet – seien es die eingebauten Module
oder solche von Drittherstellern –, um deren zusätzliche
Funktionen zu nutzen. Erinnern Sie sich beispielsweise an
das optparse-Modul aus dem vorhergehenden Tutorial. Wir
konnten dieses Modul nutzen, indem wir es mit der
import-Anweisung in unser Programm einbanden:
import optparse
Nachdem wir diese Zeile in unseren Code eingefügt hatten,
standen uns wie von Geisterhand neue Funktionen zur
Verfügung, die automatisch Kommandozeilenargumente
analysierten. Wir hatten Zugriff auf die Funktion, indem wir
den Modulnamen, einen Punkt und den Funktionsnamen
aneinanderreihten:
optparse.OptionParser()
Allein der besseren Lesbarkeit wegen lohnt sich dieser
Ansatz. Darüber hinaus mussten wir uns nicht darum sorgen,
auf Variablen- und Funktionsnamen zu verzichten, die irgendwo
im optparse-Modul Verwendung finden, da diese im optparse-Namensraum
vom Rest der Welt verborgen sind. Und
um den optparse-Code wiederzuverwenden, reicht ein einfaches
import optparse.
Wie Module funktionieren
So mächtig und hilfreich Module auch sein mögen, so einfach
sind sie auch zu implementieren. In Python sind sie
nichts anderes als Dateien. Hier ist der Beweis: Erstellen Sie
ein neues Verzeichnis und erstellen Sie dort eine Datei
namens fact.py. In dieser Datei definieren Sie eine Funktion,
welche die Fakultät einer beliebigen Zahl errechnet:
def factorial(n):
result = 1
while n > 0:
if n == 1:
result *= 1
else:
result *= n
n -= 1
return n
Dann erstellen Sie eine zweite Datei namens doMath.py.
In dieser Datei importieren Sie zuerst das soeben erstellte
Modul und rufen dann dessen fakultaet-Funktion auf:
import fact
print fact.factorial(5)
Wenn Sie nun doMath.py aufrufen, dann sollte auf
Ihrem Bildschirm das Ergebnis 120 erscheinen. Wie Sie
sehen, ist der Name eines Moduls nichts anderes als der
Dateiname ohne Erweiterung im gleichen Verzeichnis.
Und wir können jede Funktion in diesem Modul aufrufen,
indem wir deren Namen den Modulnamen und einen
Punkt voranstellen
Der Python-Pfad
Damit stellt sich die Frage, wo Python all die anderen Module
findet – sie befinden sich ja schließlich nicht im gleichen
120

Coding
Indem Sie Ihre
Programme in
kleine Einzelteile
zerlegen und
in separaten
Dateien und
Verzeichnisse
speichern, bringen
Sie Ordnung
in Ihre Projekte
und vereinfachen
zukünftige Code-
Änderungen.
Verzeichnis wie unsere Programme. Die Antwort darauf lautet,
dass Python eine vordefinierte Liste von Verzeichnisnamen
hat, in denen der Interpreter nach all den Modulen
sucht, die wir in den import-Anweisungen angegeben haben.
Zuerst wird nach den eingebauten Modulen (den Built-Ins) im
Installationsverzeichnis gesucht. Anschließend wird die
Verzeichnisliste abgearbeitet, die im path gespeichert ist.
Dieser path ist der $PATH-Umgebungsvariable sehr ähnlich
– er verwendet die gleiche Syntax und dient exakt dem gleichen
Zweck. Allerdings wird der Wert dieser Variable dynamisch
erzeugt. Zum Start eines Programms besteht er aus
diesen zwei Elementen:
Das Verzeichnis, das das Skript beherbergt, welches die
import-Anweisung enthält.
Den PYTHONPATH, der wiederum eine Reihe von
Verzeichnissen ist, die bei der Installation festgelegt wurden.
Sie können die path-Variable jederzeit inspizieren:
Importieren Sie das sys-Modul und sehen Sie sich dessen
Attribut path an (zur Erinnerung: sys.path). Nach seinem
Start darf ein Programm den Wert dieser Variable übrigens
jederzeit verändern.
Gültigkeitsbereiche
Bevor Sie nun munter Ihre eigenen Module erstellen, nehmen
wir uns noch des Themas Gültigkeitsbereiche an. Wir bereits
vor wenigen Seiten angedeutet, bestimmt der
Gültigkeitsbereich (Scope), in welchen Programmteilen eine
Variable oder eine Funktion anderen Elementen zur
Verfügung steht. Beispielsweise kann ein Python-Modul folgenden
Code enthalten:
food = [“apples”, “oranges”, “pears”]
print food
def show_choc():
food = [“snickers”, “kitkat”, “dairy milk”]
print food
show_choc()
print food
Wie Sie sehen, ist die food-Variable innerhalb der Funktion
eine Liste von Schokoriegeln und außerhalb der Funktion eine
Liste von Obst. Dieser Umstand demonstriert zwei unterschiedliche
Gültigkeitsbereiche: den globalen
Gültigkeitsbereich des Moduls mit dem Obst und einen lokalen
Gültigkeitsbereich der Funktion mit den Schokoriegeln.
Schon in kleinen Programmen mit nur einer einzigen
Code-Datei raten wir davon ab, Variablen im globalen
Gültigkeitsbereich zu definieren: Es verwirrt den Leser.
Module lindern dieses Problem ein wenig, da ein Modul seinen
eigenen „globalen“ Gültigkeitsbereich hat – da aber auch
Module immer größer und unübersichtlicher werden, ist das
keine endgültige Lösung. Erst in Kombination mit Klassen, die
wiederum eigene Gültigkeitsbereiche haben, sind Variablen in
dem Objekt gekapselt, dem sie auch wirklich gehören.
Python-Style
Mit einem Alter von über zwanzig
Jahren ist Python eine recht alte
Programmiersprache. Dies hat den
Vorteil, dass viele kluge
Programmierer mittlerweile herausgefunden
haben, wie man die Sprache
am besten verwendet – also auf welche
Weise bestimmte Aufgabentypen
am besten zu lösen sind, wie man
Funktionen benennt oder wie man den
Code so formatiert, dass auch andere
Menschen (oder Ihr Zukunfts-Ich) ihn
verstehen.
Wenn Sie an diesen sogenannten
Best Practices interessiert sind, dann
legen wir Ihnen zwei Webseiten ans
Herz, auf denen Sie ein tiefes
Verständnis für die Sprache Python
erlangen können.
http://python.net/~goodger/projects/pycon/2007/idiomatic/
handout.html
www.python.org/dev/peps/
pep-0008
121

Coding
Designkonzepte:
Massenspeicher
Der einfachste Weg, in Python persistente Daten
als Dateien zu speichern.
Speicher ist billig: Heutzutage können Sie eine externe
500-GB-Festplatte für weniger als 50 Euro kaufen.
Sogar Smartphones haben mindestens 8 GB Speicher
und können zum Preis einer Jeans auf bis zu 64 GB aufgerüstet
werden.
Daher ist es keine Überraschung, dass nahezu jede
Anwendung auf die eine oder andere Weise Daten speichert;
seien es Konfigurationsdaten, Cache-Dateien für beschleunigte
Web-Zugriffe, Spielstände, Aufgabenlisten oder Fotos
– die Liste ließe sich beliebig fortführen.
Vor diesem Hintergrund demonstriert dieses Tutorial, wie
man mit solch persistenten Daten unter Python elegant
umgeht.
Die offensichtlichste Form eines persistenten Speichers in
Python ist das Dateisystem. Die Unterstützung ist in den
Standardbibliotheken enthalten und meist benötigen Sie
nicht einmal weitere Module, um Dateien zu lesen und zu
schreiben.
Um eine Datei im aktuellen Verzeichnis (also von wo aus
Sie das Python-Skript
„Nahezu jede Anwendung
speichert Daten auf die
eine oder andere Weise.“
gestartet haben oder
wo diese sich befanden,
als Sie die Shell
starteten) zu öffnen,
rufen Sie die
open()-Funktion auf:
file = open(“lxf-test.txt”, “w”)
Das erste Argument ist der Dateiname, das zweite
Argument spezifiziert den Modus, in dem die Datei geöffnet
wird – in diesem Fall im Schreibmodus, aber andere gültige
Modi wären Lesen (r) und Anhängen (a).
In Python ist eine Datei normalerweise ein Iterator. Das
heißt, dass man das in-Schlüsselwort verwenden kann, um in
einer Schleife Zeile für Zeile durchzulaufen und deren Inhalt
zu verarbeiten. Bevor wir eine Datei auslesen, wollen wir aber
zunächst Daten in eine solche schreiben.
In Dateien schreiben
Angenommen, Sie entwickeln eine eigene RSS-
Anwendung, um den Google Reader zu ersetzen. Sie haben
bereits eine Oberfläche und können den Anwender nach
einer Liste der Feeds fragen (beispielsweise mit raw_input()
oder mit einem Web-Formular und CGI). Nun wollen Sie diese
Liste auf Festplatte speichern, um zu einem späteren
Zeitpunkt nach Feed-Aktualisierungen zu suchen. Im
Augenblick sind die Feeds nur in einer Python-Liste gespeichert:
feeds = [“http://newsrss.bbc.co.uk/rss/newsonline_uk_edition/
front_page/rss.xml”, “http://www.tuxradar.com/rss”]
Diese Liste ins Dateisystem zu speichern ist mit der
write()-Methode ganz einfach:
for feed in feeds:
file.write(“{0}\n”.format(feed))
Beachten Sie, dass wir den Format-String verwenden, um
am Ende jeder Feed-Adresse einen Zeilenumbruch einzufügen
– anderenfalls hätten wir alle Adressen in einer Zeile und
könnten sie nicht mehr separieren.
Den Inhalt der Datei wiederzuverwenden ist ähnlich einfach.
Wir iterieren über den Dateiinhalt, laden jede Zeile einzeln
ein und entfernen den Zeilenumbruch. Dies überlassen
wir Ihnen.
Wenn Sie Dateien im Python-Code verwenden, dann müssen
Sie zwei Punkte beachten. Der erste Punkt ist, dass Sie
alles, was Sie speichern möchten, in einen String umwandeln
müssen. Dies ist denkbar einfach, da Sie lediglich die eingebaute
str()-Funktion verwenden müssen, beispielsweise
str(42) => „42“.
Der andere Punkt ist, dass Sie eine geöffnete Datei nach
Gebrauch wieder schließen müssen – sonst riskieren Sie
Datenverlust, da das Betriebssystem Daten zwischenspeichert
und dieser Speicher möglicherweise nicht rechtzeitig
geleert wird. Sie schließen eine Datei manuell mit der close()-
Methode, in unserem Beispiel wäre dies file.close().
Eleganter ist allerdings die Verwendung des with-Schlüsselworts:
with open(“lxf-test.txt”, “a”) as file:
feeds = [line.rstrip(“\n”) for line in f]
Dieser kurze Python-Code öffnet das Dateiobjekt und –
sobald der Block innerhalb der with-Anweisung beendet ist
– schließt es automatisch wieder. Wenn Sie nicht genau wissen,
was die zweite Zeile macht, dann schlagen Sie „List
comprehensions“ auf http://docs.python.org nach. Dort finden
Sie Beispiele für effizienten Code
Serialisieren
Die Arbeit mit Dateien wäre weitaus einfacher, wenn man
sich nicht um das Konvertieren der Daten in und aus Strings
kümmern müsste. Insbesondere bei Dictionarys und komplexen
Datentypen schleichen sich schnell Fehler ein.
Glücklicherweise enthält Python zwei Werkzeuge, um dies zu
vereinfachen.
Das erste Tool ist das pickle-Modul. pickle nimmt viele
Python-Objekte entgegen und konvertiert sie in Strings
(Serialisieren) und diese auch wieder zurück in Objekte
(Deserialisieren). Sie müssen sich nur noch um das Öffnen
und Schließen der Dateien kümmern, den Rest übernimmt
das Modul:
import pickle
122

Coding
Wenn persistente Daten für Sie wichtig sind, dann ist die ZODB-Objektdatenbank ein gutes Hilfsmittel. Sie ist in Python
einfach zu handhaben und besser integrierbar als eine relationale Datenbank (www.zodb.org).
import pickle
...
with open(“lxf-test.txt”, “a”) as file:
pickle.dump(feeds, file)
…
with open(“lxf-test.txt”, “r”) as file:
feeds = pickle.load(file)
Dies ist nicht nur schnell umzusetzen, es hat auch
Anwendungen außerhalb der persistenten Daten. Wenn Sie
beispielsweise die Feed-Liste über das Netzwerk übertragen
wollen, dann würden Sie diese Liste ebenfalls zuerst in einen
einzelnen String umwandeln müssen.
Das einzige Problem dieser Lösung ist, dass sie nur mit
Python funktioniert – anderen Programmiersprachen ist das
pickle-Datenformat hingegen unbekannt. Hierfür lautet die
Lösung JSON: JSON steht für JavaScript Object Notation
und ist ebenfalls eine Methode, Objekte in Strings umzuwandeln.
Der Vorteil von JSON ist, dass nahezu jede
Programmiersprache Möglichkeiten besitzt, JSON zu lesen
und zu schreiben. In Python verwendet man JSON genauso
wie pickle. Im obigen Beispiel müssten Sie lediglich pickle
mit json ersetzen, um Ihre Daten zukunftssicher abzuspeichern.
Grenzfälle
In einigen Fällen werden Sie mehrere Objekte und unterschiedlichste
Objekttypen haben, die Sie für die weitere
Verwendung abspeichern möchten. Solche Fälle mit pickle
abzudecken verursacht oft sehr viel Tipparbeit.
Glücklicherweise nimmt Ihnen das Standardmodul shelve
diese Arbeit ab und vereinfacht den Zugriff.
shelve ist ein persistentes Dictionary – oder genauer
gesagt eine Möglichkeit, Schlüssel/Wert-Paare persistent zu
speichern. Die Besonderheit daran ist, dass jeder Dictionary-
Wert ein beliebiges, von pickle serialisierbares Python-Objekt
sein darf.
Sehen wir uns ein Beispiel an: Angenommen, dass unser
RSS-Reader nicht nur die Feed-Adressen speichern soll, sondern
auch die Anzahl der ungelesenen News und welche
News zuletzt gelesen wurde. Diese Daten könnten wir in
einem Dictionary speichern:
tracker = { “bbc.co.uk”: { “last-read”: “foo”,
“num-unread”: 10, },
“tuxradar.co.uk”: { “last-read”: “bar”,
“num-unread”: 5, }}
Wir können nun die Liste der Feeds und der jeweiligen
Details in einer einzelnen Datei speichern, indem wir shelve
einsetzen:
import shelve
shelf = shelve.open(“lxf-test”)
shelf[“feeds”] = feeds
shelf[“tracker”] = tracker
shelf.close()
Ein paar Dinge gibt es beim Einsatz von shelve zu beachten:
Beispielsweise hat shelve seine eigenen Methoden, um
Dateien zu öffnen und zu schließen; die üblichen Datei-
Methoden können Sie nicht verwenden.
Um Daten mit shelve zu speichern, müssen Sie diese wie
in jedem anderen Dictionary auch zuerst einem Schlüssel
zuweisen. Und wie bei Dateien müssen Sie das shelve manuell
schließen, um Dateiverlust zu vermeiden.
Der Zugriff auf Daten ist ebenso einfach. Statt einem
Schlüssel einen Wert zuzuweisen, fragen Sie den Wert mithilfe
des Schlüssels ab: feeds = shelf[“feeds”].
Wenn Sie Daten im shelve verändern möchten, dann fragen
Sie zunächst den Wert ab, verändern Sie die erhaltene
Kopie, speichern Sie die Kopie unter gleichem Schlüssel wieder
im shelve und schließen Sie es.
Mit diesem Tutorial haben Sie das Handwerkszeug
erlernt, das Sie für das Laden und Speichern persistenter
Daten benötigen. Aber eine weitere Möglichkeit haben wir
unterschlagen: relationale Datenbanken wie beispielsweise
MySQL.
123

Coding
Designkonzepte:
Datenorganisation
Wir verwenden SQL und eine relationale Datenbank, um Ordnung
in unsere 70er-Jahre-Rockmusiksammlung zu bringen.
„Relationalen Datenbanken
werden komplexe Fragen
über die Daten gestellt.“
Im vorhergehenden Tutorial haben wir gelernt, wie wir in
unseren Python-Programmen Daten dauerhaft speichern.
Die dort verwendeten Techniken waren strikt dateibasiert
und – so nützlich sie auch sind – eignen sich nicht für große
Datenmengen. Wenn eine Anwendung immer umfangreicher
und Geschwindigkeit immer wichtiger wird, wenn die zugrunde
liegenden Ideen und Zusammenhänge immer komplexer werden,
dann benötigt man andere Technologien wie beispielsweise
Objektdatenbanken oder relationale Datenbanken. Da
Letztere die bei Weitem häufigsten Tools für komplexe Fragen
über Datenbestände sind, stellen wir die Grundlagen dieser
Datenbanken und ihrer Abfragesprache (die SQL für
Structured Query Language genannt wird) vor. Sobald Sie die
Grundlagen beherrschen,
können Sie
relationale
Datenbanken in Ihren
Code integrieren. Als
Erstes stellen Sie
sicher, dass Sie
MySQL oder einen Drop-in-Ersatz installiert haben und mit der
MySQL-Konsole darauf zugreifen können:
mysql -uroot
Wenn Sie ein Passwort eingerichtet haben, dann verwenden
Sie den -p-Parameter, um dieses und den Benutzernamen
anzugeben. Von nun an arbeiten wir an einer kleinen
Datenbank, die unsere Musiksammlung verwaltet.
Relationen
Fangen wir mit all den Informationen an, die wir in unserer
Musiksammlung speichern möchten. Ein logischer Ansatz
wäre, von unseren CDs auszugehen: Jede CD ist ein Album
und jedes Album hat Informationen (oder Attribute) wie den
Künstler, der das Album erstellt hat, oder die im Album enthaltenen
Musiktitel.
Wir könnten all diese Daten in einer einzigen, großen
Tabelle – wie in „Doppelte Daten“ – speichern. Dies wäre funk-
Doppelte Daten
Album Free At Last Free At Last
Künstler Free Free
Titel Little Bit of Love Travellin’ Man
Titeldauer 2:34 3:23
Albumdauer 65:58 65:58
Jahr 1972 1972
Bandauflösung 1973 1973
Relationale Datenbank
Albumname
Free At Last
Albumdauer 65:58
Jahr 1972
Artist_id 1
tional, aber keineswegs effizient: Für jeden Musiktitel eines
Albums würden wir viele Informationen duplizieren; beispielsweise
den Albumnamen, die Albumlaufzeit, das Veröffentlichungsdatum
und auch Informationen über den Künstler wären
mehrfach enthalten. Dies wäre sowohl eine Verschwendung
von Speicherplatz als auch eine unnötige Prozessorbelastung,
zudem liefe jede Veränderung Gefahr, inkonsistente
Informationen zu verursachen.
Relationale Datenbanken lösen diese Probleme, indem wir
in den Daten einzelne Entitäten identifizieren und diese in jeweils
eigenen Tabellen speichern können. In unserem Beispiel
würden wir Album, Künstler und Musiktitel in eigenen Tabellen
speichern. Wir hätten nur noch einen einzigen Eintrag für den
Künstler Free (nämlich den Namen und das Jahr der Band-
Auflösung), einen Eintrag für das Album Free At Last (den
Namen, das Veröffentlichungsdatum und die Gesamtdauer) und
jeweils einen Eintrag für jeden Musiktitel (der alles andere enthält).
All die unnötigen Doppelungen wären verschwunden – aber
wie kommen wir nun an den kompletten Datensatz eines
Musiktitels, inklusive des verantwortlichen Künstlers und des
Albums? An dieser Stelle kommt der „relationale“ Teil einer
relationalen Datenbank ins Spiel.
Jede Zeile einer Datenbanktabelle muss in irgendeiner Weise
einzigartig sein. Dies geschieht entweder über eine einzelne
Spalte (etwa der Künstlername in der Künstlertabelle) oder
über eine Kombination mehrerer Spalten (beispielsweise
Albumtitel und Jahr der Veröffentlichung). Solche einzigartigen
Spalten werden „primärer Schlüssel“ genannt. Sollte sich aus
den vorhandenen Daten kein primärer Schlüssel ergeben, so
kann man einfach eine zusätzliche Spalte einführen und diese
automatisch mit einzigartigen Werten füllen lassen. Nun fügen
wir den Tabellen jeweils eine Spalte hinzu, in denen der primäre
Schlüssel der verwandten Datenzeilen in anderen Tabellen
steht. Wenn wir beispielsweise dem Künstler Free den primären
Schlüssel artist_id mit dem Wert 1 zuweisen, dann sollte
auch besagte zusätzliche Spalte in der Zeile Free At Last der
Album-Tabelle genau diesen Wert 1 haben. Wenn wir nun die
Tabellenzeilen kombinieren, in denen artist_id den Wert 1 hat, dann
können wir die ursprünglichen Informationen wiederherstellen.
124

Coding
SQL
Das war auch schon das große Geheimnis relationaler
Datenbanken – man zerlegt einen großen Datenbestand in
sinnvoll kleine Häppchen (Tabellen) und beschreibt die
Beziehung dieser Häppchen untereinander (primäre
Schlüssel). Um Tabellen und Schlüssel zu erzeugen und um
Daten einzufügen und abzufragen, setzen die meisten relationalen
Datenbanken auf SQL. Da wir nun wissen, was Tabellen
und Beziehungen sind, sehen wir uns den SQL-Code an, mit
dem wir diese erzeugen und nutzen.
Nachdem wir uns an der MySQL-Konsole angemeldet
haben, erstellen wir eine Datenbank. Eine Datenbank ist der
oberste Container einer Datenhierarchie, sie enthält die
Tabellen und einiges mehr. Um eine Datenbank zu erstellen,
geben wir die create database Anweisung ein:
create database lxfmusic;
Beachten Sie das Semikolon am Ende der Anweisung –
alle SQL-Befehle müssen damit enden. Aus optischen
Gründen haben wir Kleinbuchstaben verwendet; SQL selbst
ignoriert die Klein- und Großschreibung der Anweisungen.
Ähnlich wie bei den Verzeichnissen im Linux-Dateisystem
müssen wir noch in diese Datenbank wechseln, um sie
bequem verwenden zu können. Sie wechseln die aktuelle
Datenbank mit der use-Anweisung:
use lxfmusic;
Now to create some tables:
create table Album (
Album_id int auto_increment primary key,
name varchar(100)
);
create table Track (
Track_id int auto_increment primary key,
title varchar(100),
running_time int,
Album_id int
);
Hier gilt es zu beachten, dass wir zwei, mit Semikolon
getrennte Anweisungen gegeben haben. Außerdem läuft jede
Anweisung über mehrere Zeilen – SQL ignoriert überzählige
Leerzeichen und Zeilenumbrüche. Sofern die Interpunktion
stimmt, ermöglicht dies lesbar formatierte Anweisungstexte.
Die Anweisungen selbst sind dem create database-Statement
ähnlich. Wir geben an, was wir vorhaben, gefolgt von
dem Objekttyp, auf das sich das Vorhaben bezieht, und
schließlich geben wir noch ein paar Objekteigenschaften an.
Bei create database war die einzige Eigenschaft der
Datenbankname, bei create table kommen noch weitere
Eigenschaften dazu, jeweils in Klammern und mit Komma
voneinander getrennt.
Es handelt sich hier um Spaltendefinitionen: Jeder einzelne
Eintrag beschreibt eine neue Spalte der zu erzeugenden
Tabelle. Am Anfang steht der Spaltenname, dann beschreiben
wir den Typ der zu speichernden Daten und schließlich
geben wir an, ob die Spalte Teil des primären Schlüssels ist.
Das auto_increment-Schlüsselwort legt fest, dass die
Datenbank selbst den Wert für jeden neuen Tabelleneintrag
festlegt und sich der Programmierer nicht darum kümmern
muss (bzw. darf). Auf diese Weise entsteht ein automatischer
primärer Schlüssel.
Mehr Details zu create table finden Sie in der MySQL-
Dokumentation auf http://dev.mysql.com/doc/refman/5.5/en/create-table.html.
MariaDB ist ein Drop-in-Ersatz für die MySQL-Datenbank und findet in
Distributionen wie Mageia, OpenSUSE und Slackware wachsende Unterstützung.
Inserts und Selects
Daten in unsere neu erstellten Tabellen einzufügen ist ähnlich
einfach:
insert into Album (name) values (“Free at Last”);
Wieder legen wir Aktion und das betroffene Objekt fest.
Dann geben wir die Spaltennamen und die entsprechenden
Werte, die wir in die Tabelle schreiben möchten.
Bevor wir nun aber auch neue Einträge die die Track-
Tabelle schreiben können, müssen wir wissen, welche
album_id der Eintrag Free at Last bekommen hat, ansonsten
könnten wir die Tabellen nicht sinnvoll miteinander verknüpfen.
Dazu verwenden wir die select-Anweisung:
select * from Album where name = “Free At Last”;
Diese Anweisung bedeutet, dass wir alle Spalten der
Album-Tabelle auswählen möchten, deren Wert in der Spalte
name exakt „Free At Last“ ist. Da wir eigentlich nur an der ID
des Albums interessiert sind, ersetzen wir den Stern durch
Album_id und beschleunigen damit die Abfrage um ein
Vielfaches. In unserem Fall gibt dies 1 zurück (es war das erste
Album, das wir angelegt hatten) und wir können einen neuen
Musiktitel folgendermaßen einfügen:
insert into Track (title, running_time, Album_id) values (‘Little Bit
of Love’, 154, 1);
Bitte beachten Sie, dass wir die Dauer des Musiktitels in
Sekunden und als Ganzzahl angegeben haben. Da wir bei der
Definition einer Spalte grundsätzlich einen SQL-Datentyp
angeben müssen und nicht jeder Python-Typ einen korrespondierenden
SQL-Typ hat (und umgekehrt), haben wir
einen einfachen und im Python-Code schnell zu konvertierenden
Datentyp gewählt.
Damit haben Sie die wichtigsten Grundlagen von SQL
kennengelernt und kennen das Handwerkszeug für schnelle
und speichersparende Datenabfragen. Sollten SQL und insbesondere
Datenbestände aus mehreren Tabellen für Ihre
Anwendung wichtig sein, dann sollten Sie sich noch mit der
Wunderwelt der join-Abfragen auseinandersetzen. Dies sind
kombinierte select-Anweisungen über mehrere Tabellen bei
gemeinsamem Schlüssel. Und wenn Sie dann auch noch Ihre
SQL- und Programmierkenntnisse kombinieren möchten,
dann benötigen Sie die passende Code-Bibliothek, beispielsweise
das python-mysql-Modul für Python.
125

Coding
GUI-Coding: Mit
Mithilfe der Clutter-Bibliothek können Sie einen Blick über den Tellerrand der
Kommandozeile in die Welt der grafischen Benutzeroberflächen wagen.
Hier ist es noch ein bisschen dunkel. Aber dank Clutter
wird sich das bald ändern.
Bisher haben wir uns im Rahmen unserer Python-Anleitungen
und -Projekte auf das Schreiben von Terminal-
Skripten konzentriert, doch an dieser Stelle möchten
wir Ihnen einmal eine Interaktion mit dem Nutzer per grafischer
Benutzeroberfläche (GUI) demonstrieren. GUI-Code
wird schnell sehr umfangreich, da die Darstellung grafischer
Elemente auf dem Bildschirm aus Coding-Sicht eine komplexe
Angelegenheit darstellt.
Dank der PyClutter-Bibliothek ist es jedoch möglich, Code,
der eine grafische Oberfläche steuert, trotzdem relativ kompakt
zu halten. Das Programm, das wir mit Ihnen erstellen
möchten, hat einen Umfang von weniger als 70 Zeilen. Es
handelt sich um ein kleines, aber nützliches Werkzeug, mit
dessen Hilfe Sie die Geschwindigkeit Ihrer Internetverbindung
messen können. Das Schreiben des Programms führt
Sie an die Möglichkeiten von Clutter und PyClutter heran und
hilft Ihnen hoffentlich, eine Vorstellung zu gewinnen, wie die
Bibliothek sinnvoll im Zusammenspiel mit Python-Web-Anwendungen
eingesetzt werden kann.
Zunächst sollten wir uns einen Moment mit der Terminologie
von Clutter beschäftigen, denn diese mag auf den ersten
Blick seltsam wirken. Während andere GUI-Toolkits die Objekte
üblicherweise als Fenster oder Panel definieren, bezeichnet
Clutter den grafischen Darstellungsbereich als stage
(„Bühne“) und ein darin erscheinendes Objekt als actor
(„Schauspieler“). Die actors haben mehr Eigenschaften als
ein Standard-Widget, da sie de facto in einer 3D- statt einer
2D-Umgebung existieren.
Clutter: Objekte erschaffen
Nun aber zur Praxis! Öffnen Sie Ihre übliche Python-Entwicklungsumgebung
(zum Beispiel die Bash-Shell), und
legen Sie los:
>>> import clutter
>>> stage = clutter.Stage()
>>> stage.set_size(500,300)
>>> red=clutter.Color(255,0,0,255)
>>> black=clutter.Color(0,0,0,255)
>>> stage.set_color(black)
>>> stage.show_all()
Schließen Sie das Fenster, das sich daraufhin geöffnet hat,
und sehen Sie sich nochmals den Code an. Was genau ist
passiert? Die erste Programmzeile hat das Clutter-Modul geladen.
Clutter öffnet wiederum einige Backend-Module, die
mit Darstellungsbibliotheken verbunden sind, damit Objekte
auf dem Bildschirm angezeigt werden können. Als Nächstes
haben wir ein stage-Objekt erschaffen. Der Viewport, also
das Darstellungsfeld, ist die Bühne, auf der die actor-Objekte
ihre Rollen spielen.
Die Attribute sind sehr einfach festzulegen, es müssen lediglich
Methoden für die stage-Klassen zugewiesen werden.
Hier haben wir Größe und Farbe festgelegt. Die Parameter
der Methode für die Größe sind Breite und Höhe, und die
Farbe wird als RGB-Wert plus Alpha im clutter.Color-Objekt
festgelegt. Der letzte Befehl bestimmt, dass – wie bei anderen
GUI-Toolkits – das Objekt gezeigt wird, bevor es auf dem
Bildschirm dargestellt wird.
Doch was ist nun mit unseren Schauspielern, den Objekten,
die wir auf dem Monitor haben möchten? Fügen wir ein
Textobjekt hinzu:
>>> a=clutter.Text()
126

Coding
Clutter hantieren
>>> a.set_font_name(“Sans 30”)
>>> a.set_colour(red)
>>> a.set_text (“Hello World!”)
>>> a.set_position(130,100)
>>> stage.add(a)
Bei diesem Textobjekt wird hoffentlich klar, was die einzelnen
Methoden tun: eine Schriftart auswählen, eine Farbe festlegen,
den Text-String definieren sowie die Position auf der
Darstellungsfläche bestimmen. In der letzten Zeile wird das
actor-Objekt dann tatsächlich auf die Bühne geschickt. Erst
an diesem Punkt wird es auf dem Monitor sichtbar.
Nun ist das Objekt aber vorhanden, und Sie können damit
herumexperimentieren. Versuchen Sie beispielsweise eine
andere Position oder Farbe.
PyClutter ist leider nicht sehr gut dokumentiert, doch immerhin
bietet Python gute Hilfestellungen. Wenn Sie dir (a)
eintippen, bekommen Sie die Methoden und Attribute angezeigt,
die für ein bestimmtes Objekt verfügbar sind.
Als Nächstes wollen wir ein lauffähiges Skript erstellen.
Zuvor sollte jedoch noch eine Sache erledigt werden, nämlich,
die Kontrolle über die Anwendung an die Funktion
clutter.main() zu übergeben. Hierbei möchten wir uns jedoch
die Option bewahren, das Programm selber beenden
zu können. Dies erreichen wir durch ein Keyboard Event
(Tastaturereignis).
Wenn das stage-Fenster aktiv ist, erhält Clutter Signale,
wann immer Tasten auf dem Keyboard gedrückt werden. Wir
können daher eine Callback-Funktion einrichten, die das Ereignis
verarbeitet und die Haupt-Programmschleife abbricht,
sobald eine bestimmte Taste gedrückt wird. Daneben können
Sie übrigens auch anderen Tasten eine Aktion zuordnen,
etwa einen Farbwechsel im Darstellungsbereich.
>>> def parseKeyPress(self, event):
... if event.keyval == clutter.keysyms.q:
... clutter.main_quit()
... elif event.keyval == clutter.keysyms.r:
... self.set_color(red)
...
>>> stage.connect(‘key-press-event’, parseKeyPress)
>>> clutter.main()
Wenn das Skript in einer interaktiven Python-Shell läuft,
beendet die Abbruchfunktion quit nicht Python an sich, geschweige
denn, dass sie die Anwendung zerstören würde.
Die Funktion transferiert lediglich die Kontrolle zurück an
die Python-Shell. Die Methode clutter.main_quit() beendet
die laufende Anwendung oder zumindest den Clutter-
Anteil davon.
Einen Systemmonitor bauen
Jetzt wissen Sie ein bisschen über die Schnittstelle Bescheid,
also können wir uns wie versprochen der Programmierung
eines Werkzeugs zuwenden, mit dem Sie die Geschwindigkeit
Ihrer Internetverbindung messen können. Bei allen Fragen
im Zusammenhang mit Systemstatistiken ist proc
immer eine gute Anlaufstelle. Das Pseudo-Dateisystem
/proc enthält einen riesigen Fundus an Informationen über
Nach guter
alter Tradition
beginnen wir
damit, der Welt
hallo zu sagen.
Clutter-Versionen
Die Clutter-Bibliothek und demzufolge auch das Python-
Modul, das die Bibliothek verwendet, ist vor einer Weile
auf Version 1.0 upgedatet worden. Normalerweise rufen
Updates ein paar Unstimmigkeiten zwischen alten und
neuen Versionen von Software hervor, aber in diesem
Fall gibt es fundamentale Unterschiede zwischen dem
Code der Versionen vor und nach 0.9. Das PyClutter-
Modul und die Clutter-Bibliothek sind vermutlich über das
Repository Ihrer Distribution erhältlich, doch wenn Sie
diese installieren, achten Sie darauf, dass Sie Version 0.9
oder besser noch 1.0 haben und keine ältere. Andernfalls
wird der Code dieses Tutorials nicht funktionieren.
Die interaktive Shell lädt zum Herumprobieren mit
Clutter-Objekten ein.
127

Coding
Schnell-
Tipp
Den Überblick
über Versionen
zu behalten, kann
zum Alptraum
werden, doch die
meisten Module
speichern ihre
Versionsnummer
in ._
version_, was
nicht nur für Sie
selbst praktisch
ist, sondern
auch Ihren
Anwendungen
erlaubt, nach
einer kompatiblen
Version Ausschau
zu halten.
Clutter-Infos
Clutter ist eine Grafik- und GUI-
Bibliothek unter GPL-Lizenz. Es wurde
ursprünglich vom OpenHand-Team
entwickelt und später an Intel verkauft,
das die Entwicklung weiterverfolgt.
Clutter ist ein einfaches, schnelles und
mächtiges Werkzeug zur Erstellung
von 2D- und 3D-Grafiken auf diversen
einen Linux-Rechner. Es besteht aus einem Sammelsurium
an Dateien, aber wir benötigen an dieser Stelle nur /proc/
net/dev. Diese Datei listet alle Netzwerkgeräte auf, und Sie
finden darin Statistiken über empfangene und gesendete
Bytes, Pakete, Fehlermeldungen und vieles mehr. Für unseren
Code benötigen wir nur die Information über ein- und
ausgehende Bytes. Diese wird in Form einer Gesamtsumme
gegeben und stellt quasi eine Momentaufnahme zum Zeitpunkt
des Öffnens der Datei dar. Um eine Geschwindigkeit
ermitteln zu können, müssen wir also die Datei zweimal hintereinander
in einem bestimmten zeitlichen Abstand (zum
Beispiel 1 Sekunde) öffnen und die Differenz der beiden
Werte ausrechnen.
Nun brauchen wir nur noch eine kleine Funktion, welche
die Datei einliest, diese nach der gewünschten Information
durchsieht und die Rechenoperation durchführt. Bevor wir
die Datei verlassen, speichern wir noch die letzte Zahl, um sie
beim nächsten Öffnen von der neuen Zahl abziehen zu können.
So könnte die Funktion aussehen:
devfile=open(‘/proc/net/dev’,’r’)
for line in devfile.readlines():
line=line.strip()
if (line[:4] == ‘eth0’):
line=line[5:].split()
print line[0], line[8]
In der ersten Codezeile liest die Funktion die Datei ein, danach
erfolgt die Suche innerhalb der Datei nach der Textzeile,
die mit eth0 beginnt. Vor der Suche müssen die Zeilen allerdings
noch gestrippt werden, denn der Output wird mit Leerzeichen
aufgefüllt, um gleichmäßige Tabellenspalten zu erzeugen.
Sobald die richtige Zeile in der Datei gefunden ist,
entfernen wir den Schnittstellenteil und teilen den String so
auf, dass wir jede der Zahlen als Element einer Liste bekommen.
Der Wert der empfangenen und gesendeten Bytes befindet
sich an Position 0 beziehungsweise 8 der Liste. Hier
haben wir sie einfach ausgeben lassen. Tippen Sie den Code
ein und schauen Sie sich die Ausgabe an. Zum Schluss müssen
lediglich noch die Strings in ganze Zahlen umgewandelt
und gespeichert werden.
Timelines
Falls Sie jetzt einwenden, dass die Ausführung des Programmcodes
ja auch eine gewisse Zeitspanne benötigt (auf
unserem Entwicklungssystem waren dies 0,0001 Sekunden)
und somit das Ergebnis leicht verfälscht, könnten wir noch
etwas in dieser Art schreiben:
import time
lasttime=1
Plattformen. Das Backend besteht im
Wesentlichen aus OpenGL, aber mit
der Clutter-Bibliothek haben Entwickler
ein effizientes und freundliches Tool an
der Hand, um grafisch anspruchsvolle
Anwendungen zu entwickeln, ohne sich
mit den eher technischen OpenGL-
Bibliotheken abmühen zu müssen.
Zahlen. Bunte Zahlen. Das fängt doch schon mal gut an.
lastin=0
lastout=0
def getspeed():
x=open(‘/proc/net/dev’,’r’)
for line in x.readlines():
line=line.strip()
if (line[:4] == ‘eth0’):
line=line[5:].split()
bin=int(line[0])
bout=int(line[8])
return (bin, bout)
while True :
z= getspeed()
timedelta=time.time()-lasttime
lasttime=time.time()
sin=(float(z[0]-lastin))/(1024*timedelta)
sout=(float(z[1]-lastout))/(1024*timedelta)
print sin, sout
lastin=z[0]
lastout=z[1]
time.sleep(5)
Dies baut eine Timing-Funktion ein, sodass die Geschwindigkeit
präziser errechnet werden kann, auch wenn sich
der Unterschied natürlich nur im Millisekundenbereich bewegt.
Falls Sie aber irgendwann die Zeitperiode an einer
Stelle der Software ändern möchten, erleichtert Ihnen das
obige Skript dies.
Nun müssen wir das Skript noch in die Clutter-Anwendung
integrieren. Man könnte es einfach ans Ende des bisherigen
Programmcodes setzen, doch dann würde möglicherweise
die Clutter-Hauptschleife nie aufgerufen werden. Zwar könnten
wir die actor-Objekte immer noch zu jedem beliebigen
Zeitpunkt aktualisieren, aber das wäre keine gute Sache. Wesentlich
netter wäre es doch, den Objekten ihre Autonomie
zu lassen und den Text mithilfe einer animierten Timeline zu
kontrollieren.
Eine Timeline ist ein Timer, der bis zu einem bestimmten
Wert zählt und dann das programmiertechnische Äquivalent
eines Piepstons ausgibt – ein Signal. Das Signal kann aufgefangen
und in ein Callback eingespeist werden, und Sie können
auch andere Parameter hinzufügen. Für unsere Zwecke
stellen wir den Timer so ein, dass er eine Funktion aufruft,
welche die Netzwerkgeschwindigkeit testet und die beiden
actor-Objekte aktualisiert.
128

Coding
Die Timeline ist ein Objekt an sich, doch wenn wir die Verbindung
zwischen der Timeline und der Callback-Funktion
ausführen, können wir auch unsere Textobjekte weiterleiten,
sodass die Callback-Funktion diese direkt ändern kann.
Timelines können wie einzelne Threads in einer Multithread-Anwendung
verwendet werden. Sie sind zwar nicht so
flexibel, sind aber einfacher zu managen und erleichtern die
Behandlung animierter Objekte, insofern als sie die Animation
des Objekts und etwaige andere Interaktionen des Objekts
voneinander trennen können.
import clutter
import time
lasttime=1
lastbin=0
lastbout=0
black =clutter.Color(0,0,0,255)
red = clutter.Color(255, 0, 0, 255)
green =clutter.Color(0,255,0,255)
blue =clutter.Color(0,0,255,255)
def updatespeed(t, a, b):
global lasttime, lastbin, lastbout
f=open(‘/proc/net/dev’,’r’)
for line in f.readlines():
line=line.strip()
if (line[:4] == ‘eth0’):
line=line[5:].split()
bin=int(line[0])
bout=int(line[8])
timedelta=time.time()-lasttime
lasttime=time.time()
speedin=round((bin-lastbin)/(1024*timedelta), 2)
speedout=round((bout-lastbout)/(1024*timedelta), 2)
lastbin, lastbout = bin, bout
a.set_text(str(speedin)+’KB/s’)
xx, yy=a.get_size()
a.set_position(int((300-xx)/2),int((100-yy)/2) )
b.set_text(str(speedout)+’KB/s’)
xx, yy=b.get_size()
b.set_position(int((300-xx)/2),int((100-yy)/2)+100 )
def parseKeyPress(self, event):
# Parses the keyboard
#As this is called by the stage object
if event.keyval == clutter.keysyms.q:
#if the user pressed “q” quit the test
clutter.main_quit()
elif event.keyval == clutter.keysyms.r:
#if the user pressed “r” make the object red
self.set_color(red)
elif event.keyval == clutter.keysyms.g:
#if the user pressed “g” make the object green
self.set_color(green)
elif event.keyval == clutter.keysyms.b:
#if the user pressed “b” make the object blue
self.set_color(blue)
elif event.keyval == clutter.keysyms.Up:
#up-arrow = make the object black
self.set_color(black)
print ‘event processed’, event.keyval
stage = clutter.Stage()
stage.set_size(300,200)
stage.set_color(blue)
Eine Frage des Timings
Die Clutter-Bibliothek nutzt Timeline-
Objekte. Damit kann man fast alles
erledigen, was gemacht werden muss,
während eine Anwendung gerade läuft.
Die Timeline-Objekte sind der Herzschlag
Ihres Skripts, sie sorgen dafür,
dass alles möglichst gut zusammen
läuft. Timelines werden vielfach dafür
benutzt, um Animationen und Effekte
innerhalb von Clutter zu kontrollieren,
aber Sie können Sie auch als eigene
Interrupts verwenden und damit Routinen
aufrufen, und zwar mithilfe von
Signalen, die ausgesandt werden, um
Ereignisse wie started oder completed
hervorzurufen. Die Signale können
auch mit einer Callback-Funktion
verbunden werden, um damit noch
etwas anderes zu steuern. Dies ist
ein kurzes Beispiel-Skript, das Sie in
die Python-Shell eintippen können:
stage.connect(‘key-press-event’, parseKeyPress)
intext=clutter.Text()
intext.set_font_name(“Sans 30”)
intext.set_color(green)
stage.add(intext)
outtext=clutter.Text()
outtext.set_font_name(“Sans 30”)
outtext.set_color(red)
stage.add(outtext)
stage.show_all()
t=clutter.Timeline()
t.set_duration(5000)
t.set_loop(True)
t.connect(‘completed’, updatespeed, intext, outtext)
t.start()
clutter.main()
Hier haben wir nun sämtliche besprochenen Elemente zusammengefügt.
Wir haben eine Bühne aufgebaut, sie mit
Schauspielern bevölkert und anschließend die Timeline-Objekte
von Clutter dazu benutzt, diese sich selbst aktualisieren
zu lassen. Doch all das kratzt gerade mal an der Oberfläche
der Möglichkeiten, die Clutter Ihnen in puncto Grafik
bietet. Auf den folgenden Seiten gehen wir jedoch einen
Schritt weiter.
>>> import clutter
>>> t=clutter.Timeline()
>>> t.set_duration(2000)
>>> t.set_loop(True)
>>> def ping(caller):
... print caller
...
>>> t.connect(‘completed’,ping)
9L
>>> t.start()
>>>
Hierbei handelt es sich um eine einfache
Funktion namens ping, die lediglich
den Parameter ausgibt, mit dem es
angesprochen wurde. Wir verbinden
das completed-Signal mit der ping-
Funktion und starten die Timeline. Ohne
weitere Interaktion wird die ping-Funktion
nun alle 2 Sekunden aufgerufen.
Leider bietet
die Clutter-Website
http://blogs.
gnome.org/
clutter/ Python-
Anwendern nicht
viel Hilfreiches,
aber es gibt viele
Hintergrundinfos
und eine gute C-
Dokumentation.
129

Coding
Python: Clutter-
Gute Nachrichten: Wir kombinieren einen einfachen
RSS-Reader mit professionellen Clutter-Animationen.
Nicht alle Nachrichten sind gute Nachrichten. Mit diesem
Feed kommen sie immerhin aus einer guten Quelle.
In diesem Tutorial betrachten wir einige der mächtigen
Animationstechniken von Clutter, gruppieren Objekte
und lernen etwas über TextActors. Zu diesem Zweck entwickeln
wir einen RSS-Reader und hübschen diesen auf. Der
Platz wird nicht ausreichen, um alle Features eines Multi-
Stream-Readers zu implementieren und um die Technik des
Animierens exakt zu beleuchten, aber wir zeigen, wie man
Daten aus einem Feed ausliest und wie man diese zu Clutter-
Objekten macht. Damit bekommen Sie alle notwendigen
Grundlagen, um selbst ein solchen Monstrum entwickeln zu
können.
Wer noch nicht mit Clutter experimentiert haben sollte,
dem empfehlen wir, so viel wie möglich im interaktiven
Modus von Python zu experimentieren. Da Sie in diesem
Modus beliebigen Code sofort ausführen können, liefert diese
Umgebung weitaus schneller Ergebnisse und
Fehlermeldungen, als es der sonst übliche Normalmodus
könnte. Die Listings in diesem Tutorial zeigen die Python-
Eingabeaufforderung >>> am Anfang jeder Zeile, wenn Sie
etwas eingeben sollen. Wenn die Listings hingegen eine
Ausgabe zeigen, dann steht >>> nicht am Zeilenanfang –
sondern genau so, wie Sie es auf Ihrem Bildschirm sehen.
Fütterungszeit
Bei einem News-Reader stellt sich zuallererst die Frage, wie
wir an die News aus einem Feed herankommen. Dazu kann
man das Rad immer wieder neu erfinden, einfacher ist aber
die Verwendung einer bereits bestehenden Bibliothek – in
unserem Fall verwenden wir Feedparser.
In jedem Fall benötigen wir die URL eines Feeds. Um an
eine solche Web-Adresse zu gelangen, besuchen Sie einfach
Ihre Lieblingsseiten im Internet und halten nach dem orangefarbenen
RSS-Syndication-Symbol Ausschau. Meist ist dieses
Symbol ein direkter Link auf einen Nachrichten-Feed,
dessen Adresse Sie aus dem Browser in Ihre Anwendung
kopieren können. Um beispielsweise den TuxRadar-Feed einzulesen,
verwenden Sie die Adresse http://www.tuxradar.
com/rss. In unserem Beispiel verwenden wir hingegen den
News-Feed der BBC. Dies hat zwei Gründe: Erstens liefert er
eine Bildreferenz, die sich für unsere Clutter-Experimente
bestens eignet. Und zweitens wird der Feed regelmäßig mit
neuen Nachrichten aktualisiert, was wiederum die Tests vereinfacht.
Der BBC-Feed hat die Adresse http://newsrss.bbc.
co.uk/rss/newsonline_uk_edition/world/rss.xml.
>>> import feedparser
>>>f= feedparser.parse(‘http://newsrss.bbc.co.uk/rss/newsonline_uk_edition/world/rss.xml’)
>>>f
{‘feed’: {‘lastbuilddate’: u’Wed, 30 Dec 2010 19:11:25 GMT’, ‘sub-
Die Clutter-Website wird regelmäßig mit verbesserten
Dokumentationen und neuen Softwareversionen
aktualisiert. Regelmäßiger Besuch ist daher Pflicht.
130

Coding
Animationen
title’: u’Get the latest BBC World News: international news, features
and analysis from Africa, Americas, South Asia, Asia-Pacific,
Europe and the Middle East.’, ‘language ...
Wenn wir mit f Python veranlassen, die soeben zugewiesene
Variable anzuzeigen, dann wird der komplette
Containerinhalt ausgegeben – wir mussten ihn am Ende
abschneiden, da er den Heftumfang gesprengt hätte. Um an
einzelne, für uns interessante Bits zu gelangen, verwenden
daher wir Indizes und Schlüssel. Die einzelnen Nachrichten
befinden sich in einer Liste namens „entries“ und bestehen
aus Details wie Zusammenfassung (summary),
Zeitstempeln, Link-URL etc.
>>> f.entries[0].title
u’Nokia expands claim against Apple’
>>> f.entries[0].link
u’http://news.bbc.co.uk/1/hi/technology/8434132.stm’
>>> f.entries[0].updated_parsed
time.struct_time(tm_year=2009, tm_mon=12, tm_mday=29, tm_
hour=18, tm_min=0, tm_sec=46, tm_wday=2, tm_yday=364, tm_
isdst=0)
>>> f.entries[0].updated
u’Wed, 30 Dec 2009 18:00:46 +0000’
>>> f.entries[0].summary
u’Nokia ramps up its legal fight against Apple, claiming that almost
all of its products infringe its patents.’
Wie Sie sehen, können wir aus diesen Elementen alles
herauslesen, was ein guter RSS-Reader braucht. Zusätzlich
möchten wir nun aber auch das Feed-Bild anzeigen. Die RSS-
Spezifikationen erlauben ein (optionales) Bild, mit dem sich
der Nachrichtenkanal selbst präsentieren kann. Dieses Bild
wird mit URL, Beschreibungstext und einigen weiteren
Details im Feed mitgeliefert (genau genommen im XML-
Element „image“); Feedparser findet diese Daten und macht
sie für uns zugänglich. Im obigen Beispiel wäre die Adresse
des Bildes in der Eigenschaft f.feed.image.href gespeichert.
Da wir das Bild anzeigen werden, ist es sinnvoll, es auf den
RSS != RSS
Ein RSS-Feed enthält die unterschiedlichsten Elemente. Neben
dem Feed-Symbol nutzen wir nur solche Elemente, die es auch
garantiert in jedem Feed gibt. Wenn Sie herausfinden möchten,
was ein Feed sonst noch enthält, dann sehen sich den
Seitenquelltext an. Unangenehmerweise gibt es mittlerweile
zahlreiche Standards, da etliche Entwicklergruppen mit sehr
unterschiedlichen Ideen diverse RSS-Formate definiert haben.
Immerhin nimmt Ihnen das Feedparser-Modul den größten Teil
der daraus resultierenden Mehrarbeit ab.
Auf der Website der Universität Harvard findet sich ein
Tutorial, wie Sie selbst einen RSS-Feed erstellen können –
gleichzeitig beschreibt es, wie Sie einen solchen Feed in seine
Bestandteile zerlegen.
http://cyber.law.harvard.edu/rss/rss.html.
lokalen Rechner herunterzuladen. Dazu bietet sich das herausragende
Python-Modul urllib an, das neben vielen anderen
nützlichen Werkzeugen die urlretrieve-Methode enthält.
Diese Methode erhält eine Web-Adresse, speichert die dort
zu findenden Daten im temporären Verzeichnis (meist /tmp
auf der lokalen Festplatte) und liefert einen Dateinamen und
einige http-Informationen zurück. Die gespeicherte Datei
wird automatisch gelöscht, sobald der Speicherplatz knapp
wird. Wenn wir sauber arbeiten möchten, kann unser
Programm die Datei nach Gebrauch aber auch selbst wieder
löschen.
>>> import urllib
>>> img, data =urllib.urlretrieve(f.feed.image.href)
>>> img
‘/tmp/tmpTsCyDc.gif’
In wenigen Augenblicken werden wir mit dieser Datei etwas
Sinnvolles anstellen.
Schauspieler und Bühnen
Doch zuvor beschäftigen wir uns mit Clutter. Wenn Sie
noch nichts mit dieser Bibliothek zu tun hatten: Es handelt
sich um eine Bibliothek zur Erstellung von schnellen, grafisch
anspruchsvollen und vor allem animierten
Benutzeroberflächen. Wie fast alle Animationssysteme verwendet
auch Clutter Elemente wie Actors und Timelines –
sollten Sie tiefer in diese Materie eintauchen wollen, dann
legen wir Ihnen dringend die Lektüre der offiziellen
Dokumentation auf http://Clutter-project.org ans Herz.
Zum Hineinschnuppern in die Materie soll folgende
Kurzzusammenfassung genügen: Ein Clutter-Fenster nennt
sich „Stage“ (englisch für Bühne) und ist die Zeichenfläche
für alle Elemente und Animationen. In der Python-Variante
PyClutter ist die Stage ein normales GTK-Fenster, uns erwarten
also keine Überraschungen. Alle Elemente auf der Stage
nennen sich Actors (englisch für Schauspieler), egal ob es
sich um Texte, Formen oder Texturen handelt.
Es gibt viele
Quellen für RSS-
Feeds. Halten
Sie einfach die
Augen nach dem
orangefarbenen
Symbol mit
den drei Bögen
Ausschau.
131

Coding
Lesen bildet
In diesem Tutorial benötigen wir natürlich diese
Textelemente zur Darstellung der Nachrichtentexte, aber vor
allem interessieren uns die Texturen. Clutter gestattet es,
Texturen ohne Umwege aus einer Bilddatei zu erzeugen –
und wie es der Zufall will, haben wir vor wenigen Zeilen eine
solche Datei erstellt. Um zu zeigen, wie gut all dies zusammenspielt,
öffnen wir eine Stage und lassen das Bild auftreten:
>>> import clutter
>>> black=clutter.color(0,0,0,255)
>>> white=clutter.color(255,255,255,255)
>>> stage= clutter.Stage()
>>> stage.set_size(400,60)
>>> stage.set_color(white)
>>> stage.show_all()
>>> ident =clutter.texture_new_from_file(img)
>>> stage.add(ident)
Der Code gibt uns eine Referenz auf ein Stage-Objekt, legt
dessen Größe fest und gibt dem Hintergrund eine weiße
Farbe. Dann wird aus dem Bild eine Textur erzeugt und diese
der Stage hinzugefügt. Hier zeigt sich eine Besonderheit von
Clutter: Im Gegensatz zu vielen anderen Grafik-Toolkits darf
ein Actor auch dann noch erzeugt und gezeigt werden, wenn
die Stage bereits in Verwendung ist. Jedenfalls sollten Sie
nun in einem Fenster das altehrwürdige BBC-Logo sehen.
Dass das Logo perfekt in das Fenster passt, ist kein Zufall
– wir wussten bereits, dass das Logo 60 Pixel hoch ist und
haben die Stage entsprechend dimensioniert. Und da wir der
Logo-Textur keine Position zugewiesen haben, verwendet
Clutter die Standardwerte (0,0), die der linken oberen
Fensterecke entsprechen.
Clutter ist grandios. Das Python-Modul
ist großartig. Die Dokumentation ist
erbärmlich. Zwar sind die Klassen und
Methoden des Python-Moduls identisch
mit denen der C-Implementierung von
Clutter, dennoch gibt es einige subtile
Unterschiede, die den Programmierer in
den Wahnsinn treiben und sich nicht in
der Dokumentation finden. In solchen
Fällen sind Pythons Introspektionswerkzeuge
hilfreich, insbesondere die
dir()-Funktion. Sie zeigt alle verfügbaren
Klassen, Eigenschaften und Methoden
des jeweiligen Objekts dir(Clutter) oder
einer Methode dir(Clutter.Text).
In Bewegung setzen
Bevor wir unseren RSS-Reader fertigstellen, ein paar
Worte zum Begriff „Animation“. Im wirklichen Leben steht
dieser Begriff für die Illusion von flüssigen
Bewegungsabläufen (oder für die professionelle
Unterhaltung von Hotelgästen). In der Welt der
Computergrafik ist der Begriff etwas weiter gefasst: Er steht
für die Veränderung beliebiger Objekteigenschaften im
Zeitverlauf. Bei diesen Eigenschaften kann es sich um Farben
handeln oder um die Sichtbarkeit, aber natürlich auch um die
klassischen Bewegungseigenschaften Rotation und Position.
Ein Actor in Clutter hat eine Animate-Methode. Deren
Argumente geben den Animationsmodus an, gefolgt von der
Dauer in Millisekunden und schließlich die Eigenschaften und
Werte, die animiert werden. Der Animationsmodus legt fest,
wie schnell sich der jeweilige Eigenschaftswert im Zeitverlauf
ändert, also ob die Bewegung linear ist oder beschleunigt/
verzögert wird. Ein Modus kann jederzeit selbst definiert werden,
Clutter hat die wichtigsten Modi aber bereits eingebaut
und stellt diese mit Konstanten bereit. Hier nur eine Auswahl:
CLUTTER_LINEAR
CLUTTER_EASE_IN_QUAD
CLUTTER_EASE_OUT_QUAD
CLUTTER_EASE_IN_OUT_QUAD
CLUTTER_EASE_IN_CUBIC
CLUTTER_EASE_OUT_EXPO
CLUTTER_EASE_IN_OUT_EXPO
CLUTTER_EASE_IN_OUT_CIRC
Der lineare Modus stellt eine gleichmäßige Bewegung dar,
die Ease-Modi sind natürlich wirkende Kombinationen aus
Beschleunigung und Verzögerung, jeweils mit unterschiedlicher
Stärke dieses Effekts. Angenommen, wir haben ein
Objekt an Position 0,0 und wollen es in exakt 2.000
Millisekunden zu Position 100,0 bewegen. Nur mit einer linearen
Animation wäre es nach einer Sekunde genau an Position
50,0 – Sie dürfen hier also fleißig experimentieren, um den
für Sie optimalen Modus zu finden.
Die animate-Funktion nimmt den aktuellen
Eigenschaftswert als Startwert und das übergebene
Argument als Zielwert für die ebenfalls angegebene
Eigenschaft. Sie können beliebig viele Eigenschafts-Wert-
Paare übergeben. Nicht übergebene Eigenschaften werden
nicht animiert.
Zur besseren Vorstellung ein paar Beispiele – hoffentlich
ist Ihre Stage noch offen:
>>> ident.set_anchor_point(60,30)
>>> ident.set_position(60,30)
>>> ident.animate(clutter.LINEAR,2000,’rotation-angle-y’,720)
>>> ident.animate(clutter.LINEAR,2000,’rotation-angle-y’,720)
Beim zweiten Aufruf der Rotation ist nichts passiert. Dies
liegt daran, dass der übergebene Wert nicht angibt, um wie
viel sich eine Eigenschaft ändert, sondern mit welchem Wert
die Animation endet. Beim zweiten Aufruf war der gewünschte
Wert bereits erreicht – die Animation wurde zwar ausgeführt
und dauerte exakt zwei Sekunden, aber sie hatte keinen
sichtbaren Effekt. Sie können auch mehrere Eigenschaften
gleichzeitig animieren. Versuchen Sie Folgendes:
>>> ident.animate(clutter.LINEAR,2000,’x’,100, ‘rotation-angle-y’,
360 )
>>> ident.animate(clutter.EASE_IN_SINE,2000,’x’,0, ‘rotation-angle-y’,
0 )
In diesem Beispiel tanzt das Logo vor sich hin und kehrt
dann an die Ursprungsposition zurück.
Gruppendynamik
Mit einem drehenden Logo sind wir bereits halb am Ziel; uns
fehlen nur noch die Nachrichtenüberschrift und die
Zusammenfassung, die beide neben dem Logo angezeigt
werden sollen. Damit hätten wir drei Actors auf der gemeinsamen
Bühne.
Clutter kann durchaus jeden einzelnen Actor gleichzeitig
animieren, bei aufwendigen Animationen und bei zahlreichen
132

Coding
Actors steigt der Programmieraufwand aber schnell ins
Unermessliche. Glücklicherweise unterstützt Clutter
Gruppen, in denen mehrere Actors zusammengefasst und
dann als einzelner Actor behandelt werden. Wir erstellen also
zuerst eine solche Gruppe, definieren dann die tatsächlichen
Elemente, fügen diese der Gruppe hinzu und senden dann
die Gruppe auf die Stage. Der Einfachheit halber erzeugen wir
im Folgenden eine neue ident-Textur:
>>> group1= clutter.Group()
>>> ident1=clutter.texture_new_from_file(img)
>>> head1=clutter.Text()
>>> head1.set_position(130, 5)
>>> head1.set_color(blue)
>>> head1.set_text(f.entries[0].title)
>>> body1=clutter.Text()
>>> body1.set_max_length(75)
>>> body1.set_position(130, 22)
>>> body1.set_size(250, 100)
>>> body1.set_line_wrap(True)
>>> body1.set_text(f.entries[0].summary)
>>> group1.add(ident1, head1, body1)
>>> group1.show_all()
>>> stage.add(group1)
In diesem Code haben wir eine Textur und zwei
Textobjekte erzeugt – eins repräsentiert die Titelzeile der
Nachricht (head1) und eins die Zusammenfassung (body1).
Die Texte stammen aus dem ersten Eintrag, den das Feed-
Objekt enthält. Beide Textobjekte wurden linksbündig neben
die Logo-Textur gesetzt. Es sieht zwar so aus, als hätten wir
für die drei Actors absolute Koordinaten verwendet, tatsächlich
aber beziehen sie sich auf die linke obere Ecke des
Group-Objekts: Mit group1.add() werden die Actors Kinder
der Gruppe und alles, was für die Gruppe gilt, gilt auch für
deren Kinder – in diesem Fall die Position der Gruppe, die
zunächst den Standardwert (0,0) hat.
Daher gilt Folgendes:
>>> head1.get_position()
(130,5)
>>> group1.set_position(10,10)
>>> head1.get_position()
(130,5)
>>> group1.set_position(0,0)
Wenn Sie die Position der Gruppe verändern, dann sehen
Sie, wie sich Textur und Text bewegen – aber Vorsicht: Die
Kindelemente wissen von dieser Bewegung nichts! Deren
Positionseigenschaften haben sich nicht verändert, denn diese
beziehen sich ja auf die Position innerhalb ihrer Gruppe
– und es war die Gruppe, deren Positionseigenschaft sich
geändert hat.
Dies hat den angenehmen Nebeneffekt, dass wir nur noch
diese eine Gruppe animieren müssen, um sämtliche
Bildschirmelemente zu bewegen.
>>> group.animate(clutter.LINEAR,2000,”x”,200,”y,”30”)
>>> group.animate(clutter.LINEAR,2000,”x”,0,”y,”0”)
Hier bewegen sich alle Elemente synchron, als ob sie nur
ein einzelnes Element wären (was sie aus Code-Sicht auch
sind). Wir könnten dennoch beispielsweise den Text oder die
Position einzelner Elemente verändern, nur dass diese
Änderungen relativ zur Gruppe und nicht zur Bühne wären.
Wir erstellen nun eine zweite Gruppe und zwei
Animationsmodi, um einen schönen Übergang von einer
Nachricht zur nächsten zu erzeugen:
>>> group2= clutter.Group()
>>> ident2=clutter.texture_new_from_file(img)
>>> head2=clutter.Text()
>>> head2.set_position(130, 5)
>>> head2.set_color(blue)
>>> head2.set_text(f.entries[1].title)
>>> body2=clutter.Text()
>>> body2.set_max_length(75)
>>> body2.set_position(130, 22)
>>> body2.set_size(250, 100)
>>> body2.set_line_wrap(True)
>>> body2.set_text(f.entries[1].summary)
>>> group2.add(ident2, head2, body2)
>>> group2.hide()
>>> stage.add(group2)
>>> group1.animate(clutter.EASE_OUT_EXPO,4000,’x’,800,’ y’,0,’rotation-angle-y’,180)
>>> group2.animate(clutter.EASE_OUT_
EXPO,1,’x’,400,’y’,100,’rotation-angle-y’,720)
>>> group2.show()
>>> group2.animate(clutter.EASE_OUT_
EXPO,3000,’x’,0,’y’,0,’rotation-angle-y’,0)
Bevor wir die neue Gruppe zur Stage hinzufügen, haben
wir sie unsichtbar gemacht. Dann wurde sie aus dem sichtbaren
Bereich herausanimiert und wieder sichtbar gemacht.
Auf diese Weise stört sie nicht die Darstellung der ersten
Gruppe. Um eine zweite Nachricht zu zeigen, animieren wir
einfach die zweite Gruppe zurück in den Bildschirm hinein
und lassen die (nun überdeckte) erste Gruppe verschwinden.
Nächste Schritte
Mit diesem Wissen können Sie nun einen sehenswerten RSS-
Reader erstellen. Ganz wichtig sind Tests auf potenzielle
Fehler: Was, wenn der Feed nicht erreichbar ist oder keinen
Eintrag hat? Außerdem könnte die jeweils sichtbare News
alle paar Sekunden automatisch durch eine andere ersetzt
werden. Und jeder bessere RSS-Reader fasst mehrere Feeds
zusammen und möglicherweise möchten Sie anstelle des
Feed-Logos das Bild der Nachricht selbst anzeigen.
Mit solchen
Animationen
werten auch
professionelle
News-Portale
und TV-Sender
den endlosen
Strom ihrer
Nachrichten auf.
133

Programmiersprachen
134

Programmiersprachen
Sprachen
Nun ist es Zeit für weitere Fortschritte - der
Raspberry Pi bietet sich dafür an, denn auf ihm
laufen perfekt die Sprachen Python und
Scratch. Mit dem ARM-Rechner können Sie sogar
noch weitere Sprachen lernen.
Andere Sprachen......................................................................................136
Begeisterung für OpenEuphoria...................................................138
Ein kurzer Lehrgang in Go.................................................................142
Listig mit Lisp..............................................................................................146
C++: So geht’s...........................................................................................150
Fortan Fortran.............................................................................................154
Lua: Erste Schritte..................................................................................158
135

Programmiersprachen
Andere Sprachen
Für den Fall, dass Sie gerne eine andere Programmiersprache als Python
auf dem Raspberry Pi ausprobieren möchten, stellen wir Ihnen hier eine
Auswahl vor.
Für die ersten Schritte als angehender Programmierer
auf dem Raspberry Pi sind die Sprachen Scratch (insbesondere
auch für Kinder) sowie Python gut geeignet.
Speziell mit Python lässt sich eine ganze Menge anstellen.
Wer damit bereits ein bisschen Erfahrung gesammelt hat,
könnte vielleicht Lust bekommen, seinen Sprachenhorizont
zu erweitern. Auf den folgenden Seiten möchten wir Ihnen
einige alternative Programmiersprachen genauer vorstellen.
In diesem Beitrag hier geht es jedoch zunächst darum, wie
man diese Sprachen auf dem Raspberry Pi installiert, um
damit arbeiten zu können.
Euphoria
Um Euphoria installieren zu können, benötigen Sie zunächst
die auf Ihre Distribution zugeschnittene Version von OpenEuphoria.
Hinsichtlich der Operationen auf Gleitkommazahlen
ist es ferner wichtig, ob die Distribution Hard Float oder Soft
Float unterstützt, das heißt, ob sie die Gleitkommaeinheit in
der Hardware des Raspberry Pi nutzt oder nicht. Wir spielen
das Ganze einmal für die Raspbian-Distribution durch. Tippen
Sie
wget http://openeuphoria.org/eubins/linux/4.1.0/arm-32-bit/
eubin-arm-cortex-a8-2012-01-13-ee49c6b8a340.tar.gz
in die Kommandozeile. Dann entpacken Sie die Binärdistribution,
erstellen einen Ordner dafür, ändern die Benutzerrechte
und kopieren Euphoria in den Ordner:
gunzip eubin-arm-cortex-a8-2012-01-13-ee49c6b8a340.tar.gz
tar -xvf eubin-arm-cortex-a8-2012-01-13-ee49c6b8a340.tar
sudo mkdir -p /usr/share/euphoria/bin
sudo chown -R pi.users /usr/share/euphoria/
mv *.tar ../.
cp * /usr/share/euphoria/bin/.
Damit die entsprechenden Tools verwendet werden können,
wo immer sie benötigt werden, muss Euphoria noch der
PATH-Variablen hinzugefügt werden. Öffnen Sie dazu die
.bashrc-Datei mit
nano ~/.bashrc
und hängen Sie Folgendes ans Ende der Datei, bevor Sie sie
speichern:
PATH=$PATH:/usr/share/euphoria/bin
export PATH
Um sicherzugehen, dass der Pfad korrekt eingerichtet ist und
Euphoria funktioniert, führen Sie noch folgende Kommandos
aus:
source ~/.bashrc
echo $PATH
eui -v
Wenn alles in Ordnung ist, können Sie mithilfe von wget die
Quelldateien sowie Beispiele von http://sourceforge.net/
projects/rapideuphoria/files/Euphoria/4.0.5/
euphoria-LINUX-4.0.5-src.tar.gz herunterladen. Nähere
Infos zum Problem Hard Float versus Soft Float bekommen
Sie unter http://openeuphoria.org/wiki/view/
EuphoriaAndRaspberryPi.wc.
Go
Auch bei Go besteht das Gleitkommaproblem. Damit der
Code funktioniert, muss er für den Raspberry Pi kompiliert
sein. Immerhin ist es kein Problem, Programme, die auf dem
Raspberry Pi geschrieben und kompiliert worden sind, auf
anderen Plattformen auszuführen.
Euphoria: Sie können den Code mit Syntaxhervorhebung
bearbeiten und im Hintergrund laufen lassen.
136

Programmiersprachen
Die Installation von Go ist ziemlich simpel. Öffnen Sie dazu
Ihre .bashrc-Datei und fügen Sie die nachfolgenden Variablen
ein:
GOARM=5
GOOS=linux
GOARCH=arm
GOPATH= (your package root)
Die erste Zeile ist die wichtigste, denn diese legt fest, dass für
einen ARMv5-Chip kompiliert werden soll.
Holen Sie sich dann die relevanten Pakete vom Go-Repository
auf Google Code und kompilieren Sie sie (Letzteres dauert
etwa eine Stunde):
sudo apt-get install mercurial
sudo apt-get install git
hg clone -u tip https://code.google.com/p/go
cd go/src
./all.bash
Wenn Sie einen Raspberry Pi mit 256 MB RAM benutzen,
stellen Sie sicher, dass in der Konfigurationsdatei raspi-config
die Speicheraufteilung so gewählt ist, dass der Anteil, der für
die CPU reserviert ist, möglichst groß ist.
C++
C++ ist eine tolle, raffinierte Programmiersprache, aber leider
auch sehr kompliziert. Es kann Ihnen passieren, dass Sie sich
schon bald nach Python zurücksehnen. Falls Sie sich an C++
herantrauen, ist aber zumindest die Installation einfach.
Wenn Sie bereits die Entwicklungsumgebung Geany (siehe
Seite 96) auf Ihrem Raspberry Pi haben, brauchen Sie gar
nichts weiter zu tun, sondern können sofort mit C++ loslegen.
Es lohnt sich, darüber hinaus die Bibliothek BCM2835
von Mike McCauley zu holen, denn damit können Sie im Rahmen
Ihrer C- und C++-Projekte die GPIO-Pins des Raspberry
Pi steuern. Sie finden alle nötigen Anleitungen unter
www.raspberry-projects.com/pi/programming-in-c/
c-libraries/bcm2835-by-mike-mccauley.
Lisp
Die Polnische Notation (oder Präfixnotation) mag insbesondere
für Einsteiger eine Herausforderung darstellen, doch
Lisp lohnt dennoch die Anstrengung. Falls Sie Raspbian auf
Ihrem Raspberry Pi verwenden, können Sie ohne Umwege
CLISP, eine Implementierung von Common Lisp, verwenden.
Geben Sie dazu lediglich folgendes Kommando:
sudo apt-get install clisp
Damit holen Sie sich das komplette Paket. Common Lisp,
eine objektorientierte Programmiersprache, erschien zuerst
im Jahr 1984. Ab Seite 146 in diesem Handbuch erfahren Sie
mehr darüber.
Go: Datei gelöscht und beim nächsten Durchlauf wiederhergestellt. Es läuft
auch outputDone().
Fortran
Um Fortran laufen zu lassen, brauchen Sie keine speziellen
Tools, sondern nur einen Compiler. Es gibt eine Auswahl
möglicher Compiler für den Raspberry Pi, allerdings spielt es
aus technischer Sicht keine große Rolle, welchen Sie verwenden,
außer vielleicht bei sehr umfangreichen Programmen.
Holen Sie sich zum Beispiel den Compiler gfortran mit
dem Paket-Manager.
Lua
Lua, eine tolle Skriptsprache, ist auf einem Raspbian-System
kinderleicht zu installieren. Tippen Sie apt-get install lua in
ein Terminal, und Sie erhalten die Kommandozeilenversion.
Es sind aber auch grafische Benutzeroberflächen und interessante
Tools erhältlich. Wir empfehlen GameCake, bei dem
Sie zusätzlich zu den normalen Bibliotheken 2D-Grafik und
Joystick-Unterstützung bekommen. GameCake können Sie
auf http://cake.4lfa.com/gamecake herunterladen.
Lua: Den Code
ein paarmal
laufen lassen,
dann die Datei
ausgeben, um zu
sehen, ob alles in
Ordnung ist.
Lisp: Addition, Listen, Variablendefinition in Slime.
137

Programmiersprachen
Begeisterung für
OpenEuphoria
Wir begeben uns nach Euphoria und entdecken eine gut lesbare,
leicht erlernbare und überaus schnelle Sprache.
Die Programmiersprache Euphoria kam im Jahre 1993
als Shareware auf den Markt. Mittlerweile steht sie
unter einer Open-Source-Lizenz, wird ständig weiterentwickelt
und ist für die unterschiedlichsten Plattformen
inklusive Linux erhältlich. Obwohl Euphoria eine Interpreter-
Sprache ist, ist sie extrem schnell. Zudem kann sie in C übersetzt
und anschließend kompiliert werden. Und mit einem
Minimum an Interpunktionszeichen sowie mit knapp gehaltenen
Schlüsselwörtern ist Euphoria auch noch schnell zu
schreiben.
Wer sich der Objektorientierten Programmierung verschrieben
hat, wird dennoch keine Freude an dieser Sprache
haben: Mit dem prozedurale Aufbau, der kaum vorhandenen
Typenüberprüfung und den reduzierten
Funktionsdefinitionen entspricht Euphoria nicht mehr den
Paradigmen der heutigen Zeit. Und da die zahlreichen
Schlüsselwörter meist englischen Begriffen entsprechen,
erinnert ein Listing stets an Pseudocode – aber es ist
Pseudocode, der tatsächlich funktioniert.
Sie finden den Download auf der OpenEuphoria-Webseite
http://www.openeuphoria.org. Die derzeit stabile Version
hat die Nummer 4.0.5 und ist für Debian und Windows sowie
als generisches tar.gz verfügbar. Der Quellcode sowie
Nightly-Builds stehen ebenfalls zum Download bereit.
Wenn Sie das tar.gz-Paket installieren, dann sollten Sie es
im Verzeichnis /usr/local entpacken. Anschließend editieren
Sie /etc/profile oder erstellen eine eu.cfg-Datei; beides
mit folgendem Inhalt:
/pfad/zu/euphoria/include
Damit teilen Sie Euphoria mit, wo die
Standardbibliotheken zu finden sind. Alternativ können Sie
auch die Umgebungsvariable $EUINC definieren.
/path/to/euphoria/include
Dies informiert Euphoria über den Ort der unterschiedlichen
Standardbibliotheken. Die Umgebungsvariabel $EUINC
liefert übrigens das gleiche Ergebnis.
Hello World
Wir starten mit dem Programm Hello World. Dazu erstellen
wir eine Datei helloworld.ex (Konsolenprogramme verwenden
gewöhnlich die Erweiterung .ex, GUI-Anwendungen
die Erweiterung .exw und importierte Dateien und
Bibliotheken die Erweiterung .e):
puts(1, “Hello, World\n”)
Sie starten das Programm mit eui helloworld.ex und sollten
nun die zu erwartende Ausgabe sehen.
puts() steht für „put string“ und begegnet Ihnen in auch
vielen anderen Programmiersprachen. Hier erwartet es zwei
Argumente: Das erste Argument sagt Euphoria, wohin die
Ausgabe gehen soll (1 ist das Datei-Handle der
Standardausgabe), das zweite ist der auszugebende String.
printf() wird ebenfalls unterstützt und eignet sich für komplexere
oder formatierte Ausgaben.
Um in eine echte Datei zu schreiben, öffnen wir zuerst die
Datei und weisen das erhaltene Datei-Handle einer Integer-
Variablen zu:
integer myfile
constant STDERR = 2
constant STDOUT = 1
myfile = open(“myfile.txt”, “w”)
if myfile = -1 then
puts(STDERR, “couldn’t open myfile\n”)
else
puts(STDOUT, “file opened\n”)
puts(myfile, “Hello, World\n”)
close(myfile)
end if
In Euphoria gibt es nur vier Dateitypen, integer ist eine
davon. Hier deklarieren wir die die Variable myfile als integer,
anschließend versuchen wir, die Datei mit Schreibzugriff
zu öffnen. Wenn dies gelingt, dann erhalten wir eine positive
Ganzzahl als Datei-Handle. Wenn es fehlschlägt, dann erhalten
wir -1. Wir prüfen den Erfolg (die if/then-Syntax birgt keinerlei
Überraschungen, aber achten Sie auf das abschließende
end if) und handeln entsprechend. Wir schreiben nicht
nur in die Datei, sondern auch in die Standardausgabe oder
in die Standardfehlerausgabe, deren Datei-Handles 1 und 2
immer verfügbar sind. Nach getaner Arbeit schließen wir die
Datei.
Typen und Unterprogramme
Nun wagen wir uns an eine größere Aufgabe. Wir entwickeln
ein Programm für die Zeitmanagementmethode Pomodoro,
das uns nach einer vorgegebenen Zeitspanne an etwas erinnert.
In der ersten Programmversion lassen wir uns nur wenige
Sekunden warten:
include std/os.e
global integer Seconds = 5
global object Message = “Time’s up!\n”
procedure ring_alarm(object alarm_text)
puts(1, alarm_text)
end procedure
procedure run_alarm()
sleep(seconds)
ring_alarm(message)
end procedure
138

Programmiersprachen
run_alarm()
In der ersten Zeile importieren wir eine
Standardbibliothek, mit der wir unter anderem Zugriff auf die
systemeigene sleep()-Funktion haben. Dann deklarieren wir
zwei Variable. Wie bereits erwähnt, stehen uns dafür nur vier
Typen zur Auswahl:
object (kann jeden Wert annehmen);
sequence (eine Sequenz beliebiger Objekte);
atom (Zahlen aller Art);
integer (Ganzzahlen zwischen -1073741824 und
+1073741823; für größere Ganzzahlen muss atom verwendet
werden)
Die Definition eigener Datentypen ist ebenfalls möglich, würde
den Rahmen dieses Tutorials aber sprengen.
Da numerische Operationen mit integer sind schneller als
die gleichen Operationen mit atom sind, wählen wir für die
Seconds-Variable den Typ integer.
Ein Euphoria-Unterprogramm ist entweder eine Prozedur
(procedure) oder eine Funktion (function). Eine Prozedur
kann Parameter entgegennehmen. Eine Funktion kann dies
auch, zusätzlich gibt sie einen Wert zurück. Sowohl
Prozeduren als auch Funktionen werden mit end
[procedure|function] abgeschlossen und wie üblich werden
beide durch ihren Namen aufgerufen.
In unserem Beispiel haben wir den Programmcode auf
zwei sehr einfache und sehr kurze Prozeduren verteilt. Dies
vereinfacht die Erweiterung unseres Programms – immerhin
wissen wir bereits jetzt, dass der Code in den nächsten
Schritten weiter anwachsen wird. Speichern Sie den Code in
der Datei pomodoroalarm.ex und starten Sie das Programm
mit eui pomodoroalarm.ex. Nach fünf Sekunden sollten
Sie in der Konsole eine Meldung sehen.
Coding-Standards
Fünf Sekunden sind zum Testen okay, aber die Pomodoro-
Technik schreibt 25 Minuten vor. Also passen wir das
Programm entsprechend an:
global atom Seconds
function set_alarm(atom minutes)
return minutes * 60
end function
procedure run_alarm()
Seconds = set_alarm(25)
-- rest of procedure as before
end procedure
Wenn Sie das Programm starten, dann werden Sie nach
25 Minuten den Alarm sehen. Für weitere Tests empfehlen
wir, die 25 mit einem kleinen Wert wie 0.1 zu ersetzen.
Beachten Sie, dass minutes den Typ atom hat, ansonsten
wären wir auf ganze Minuten beschränkt. Auch Seconds hat
nun diesen Datentyp, da es sonst Fehlermeldungen hageln
Euphoria in Editoren
würde: Würden wir set_alarm(0.01) aufrufen, dann wäre das
Ergebnis die Zahl 0.6, die wiederum nicht einer integer-Variable
zugewiesen werden kann.
Ein Hinweis auf Coding-Standards: In Euphoria ist es
üblich, dass der Name lokaler Variablen kleingeschrieben
wird, Konstantennamen nur aus Großbuchstaben bestehen,
globale Variablen mit Großbuchstaben beginnen und dass
Unterstriche einzelne Namensbestandteile trennen.
Sie können sich an diese Standards halten, eine technische
Notwendigkeit dafür besteht jedoch nicht. Beachten Sie
aber, dass Euphoria zwischen Groß- und Kleinschreibung
unterscheidet.
Zurück zu Pomodoro: Nach 25 Minuten Arbeit schreibt
das System eine Pause von fünf Minuten vor. Um unser
Programm entsprechend anzupassen, legen wir die beiden
Zeitspannen in einer sequence ab und bearbeiten diese in
einer Schleife:
global object Work_message = “Arbeitszeit beendet\n”
global object Break_message = “Pause beendet!\n”
global atom Work_minutes = 25
global atom Break_minutes = 5
procedure run_alarm()
sequence pomodoro = {Work_minutes, Break_minutes}
sequence pomodoro_message = {Work_message, Break_message}
for i=1 to length(pomodoro) by 1 do
sleep(set_alarm(pomodoro[i]))
ring_alarm(pomodoro_message[i])
end for
end procedure
Dieser Code ist ziemlich selbsterklärend. Wir erstellen
zwei Sequenzen; eine für die Zeitspannen und eine für die
Alarmmeldungen. Dann verwenden wir die eingebaute length()-Funktion,
um über die Sequenzen zu iterieren und für
jeden Eintrag sleep() und ring_alarm() aufzurufen. Beachten
Sie, dass Euphoria den Indexwert 1 für den ersten Eintrag
verwendet.
Der Code ist fehleranfällig: Was wäre, wenn pomodoro
und pomodoroMessage unterschiedliche Längen hätten?
Diesen potenziellen Absturz können wir umgehen, wenn wir
eine Sequenz von Sequenzen verwenden, um die
Zeitspannen und Nachrichten zu verwalten:
procedure run_alarm()
sequence pomodoro = {{Work_minutes, Work_message},
{Break_minutes, Break_message}}
for i=1 to length(pomodoro) by 1 do
sleep(set_alarm(pomodoro[i][1]))
ring_alarm(pomodoro[i][2])
end for
end procedure
Ein ähnliches Ergebnis erhielten wir auch, wenn wir andere
globale Variable definieren würden:
Schnelltipp
Um den Programmablauf
zu verfolgen
(also ihn Anweisung
für Anweisung zu
durchschreiten),
schreiben Sie an den
Anfang Ihres Programms
diese
zwei Zeilen:
with trace
trace(1)
Euphoria wird mit dem speziell angepassten
Editor ed.ex ausgeliefert. Um diesen zu verwenden,
fügen Sie das Euphoria-bin-Verzeichnis dem
PATH in .bashrc hinzu:
PATH=$PATH:/usr/share/euphoria/bin
Um den Editor zu starten, tippen Sie
PATH=$PATH:/usr/share/euphoria/bin
To use it, type
eui ed.ex file.ex
Im Vergleich zu Editoren wie Vim oder Emacs ist
macht ed einen schlichten Eindruck, aber immerhin
verfügt er über Syntax-Highlighting. Mit einer
Besonderheit ist er diesen beiden Konkurrenten
überlegen: Wenn Sie direkt nach einem Euphoria-
Fehler ed ohne Argumente starten, dann liest er
die ex.err-Datei aus und springt direkt zu derjenigen
Code-Stelle, an der der Fehler aufgetreten
ist.
In der Praxis werden Sie jedoch schnell aus ed
herauswachsen und sich nach Alternativen
umsehen. Im OpenEuphoria-Wiki sind weitere
Editoren aufgelistet.
Um Vim wenigstens Syntax-Highlighting und
Einrückungen beizubringen, installieren Sie die
vom eu-editor bereitgestellten Dateien in die
geeigneten Vim-Verzeichnisse und fügen Sie diese
Zeile der Datei filetype.vim hinzu:
au BufNewFile,BufRead *.ex setf euphoria
Auch für MicroEmacs, Nano und andere stellt
das eu-editor Projekt ähnliche Features bereit
139

Programmiersprachen
global sequence Work_settings = {Work_minutes, Work_message}
global sequence Break_settings = {Break_minutes, Break_message}
procedure run_alarm()
sequence pomodoro = {Work_settings, Break_settings}
-- for-Schleife wie zuvor
end procedure
Wie Sie sehen, führen in Euphoria viele Wege zum gleichen
Ziel. Welchen Weg Sie wählen, bleibt Ihren persönlichen
Vorlieben überlassen.
Als Nächstes werden wir den Benutzer fragen, wie lange
er arbeiten und pausieren möchte. Dazu erzeugen wir eine
Funktion, die den Benutzer zur Eingabe auffordert:
include std/io.e
include std/get.e
procedure get_alarm_times()
puts(STDOUT, “Please enter work minutes: “)
sequence result = get(STDIN)
Work_minutes = result[2]
puts(STDOUT, “Please enter break minutes: “)
sequence result = get(STDIN)
Break_minutes = result[2]
end procedure
procedure run_alarm()
get_alarm_times()
-- rest is as before
end procedure
Die Bibliothek std/io.e definiert für uns die Konstanten
STDOUT, STDIN und STDERR. get() (aus der Bibliothek
std/get.e) liest einen String aus einer Datei bzw. von der
Standardeingabe und konvertiert ihn in eine Zahl. Wir hätten
auch andere Funktionen wie gets() verwenden können, aber
diese hätten nicht die automatische Umrechnung in eine
Zahle für uns übernommen. get() nimmt folgende Parameter
entgegen:
get(integer file, integer offset = 0, integer answer = GET_SHORT_
ANSWER)
file ist das Datei-Handle, aus dem gelesen werden soll.
offset ist die Stelle innerhalb dieser Datei, ab der gelesen
wird. answer legt fest, welche Werte get() zurückliefern
soll:
GET_SHORT_ANSWER : {integer return_status, object value_read}
GET_LONG_ANSWER : {integer return_status, object value_read,
integer num_characters_read, integer initial_whitespace}
Der return_status kann GET_SUCCESS, GET_EOF,
GET_FAIL oder GET_NOTHING sein. Der Einfachheit halber
werten wir den Status nicht aus – in dem Wissen, dass fehlerhafte
Eingaben das Programm zum Absturz bringen werden.
Da wir aus STDIN lesen, können wir auf die Angabe von offset
und answer verzichten und erhalten den kürzeren der
beiden Rückgabewerte. Den gesuchten Wert finden wir an
zweiter Stelle der Sequenz und speichern ihn in Work_minutes
bzw. Break_minutes.
Wenn Sie das Programm nun starten, dann müssen Sie
feststellen, dass die neuen Werte offenbar ignoriert werden.
Was passiert hier?
Das Problem ist, dass sich die Zeitspannen-Variablen
zwar verändern, diese Änderungen aber nicht automatisch
an Work_settings und Break_settings weitergereicht werden.
Es gibt mehrere Lösungen dafür:
-- Option 1
procedure get_alarm_times()
-- as above
Work_settings[1] = Work_minutes
Break_settings[1] = Break_minutes
end procedure
-- Option 2
procedure run_alarm()
get_alarm_times()
sequence pomodoro = {{Work_minutes, workMessage},
{Break_minutes, breakMessage}}
-- as before
end procedure
Ein Zwischenkommentar über Kommentare: Euphoria
verwendet -- für einzeilige Kommentare und /* … */ für
mehrzeilige.
Externe Musik
Wenn Sie gerade tief in Ihrer Arbeit versunken sind, dann
werden Sie die kleine Textmeldung im Konsolenfenster vermutlich
nicht bemerken. Ein Alarmsound wäre die Lösung,
doch leider gibt es nur in der Windows-Version von Euphoria
Zugriff auf Systemklänge, nicht aber für Linux. Also werden
wir ein externes Programm starten und dieses eine MP3-
Datei abspielen lassen:
global object Play_alarm_command = “mpg123 -q alarm.mp3”
procedure ring_alarm(object alarm_text)
puts(1, alarm_text)
system(Play_alarm_command, 2)
end procedure
Wir haben die Anwendung mpg123 gewählt, da sie ein
einfaches Kommandozeilenprogramm ist, welches ganz
ohne eigene Textausgabe laufen kann (die Option -q).
Wenn Sie eine andere Anwendung bevorzugen, dann
können Sie diese natürlich auch verwenden – die system()-Funktion
wird sie in jedem Fall starten. Der Modus
2 besagt, dass der Grafikmodus nach Programmende
nicht wiederhergestellt wird. Da mpg123 den Bildschirm
nicht verwendet, müssen wir uns um den Grafikmodus
nicht sorgen.
Wenn Sie dieses Programm starten, dann wird
irgendwann die Musik anfangen zu spielen. Erst nach-
Weitere Features von Euphoria
OpenEuphoria enthält in der aktuellen Version
zahllose APIs, die für nahezu jeden Einsatzzweck
effiziente und bestens dokumentierte Funktionen
bereitstellen. So gibt es APIs für Mathematik und
für internetspezifische Techniken wie HTTP, DNS
und URLs, für die Unterstützung von lokalisierten
Anwendungsoberflächen und für vieles mehr.
Euphoria ermöglicht auch echtes Multitasking,
was insbesondere die Entwickler von Spielen
oder lange andauernden Hintergrundaufgaben
interessieren dürfte. Für die Sicherheitsexperten
gibt es mit dem Import std/unittest.e und dem
Programm eutest automatisierte Unit-Tests zum
Überprüfen des korrekten Programmablaufs.
Wenn Sie den grafischen Weg einschlagen möchten,
dann haben Sie mit std/graphics.e Zugriff
auf Cross-Plattform-Konsolengrafiken und mit
std/image.e auf Bitmaps. Alternativ gibt es auch
eine GTK-Grafikbibliothek auf http://eugtk.wikispaces.com,
die sogar Glade unterstützt.
Die Nutzung von C-Code ist ebenfalls möglich:
Mit open_dll(), Funktionsdeklarationen und c_
func() oder c_proc() steht dem Zugriff auf beliebige
.dll- und .so-Dateien nichts im Weg.
Selbst für Datenbankaufgaben ist die Sprache
geeignet: Sie kann jede Standarddatenbank
ansprechen und liefert für die etwas kleineren
Projekte mit dem Euphoria Database System
auch eine eigene, Euphoria-orientierte Datenbank
mit.
140

Programmiersprachen
dem Sie mit [Strg]-[C] die Musik beenden, läuft das
Programm weiter. In diesem Fall dürfte das der
gewünschte Ablauf sein, in anderen Fällen möchten Sie
aber vielleicht, dass Ihr Hauptprogramm während der
Musikwiedergabe weiterläuft. Dieses sogenannte
Multitasking starten Sie mit dem fork()-Befehl. Weitere
Informationen zum Multitasking finden Sie in der
Euphoria-Dokumentation.
Ein Nachtrag zur if/else-Syntax in Euphoria: Auch dieser
Blocktyp wird mit einem end * abgeschlossen. Wenn Sie
einen else-Zweig benötigen, dann wird dieser auf folgende
Weise verwendet:
if a = b then
-- - Anweisungen
elseif a = c then
-- andere Anweisungen
else
-- ganz andere Anweisungen
end if
Wir machen noch schnell eine weitere
Programmverbesserung: Wir fragen den Benutzer, wie
viele Wiederholungen der Arbeit/Pause-Kombinationen
(die Pomodoros) er haben möchte oder ob er alternativ
die 25/5-Minuten-Intervalle ändern möchte. Die Abfrage
findet in der Funktion get_number_pomodoros() statt
und die Fallunterscheidung in set_timing().
Wenn der Benutzer 0 gewünschte Pomodoros angibt,
dann lassen wir ihn seine eigenen Zeitintervalle festlegen.
In jedem Fall aber verwenden wir in run_alarm() zwei
for-Schleifen, um über die gewünschte Pomodoro-Anzahl
und über die beiden Zeitspannen zu iterieren.
Operationen & Sequenzen
Die verschachtelten for-Schleifen machen einen unaufgeräumten
Eindruck. Ein Blick in das Euphoria-Handbuch zeigt
zahllose Möglichkeiten, mehrere Sequenzen miteinander zu
verbinden oder einzelne Sequenzen zu wiederholen. Da gibt
es unter anderem den &-Operator sowie die Funktionen
append() und repeat(). Damit sollten wir eine Alarm-
Sequenz wie diese erzeugen können:
{{Work_minutes, Work_message}, {Break_minutes, Break_message},
{Work_minutes, Work_message}, {Break_minutes, Break_message}}
In der Praxis stellt sich dieses Unterfangen als recht kompliziert
heraus, da jede Verkettungsmethode ihre ganz speziellen
Eigenheiten hat:
append({a, b}, {c, d}) = {a, b, {c, d}}
append({Work_minutes, Work_message}, {Break_minutes, Break_
message})
= {Work_minutes, Work_message, {Break_minutes, Break_message}}
{a, b} & {c, d} = {a, b, c, d}
{Work_minutes, Work_message} & {Break_minutes, Break_message}
= {Work_minutes, Work_message, Break_minutes, Break_message}
repeat({a, b, c, d}, 2) = {{a, b, c, d}, {a, b, c, d}}
repeat({Work_minutes, Work_message, Break_minutes, Break_
message}, 2)
= {{Work_minutes, Work_message, Break_minutes, Break_message}
{Work_minutes, Work_message, Break_minutes, Break_message}}
repeat({a, b, {c, d}}, 2) = {{a, b, {c, d}}, {a, b, {c, d}}
repeat({Work_minutes, Work_message, {Break_minutes, Break_
message}}, 2)
= {{Work_minutes, Work_message, {Break_minutes, Break_message}}
{Work_minutes, Work_message, {Break_minutes, Break_message}}}
Damit bleiben uns zwei Möglichkeiten, unsere
Alarmsequenz mit Sequenz-Operationen zu erzeugen:
procedure set_timing()
Number_pomodoros = get_number_pomodoros()
if Number_pomodoros = 0 then
get_alarm_times()
Number_pomodoros = 1
end if
Alarm_sequence = repeat(Work_settings & Break_settings,
Number_pomodoros)
/* Alarm_sequence now looks like {{W_min, W_mess, B_min, B_
mess},
{W_min...}, ... } */
end procedure
procedure run_alarm()
set_timing()
for i=1 to Number_pomodoros by 1 do
sleep(set_alarm(Alarm_sequence[i][1]))
ring_alarm(Alarm_sequence[i][2])
sleep(set_alarm(Alarm_sequence[i][3]))
ring_alarm(Alarm_sequence[i][4])
end for
end procedure
Dies erzeugt eine Sequenz einer vierteiligen Sequenz. Die
Alternative dazu lautet:
procedure set_timing()
-- as above
Alarm_sequence = repeat({Work_settings, Break_settings},
Number_pomodoros)
/* Alarm_sequence now looks like {{{W_min, W_mess}, {B_min,
B_mess}},
{{W_min...}, {B_min..}}, ... }*/
end procedure
procedure run_alarm()
set_timing()
for i=1 to Number_pomodoros by 1 do
sleep(set_alarm(Alarm_sequence[i][1][1]))
ring_alarm(Alarm_sequence[i][1][2])
-- could also use another for loop here
sleep(set_alarm(Alarm_sequence[i][2][1]))
ring_alarm(Alarm_sequence[i][2][2])
end for
end procedure
Beide Varianten sind nicht lesbarer als eine doppelte for-
Schleife. Es bleibt Ihrem Geschmack überlassen, welche
Lösung Sie wählen.
Und weiter geht’s!
Wie immer gibt es viele unterschiedliche Möglichkeiten und
Ansätze, das jeweilige Programm zu verbessern.
Beispielsweise könnten Sie mit einem Countdown Minute für
Minute herunterzählen, oder Sie könnten eine hübsche und
aufgeräumte Programmoberfläche mit großen Start-/Stop-
Schaltern entwickeln. In diesem Tutorial sollten Sie jedenfalls
jetzt bereits gelernt haben, dass Euphoria eine schnelle
Sprache mit klaren Fehlermeldungen ist, in die man sich
leicht einarbeitet.
141

Programmiersprachen
Ein kurzer
Lehrgang in Go
Go ist schnell und typsicher, bereinigt den Speicher automatisch
und ist nebenläufig. Ein kurzer Blick auf die Sprache.
Go, auch als Golang bekannt, ist eine Open-Source-
Sprache mit statischer Typisierung. Der von Google
entwickelte Compiler wurde entwickelt, um mit
Nebenläufigkeit (also Multitasking) die Entwicklung beliebig
skalierbarer Systeme zu ermöglichen und trotz aller Features
einer modernen Sprache die Programme schnell zu kompilieren
und ablaufen zu lassen. Solche Features sind insbesondere
die Typsicherheit, die Reflexion und die Garbage
Collection. Auch Objektorientierung wird unterstützt, allerdings
ohne das übliche Klassenkonzept.
Erste Schritte
Um in die Go-Programmierung einzusteigen, installieren wir
den Linux-Tarball, den wir von http://golang.org/doc/
install herunterladen und mit sudo tar -C /usr/local/-
zxf go1.1.1.linux-386.tar.gz im Verzeichnis /usr/local installieren.
Anschließend passen wir die $PATH-
Umgebungsvariable in .bashrc oder .profile an, damit
auch /usr/local/go/bin im Suchpfad enthalten ist.
Alternativ könnten wir auch den Quellcode selbst kompilieren
und das Kompilat installieren. Anschließend
erstellen wir uns eine Verzeichnisstruktur, die laut den
Go-Richtlinien folgendermaßen aussehen muss:
my_go_dir/
bin/

Programmiersprachen
möglich gewesen, was uns die Angabe des Zeilenumbruchs
erspart hätte. Wie Sie sehen, fängt der Funktionsname mit
einem Großbuchstaben an. Im Gegensatz zu vielen anderen
Sprachen ist die richtige Groß- und Kleinschreibung von
Bedeutung, beispielsweise werden nur Funktionen mit
Großbuchstaben exportiert.
Ihnen ist vermutlich auch aufgefallen, dass die einzelnen
Zeilen nicht mit einem Semikolon abgeschlossen wurden.
Tatsächlich sieht die Sprachdefinition diese Semikolons vor,
aber der Compiler setzt diese im Normalfall selbst an die
richtige Stelle. Wenn der Compiler ohne weitere
Informationen auf einen Zeilenumbruch stößt, dann vermutet
er ein logisches Zeilenende und setzt das Semikolon.
Daher muss beispielsweise die öffnende Klammer einer
Ein richtiges Programm
Hello World ist unverzichtbar, um in einer neuen Sprache die
ersten Schritte zu erlernen. Nun aber wollen wir etwas
Nützlicheres schreiben. Wenn Sie bereits in der
Vergangenheit Programmiersprachen erlernt haben, haben
Sie vermutlich bereits die eine oder andere To-do-Liste entwickelt.
Für unseren nächsten Schritt machen wir das exakte
Gegenteil: Wir programmieren einen Schon-erledigt-
Anwendung. Sie fragt den Benutzer, was er gerade gemacht
hat, und speichert dies. Zunächst wird das Programm nach
Input fragen und die Eingabe gleich wieder ausgeben.
Erstellen Sie ein neues Verzeichnis src/repo.com/name/
donelist und erzeugen Sie die Datei donelist.go:
// Package runs a program to record items done and output them.
package main
import “fmt”
var (
done string
)
func main() {
getDone()
outputDone()
}
// getDone fragt den Benutzer nach einer erledigten Aufgabe func
getDone() {
fmt.Printf(“What did you do? “)
fmt.Scan(&done)
}
// outputDone gibt die Aufgabe aus
func outputDone() {
fmt.Println(“You did:”)
fmt.Println(done)
}
Kommentare dienen in Go auch dazu, mittels godoc automatisch
eine Dokumentation zu erstellen. Daher sollten am
Form- und Namenstandards
if-Anweisung immer in der gleichen Zeile wie das if selbst
stehen:
if j < 1 {
beliebige Anweisungen
}
// not....
if j < 1
{ // Upps. Der Compiler hat an das Ende der obigen Zeile ein
Semikolon gesetzt
}
Zurück zu Hello World. Um das Programm zu kompilieren
und auszuführen, wechseln Sie mit cd in das Verzeichnis
repo.com/name/hello und tippen go install – gefolgt
von $GOPATH/bin/hello – ein.
Anfang jedes Paket ein paar erklärende Worte stehen, ebenso
sollte über jeder öffentlichen Funktion deren
Verwendungszweck und Anforderungen genannt sein.
Im var-Block werden Variablen deklariert und gegebenenfalls
mit einem Startwert initialisiert. Für Konstanten würde ein
const-Block dienen. Da wir done in mehreren Funktionen dieses
Pakets verwenden, wurde done im globalen var-Block definiert.
fmt.Scan() liest aus der Standardeingabe in eine
Variable. Beachten Sie das Et-Zeichen in &done: Wenn in
Go eine Variable an eine Funktion übergeben wird, dann
erhält die Funktion eine Kopie dieser Variable.
Änderungen an dieser Kopie ändern nicht das Original.
Hätten wir also fmt.Scan(done) aufgerufen, dann hätte sich
nach Beendigung von getDone() nichts geändert, das Originaldone
wäre noch immer leer. Um auch Originale an Funktionen
zu übergeben, behilft man sich mit Verweisen (auch Zeiger,
Referenzen oder Pointer genannt): Verweise zeigen auf den
Speicherbereich, an dem die Variable liegt. In Go liefert &done
also die Speicheradresse der Variablen done (beispielsweise
12345678). fmt.Scan() dereferenziert diesen Verweis (mit
*done), um an den Variablenwert zu gelangen. Das heißt, dass
der Verweis &done für den Funktionsaufruf kopiert wurde,
aber da die Kopie von 12345678 noch immer 12345678 ist,
zeigt auch die Kopie an die richtige Adresse und Scan() kann
das Original verändern.
Kompilieren Sie das Programm mit go install und starten
Sie es mit donelist. Sie werden nun nach einer Eingabe
gefragt. Geben Sie zunächst ein einzelnes Wort ein und erfreuen
Sie sich an der originalgetreuen Ausgabe. Wenn Sie es aber
mit mehreren Wörtern versuchen, dann wird das Programm
scheitern. Der Grund dafür ist die Funktion fmt.Scan(), deren
Einsatzzweck das Einlesen eines einzelnen Wortes ist. Für
mehrere Wörter brauchen wir also eine andere Lösung.
Schnelltipp
Sie werden häufig
ein library.go-
Paket im /lib-
Verzeichnis erstellen,
das mit
package library
beginnt, und eine
application.
go-Datei im /
src-Verzeichnis.
Letzteres startet
package main und
importiert library.
Mit Go wird ein Tool namens gofmt ausgeliefert,
das Ihren Code einliest und mit Standard-
Einrückungen versieht. Bevor Sie Ihren Code
anderen zeigen, sollten Sie ihn unbedingt durch
dieses Tool laufen lassen. Auch die
Namenskonventionen gilt es zu beachten:
Paketnamen sind kurz und bestehen aus einem
Wort in Kleinbuchstaben. Variablen und
Funktionen in Kleinbuchstaben werden nicht
außerhalb ihrer Paketgrenzen exportiert (sie sind
also privat), Variable und Funktionen mit
Großbuchstaben hingegen schon (sie sind daher
public). Sie sollten dies stets beachten, wenn Sie
sich für Ihre Variablen und Funktionen einen Namen
ausdenken. Für lange Namen oder Zusammensetzungen
mehrerer Wörter sind Binnenmajuskel
(FunktionsName) sogar mit kleinem
Anfangsbuchstaben (funktionsName) möglich.
143

Programmiersprachen
Schnelltipp
Die eingebaute
Funktion println()
eignet sich zur
Fehlersuche, für
die Ausgabe zum
Benutzer sollten
Sie aber fmt.
Println()
verwenden.
println() schreibt
auf stderr und
nicht auf stdout,
zudem wird die
Funktion möglicherweise
aus der
Sprache entfernt.
Die erste
Programm
version läuft.
Ignorieren Sie
unbedingt den
Compiler-Fehler
in diesem Bild.
Puffer in Go
Eine Lösung des Multi-Wort-Problems wäre ein Array, das
wir in einer Schleife mit fmt.Scan() befüllen. Der Aufwand
wäre allerdings unverhältnismäßig hoch – immerhin würden
wir fmt.Scan() zu etwas benutzen, wofür es nicht gedacht
war. Stattdessen verwenden wir Buffer.IO aus dem
bufio-Paket. Hier ist ein erster Ansatz, getDone() umzuschreiben
(wir zeigen nur die Code-Änderungen):
import (
“bufio”
“fmt”
“os”
)
const delimiter = ‘\n’
func getDone() {
fmt.Printf(“What did you do? “)
r := bufio.NewReader(os.Stdin)
done, err := r.ReadString(delimiter)
if err != nil {
println(err)
os.Exit(1)
}
}
Der Versuch, dies zu kompilieren, endet mit einer
Fehlermeldung:
$ go install
# repo.com/juliet/donelist
./donelist.go:28: done declared and not used
Deklaration in Go
Woher kommt diese Fehlermeldung? Die Ursache ist hinter
der :=-Zuweisung verborgen. In Go verwendet man :=, um
Variablen in einer Anweisung zu deklarieren und zuzuweisen.
Man kann := auch verwenden, um einer Variablen einen neuen
Wert zuzuweisen – aber nur wenn diese Variable aus dem
aktuellen Gültigkeitsbereich stammt und wenn mindestens
eine andere Variable in dieser Anweisung neu deklariert wird.
Der folgende Code würde daher funktionieren:
func getDone() {
fmt.Printf(“What did you do? “)
r := bufio.NewReader(os.Stdin)
myDone := “ping”
myDone, err := r.ReadString(delimiter)
if err != nil {
println(err)
os.Exit(1)
}
println(myDone)
}
Wenn Sie dies ausführen, dann würde jede Eingabe
zunächst in myDone gespeichert und mit der Println()-
Anweisung ausgegeben werden.
Warum funktioniert es also für myDone, aber nicht für
done? Weil done aus dem globalen Gültigkeitsbereich
kommt und := daher eine neue, lokale Variable namens done
erstellt. Mit folgendem Code umschiffen wir diese Klippe:
func getDone() {
fmt.Printf(“What did you do? “)
r := bufio.NewReader(os.Stdin)
line, err := r.ReadString(delimiter)
if err != nil {
println(err)
os.Exit(1)
}
outputDone(line)
}
func outputDone(done string) {
println(“You did:”)
fmt.Println(done)
}
Dieser Code zeigt, wie man eine Funktion mit Argumenten
deklariert: func funktionsName (variablenName variablenTyp).
Außerdem kommt dieser Code ganz ohne globale
Variable aus – gleichzeitig ist er aber recht unordentlich, da
er nicht sauber zwischen Dateneingabe und -ausgabe trennt.
Eine weitere Variante mit globaler Variante wäre Folgendes:
func get_done() {
fmt.Printf(“What did you do? “)
r := bufio.NewReader(os.Stdin)
line, err := r.ReadString(delimiter)
if err != nil {
println(err)
os.Exit(1)
}
done = line
}
// And go back to calling output_done() with no arguments in
main()
Und noch eine Version:
var err error
done, err = r.ReadString(delimiter)
Hier deklarieren wir zuerst die lokale err-Variable und verwenden
anschließend das klassische = als Operator für die
Zuweisung von r.ReadString() zu den beiden globalen und
lokalen Variablen.
Mit jeder der genannten Varianten sollte Ihr Programm
nun mehrere Worte entgegennehmen und ausgeben können.
Dateien in Go
Wenn wir die Benutzereingaben in eine Datei speichern
möchten, um sie eventuell später wiederzuverwenden,
erwarten uns mit Go keine großen Überraschungen:
import (
“io/ioutil”
)
func main() {
getDone()
writeToFile()
}
func writeToFile() {
t := []byte(done)
err := ioutil.WriteFile(“>>output.txt”, t, 0644)
if err != nil { panic(err) }
}
Dies ist die einfachste von zahllosen Möglichkeiten, Daten
in eine Datei zu schreiben. Vorsicht: Bei großen
Datenmengen wird dieser Ansatz fehlschlagen. Wir verwandeln
done in einen byte-Slice und verwenden ioutil.
WriteFile, um den Slice in eine Datei zu speichern. Und da
wir gerade dabei sind, setzen wir die Dateiberechtigungen auf
144

Programmiersprachen
0644.Beachten Sie die Fehlerbehandlung, die auf Probleme
beim Schreiben der Datei prüft.
Zur Auflockerung ein kurzer Überblick über Slice: Ein Slice
ist einem Array sehr ähnlich, hat aber keine feste Größe. Im
obigen Beispiel haben wir den byte-Slice auf Basis des done-
Strings erstellt. Man kann einen Slice auch mit der
make-Funktion erstellen, man kann ihn re-slicen (also verkleinern),
kopieren und vergrößern.
Wenn Sie den Code testen und anschließend die output.
txt-Datei öffnen, dann scheint das Programm korrekt zu
funktionieren. Nach einem weiteren Programmstart zeigt
sich jedoch, dass der alte Dateiinhalt überschrieben wurde.
Da WriteFile() keinen Anhänge-Modus hat, verwenden wir
eine andere Funktion:
func writeToFile() {
f, err := os.OpenFile(“output.txt”, os.O_APPEND|os.O_WRONLY,
0644)
if err != nil { panic(err) }
defer f.Close()
if _, err = f.WriteString(done); err != nil {
panic(err)
}
}
Hier öffnen wir zuerst die Datei mit os.OpenFile(), da wir
in dieser Funktion den Dateimodus angeben können. In unserem
Fall verwenden wir O_APPEND, um neue Daten an das
Ende der bestehenden Datei anzuhängen, und O_WRONLY
für den Schreibzugriff. Wieder geben wir
Dateiberechtigungen an, die aber nur beim ersten Erstellen
der Datei angewendet werden.
Mit der defer-Anweisung vereinfacht Go die notwendigen
Aufräumarbeiten. Die Anweisung legt die übergebene
Funktion f.Close() auf einen Stapel und arbeitet diesen nach
dem Ende der aktuellen Funktion ab. Das hat den Vorteil,
dass f.Close() auch dann die Datei schließt, wenn in der
Funktion ein schwerer Fehler auftritt (beispielsweise wenn
WriteString() fehlschlägt).
Der Code enthält eine weitere Form der
Fehlerbehandlung: WriteString() ist in einem if-Statement
eingebettet und die Funktion würde entsprechend verzweigen.
Aber sobald wir output.txt löschen würden, scheitert
dieser Ansatz. Also erstellen wir eine Funktion, welche die
Existenz einer Datei testet und sie gegebenenfalls erstellt:
func checkFileExists(file string) {
if _, err := os.Stat(file); os.IsNotExist(err) {
f, err := os.Create(file)
if err != nil { panic(err) }
f.Close()
}
}
In diesem Code fällt der Unterstrich auf: _. Sie können ihn
wie eine Variable in einer Zuweisung verwenden, wenn Sie an
dem Wert nicht weiter interessiert sind. Im obigen Fall gibt
os.Stat() eine FileInfo-Struktur und einen Fehlerwert
zurück. Da wir nur an diesem Fehlerwert interessiert sind,
schreiben wir die FileInfo-Struktur in _ und kümmern uns
nicht mehr um diesen Wert.
Da die Go-Erfinder all dies vorhergesehen haben, gibt es
einen weitaus kürzeren Weg – wir verwenden einen zusätzlichen
Flag für OpenFile():
f, err := os.OpenFile(“output.txt”, os.O_APPEND|os.O_
WRONLY|os.O_CREATE, 0644)
Wenn Sie nun output.txt löschen und das Programm
starten, dann wird output.txt automatisch neu erzeugt. Wenn
Sie hingegen die Datei nicht löschen, dann wird die vorhandene
Datei weiterverwendet.
Datei gelöscht
und neu erzeugt
– nun muss nur
noch outputDone()
funktionieren.
Einen Slice anzeigen
Nun, da unsere Aufgaben in der Datei gespeichert sind, benötigen
wir noch eine Methode, sie da wieder herauszuholen.
Hier ist eine kurze Funktion dafür:
func main() {
outputWholeList()
}
var (
outputFile = “output.txt”
)
func outputWholeList() {
fileContent, err := ioutil.ReadFile(outputFile)
if err != nil { panic(err) }
allDones := strings.Split(string(fileContent), string(delimiter))
for i, v := range allDones {
fmt.Printf(“%d: %s \n”, i, v)
}
}
ReadFile() rgibt den Dateiinhalt als byte-Slice zurück. Wir
konvertieren die Bytes in einen String und verwandeln diesen
mit string.Split() in einen String-Slice und speichern das
Ergebnis in allDones. Schließlich verwenden wir das
Schlüsselwort range, um über allDones zu iterieren. i ist
dabei die Indexnummer (beginnend mit 0) und v der
Schleifenwert. Printf() formatiert schließlich beides zu
einem hübschen String.
Wie Sie dies mit der main()-Funktion verknüpfen und
in welcher Reihenfolge Sie die Unterfunktionen aufrufen,
überlassen wir Ihnen. Bevor Sie aber ein großer Fan
dieser jungen Programmiersprach werden, legen wir
Ihnen noch ein Wort der Warnung ans Herz: Go ist nach
wie vor in Entwicklung und etliche Sprachelemente dürften
sich in den nächsten Monaten verändern.
Das Programm
läuft gut, aller
dings ist die Leer
zeile ein echter
Schönheitsfehler.
145

Programmiersprachen
Listig mit Lisp
Mit der Programmiersprache Lisp werden Sie lernen, anders zu
denken und Klammern zu lieben.
Lisp erblickte 1958 das Licht der Welt und ist damit
(nach dem ein Jahr älteren Fortran) die zweitälteste
Hochsprache, die noch immer in Gebrauch ist. Der
Name leiten sich ab von LISt Processing, da der Code und die
Daten in weiten Teilen auf Listen basieren. Streng genommen
sind Code und Daten in Lisp sogar austauschbar.
Lisp wurde in den letzten 60 Jahren stetig weiterentwickelt
und an neue Gegebenheiten angepasst. So gibt es heutzutage
drei weitverbreitete Dialekte::
Common Lisp,gewann mit einem großen Standardwortschatz
und einem Objektsystem seine alte Popularität zurück.
Scheme, teilt sich wegen des eher minimalistischen und
klaren Aufbaus nur wenige Features mit Common Lisp.
Clojure, kompiliert direkt in den Bytecode der Java
Virtual Machine und hat unter Java-Programmierern
Freunde gefunden.
Es gibt sogar Lisp-Dialekte, die als Skriptsprache verwendet
werden. So gibt es beispielsweise Emacs-Lisp und Gimp
Script-fu.
Zum Einstieg in die Sprache eignen sich alle drei großen
Dialekte. Im Folgenden werden wir Common Lisp verwenden,
welcher nicht auf Klein- und Großschreibung achtet.
Einstieg in Lisp
Addition, Listen
und Variablendefinition
in
Slime.
Starten Sie SBCL/Slime (siehe Kasten auf dieser Seite), um
zur Eingabeaufforderung zu gelangen (* oder CL_USER). Um
die Syntax kennenzulernen, versuchen wir uns an einer einfachen
Addition:
* (+ 2 2)
4
* (+ 2 2 2)
6
* (+ 1 2 3 4)
10
Diese Zeilen zeigen zwei Grundlagen von Lisp. Da sind
zum einen die runden Klammern, die jede Liste umschließen.
Zum anderen stehen Funktionsnamen stets am Anfang einer
Liste. Für die Addition darf die Liste beliebig lang sein.
Und wie sieht das Standardprogramm Hello World aus?
* (print “Hello World”)
“Hello World”
“Hello World”
Der Interpreter zeigt den String zweimal an. Dies ist nichts
Ungewöhnliches, denn wie andere Interpreter auch führt Lisp
die Funktion aus (daher die erste Ausgabe) und zeigt anschließend
deren Rückgabewert an (daher die zweite Ausgabe).
Programme dauerhaft ablegen
Bis jetzt haben wir den Code direkt in den Interpreter eingegeben.
Sobald wir ihn beenden, wären unsere Programme also verschwunden.
Um eine Programmdatei zu erstellen, verwenden Sie einen
beliebigen Editor und erstellen die Datei hello.lisp mit dem Inhalt
(print “Hello World”)
Sie können das Programm nun mit sblc --script hello.lisp
ausführen. Es wird den Text inklusive der Anführungszeichen
und ohne Zeilenumbruch ausgeben. Verwenden Sie princ
anstelle von print, um die Anführungszeichen zu unterdrücken.
Und mit WRITE-LINE erhalten Sie einen Zeilenumbruch.
Common Lisp installieren
Um den Beispielen zu folgen, sollten Sie
sich SBCL (Steel Bank Common Lisp, die
populärste Linux-Installation) installieren.
Sie installieren die Sprache mit Ihrem
Paketmanager oder laden sie selbst von
der SBCL-Webseite http://www.sbcl.org
herunter. Zusätzlich sollten Sie Emacs
und Slime installieren (ebenfalls mittels
Paketmanager oder Download) und diese
Kombination als Entwicklungsumgebung
verwenden. Slime bringt Emacs eine
Befehls-Chronik, Tab-Autokomplettierung
und eine Funktionsdokumentation
um unteren Bildrand bei. Fügen Sie
diese Zeilen zu ~/.emacs hinzu:
;; Set up Common Lisp
(add-to-list ‘load-path “/usr/share/common-lisp/source/slime/”)
(setq inferior-lisp-program “/usr/bin/sbcl”)
(require ‘slime)
(slime-setup)
;; Use highlight colors
(global-font-lock-mode t)
Starten Sie nun Emacs, geben Sie M-x
slime ein und schon erhalten Sie eine
CL-USER-Eingabeaufforderung.
So sieht Slime beim ersten Programmstart aus.
146

Programmiersprachen
Atome, (Listen), car und cdr
Werfen wir einen Blick auf die Grundlagen der Lisp-Syntax.
Alles in Lisp ist eine sogenannte S-Expression, bei der es sich
um Atome (Zahlen, Strings, Symbole) oder um Listen handeln
kann. Atome geben sich selbst zurück:
* 2
2
* “hello”
“hello”
Ein Symbol entspricht in etwa dem Namen einer
Variablen. Namen dürfen keine Leerzeichen enthalten oder
mit Zahlen anfangen. Weder 3 noch 3e4 sind gültige Namen
und würden vom Interpreter als Zahlen (die letztere mit
So speichert Lisp eine Liste mit vier Einträgen: Jeder
Eintrag ist das car eines cons-Paares
Ein erstes Lisp-Programm
Das erste richtige Lisp-Programm soll eine kleine
Fotodatenbank sein. Wir definieren für jedes Foto ein paar
Daten und erstellen dann eine Liste aller Bilder. Wie oben
beschrieben, können Sie die Code-Abschnitte entweder
direkt im SBLC/Slime starten oder sie als separate
Programmdatei ausführen
Zunächst definieren wir einen einzelnen Eintrag. Dafür
werden wir eine Hashtabelle verwenden, einen Datentyp, der
eine Reihe von Schlüssel-/Wert-Paaren verwaltet.
Hier ist der Code, der die Hashtabelle photo erzeugt und
mit drei Schlüssel-/Wert-Paaren “category”, “tag” und “location”
füllt:
* (setq photo (make-hash-table :test ‘equal))
* (setf (gethash “category” photo) “pets”)
* (setf (gethash “tag” photo) (list “dog” “sunset” “beach”))
* (setf (gethash “location” photo) “Camber Sands”)
Wir übergeben :test ‘equal an die MAKE-HASH-TABLE-
Funktion, damit sie einen Gleichheitstest durchführen kann.
Ohne dieses Argument wüsste die Hashtabelle nicht, wie es
die Schlüssel mit Hash-Werten abgleichen sollte
Um einen Eintrag zu erstellen, verwenden wir GETHASH,
um diesen (wertfreien) Eintrag zu erhalten. Dann setzen
Exponent) verwendet werden. Die Konventionen schreiben
vor, dass man meine-variable anstatt meine_variable verwendet,
dass globale Variable von *sternen* und dass
Konstanten mit +plus-zeichen+ eingerahmt werden.
Listen
Listen bestehen aus zwei Teilen: Dem ersten Listenelement,
das aus historischen Gründen car genannt wird (Contents of
Address Register), und dem Rest der Liste, der cdr genannt
wird (Contents of Decrement Register). car muss entweder
ein Symbol, eine Funktion oder ein Lambda-Ausdruck (mehr
dazu später) sein. Wenn es ein Symbol ist, dann wendet Lisp
es auf den gesamten Rest der Liste an:
* (* 2 3 6)
36
* (list 3 4 5)
(3 4 5)
* (cons 5 6)
(5 . 6)
Das *-Symbol multipliziert den Rest der Liste. Die
list-Funktion macht aus dem Rest der Liste eine neue
Liste und die cons-Funktion macht aus zwei
Listenelementen ein Paar (das keine Liste ist – beachten
Sie den Punkt, der die Elemente trennt).
Unter der Haube sind Listen eigentlich miteinander verknüpfte
Paare. In jedem dieser Paare ist car der Wert des
Listenelements und cdr ein Verweis auf das nächste Paar.
Das Paar mit dem cdr-Wert NIL ist das Ende der Liste.
NIL hat in Lisp mehrere Aufgaben. Als Atom entspricht es
dem logischen FALSCH (jeder andere Wert entspricht dem
logischen WAHR) und als Liste entspricht es einer leeren
Liste. Somit wird () als NIL interpretiert. Wenn Sie ein logisches
WAHR benötigen, dann gebieten die Konventionen die
Verwendung von T.
wir den Wert dieses Schlüssel-/Wert-Paars mit SETF auf
einen neuen Wert. Da ja zum Zeitpunkt der ersten
GETHASH-Aufrufe noch kein entsprechendes Paar existiert,
erzeugt Lisp automatisch neue, uninitialisierte Paare.
Um einen Wert aus der Hashtabelle auszulesen, verwenden
wir GETHASH:
* (gethash “category” photo)
“pets”
T
Dies zeigt den unter “category” gespeicherten Wert an,
gefolgt von einem T (dem logischen WAHR, da der Eintrag
existiert).
Nun machen wir uns das Leben etwas einfacher, indem
wir eine Funktion definieren, welche category, taglist und
location in eine neue Hashtabelle speichert:
(defun make-photoinfo (location taglist category)
(setf photo (make-hash-table :test ‘equal))
(setf (gethash “location” photo) location)
(setf (gethash “tag” photo) taglist)
(setf (gethash “category” photo) category)
photo)
Das Symbol DEFUN gibt an, dass wir nun eine
Schnelltipp
Lisp ist eine funktionale
Programmiersprache
und dürfte
daher keine
Funktion besitzen,
welche „Seiteneffekte“
verursachen
– wie etwa die
PRINT-Funktion,
die einen Text auf
dem Bildschirm
ausgibt. Einer 60
Jahre alten
Sprache macht
man aber keine
entsprechenden
Vorwürfe, außerdem
haben alle
praxisnahen funktionalen
Sprachen
Seiteneffekte. Wer
eine „rein funktionale“
Sprache
sucht, wird mit
XSLT, Miranda und
Clean fündig.
147

Programmiersprachen
Schnelltipp
Schnelltipp
Um eine Programmdatei
direkt auszuführen,
fügen Sie ihr
die Shebang- Zeile
#!/usr/bin/sbcl
--script
hinzu und machen
die Datei ausführbar.
Funktion definieren. Anschließend folgt der Name
make-photoinfo der Funktion und anschließend die
Parameterliste. Danach kommt der Funktionsrumpf und
eine weitere Zeile: das photo am Funktionsende. Dies ist
der Rückgabewert der Funktion, der in Lisp stets an letzter
Stelle der Definition stehen muss. Hätten wir diese
Zeile weggelassen, würde die Funktion den category-Wert
zurückgeben,
Grundsätzlich hat eine Funktionsdefinition folgende
Struktur::
(DEFUN name (parameter_liste)
(funktions_koerper)))
Beachten Sie, dass es sich hier um eine Liste handelt. Die
Reihenfolge der Elemente ist erfreulicherweise die gleiche,
wir in jeder anderen Programmiersprache, aber es ist dennoch
eine echte Lisp-Liste.
Da wir mehr als nur ein Foto speichern wollen, benötigen
wir nun eine globale Liste, die alle Fotos aufnimmt:
(defvar *photolist* nil)
DEFVAR definiert eine Variable, und mit den Sternchen
zeigen wir, dass *photolist* eine globale Variable ist.
Schleifen
Beachten Sie, dass DEFVAR nur für die erste
Variablendefinition gültig ist – um eine Variable neu
zuzuweisen, verwenden Sie DEFPARAMETER.
Vorausplanung
Um dieser Liste ein Foto zuzuweisen, könnten wir die PUSH-
Funktion verwenden. Es ist aber einfacher und zukunftssicherer,
für diesen Zweck eine add-photoinfo-Funktion zu
erstellen:
(defun add-photoinfo (photo) (push photo *photolist*))
Die add-photoinfo-Funktion ist recht einfach: Sie hat nur
einen einzigen Parameter und fügt diesen mit PUSH der Liste
*photolist* hinzu. Nun können wir in unserer Fotodatenbank
mehrere Einträge speichern:
(add-photoinfo (make-photoinfo “London” ‘(dog park) “pets”))
(add-photoinfo (make-photoinfo “London” ‘(baby park)
“family”))
(add-photoinfo (make-photoinfo “Venice” ‘(canal building) “holidays”))
Geben Sie *photolist* ein, um den Inhalt der Liste zu sehen.
Lisp behandelt
„Buchstaben in
doppelten
Anführungszeichen“
als Strings.
Ein einzelnes
Anführungszeichen
veranlasst Lisp,
den folgenden Wert
nicht auszuwerten,
sondern ihn als
Datum zu behandeln.
‘dies gibt
daher dies zurück
und ist besonders
in Funktionen und
Makros nützlich.
Wenn Sie nun *photolist* eintippen, dann sehen Sie nur eine
Liste von Hashtabellen-Beschreibungen. Für eine sinnvollere
Ausgabe entwickeln wir daher eine Funktion, die mit einer
Schleife über die Liste iteriert und die einzelnen Werte der
Hashtabelle ausgibt. In Lisp sind die häufigsten Konstrukte
für diesen Zweck Makros und basieren auf der sehr einfachen
und meist kompliziert zu verwendenden DO-Funktion:
DOLIST und DOTIMES.
DOLIST iteriert über die
Listeneinträge und wendet
den Funktionsrumpf auf diese
Einträge an – ähnlich wie
foreach in anderen
Sprachen. DOTIMES ist eine
Zählerschleife, welche den Funktionsrumpf mit der angegebenen
Häufigkeit ausführt. Hier ist eine mathematische
Anwendung von DOTIMES:
(dotimes (i 5)
(print (* i i)))
0 1 4 9 16 NIL
Beachten Sie, dass der angegebene Vergleichswert 5 nicht
erreicht wird.
DOLIST hingegen iteriert über eine Liste. In unserer Funktion
show-photo-details durchläuft sie *photolist* und stellt
dabei jeden Eintrag in der Variable photo bereit:
(defun show-photo-details ()
(dolist (photo *photolist*)
(setf photoinfo nil)
(push (gethash “category” photo) photoinfo)
(push “category” photoinfo)
(push (gethash “tag” photo) photoinfo)
(push “tag” photoinfo)
(push (gethash “location” photo) photoinfo)
(push “location” photoinfo)
(format t “~{~a - ~a~%~}” photoinfo)))
Im Schleifenrumpf von DOLIST erstellen wir eine temporäre
Liste namens photoinfo und verwenden GETHASH, um den
entsprechenden Wert dieser Liste hinzuzufügen. Darüber
hinaus erhält die Liste auch noch die Namen dieser Werte.
„DOLIST entspricht etwa der
foreach-Schleife anderer
Sprachen“
Die FORMAT-Funktion selbst mag hässlich sein, sie verpasst
der Ausgabe aber ein sehenswertes Format. Alle FORMAT-
Direktiven fangen mit dem Tildezeichen ~ an. Das ~{ ... ~} iteriert
über die eine Liste (in unserem Fall photoinfo). ~a gibt
das nächste Argument aus, gefolgt von einem Bindestrich
und gefolgt vom nächsten Argument. Damit erhalten wir
als Ausgabe mehrere „Name - Wert“-Paare.
Diesen Code könnten wir
schöner gestalten, wenn
wir die MAPHASH-
Funktion verwenden würden.
Diese ist dazu da, aus
einer Hashtabelle eine Liste
zu erzeugen. Außerdem
teilen wir den Code in mehrere Funktionen auf:
(defun print-hash (key value)
(format t “~5t~S - ~S~%” key value))
(defun show-single-photo (photo)
(maphash #’print-hash photo))
(defun show-photo-details-2 (mylist)
(setf pageno 1)
(dolist (photo mylist)
(write-line (concatenate ‘string “Photo “ (write-to-string pageno)))
(show-single-photo photo)
(incf pageno)))
print-hash legt mittels FORMAT fest, wie ein Name/Wert-
Paar angezeigt werden soll (~S ist der Platzhalter für die
Argumente key und value hinter dem Formatstring).
show-single-photo übergibt diese Funktion an MAPHASH,
die sie auf ihren Rückgabewert anwendet.
Nun packen wir das alles in showphoto-details-2 in eine
DOLIST-Schleife und verschönern die Ausgabe ein wenig:
Jedes Foto erhält eine Nummer und einen Titel. Beachten
Sie, dass Sie CONCATENATE mitteilen müssen, welcher Typ
zurückgegeben werden soll – in diesem Beispiel ist es ‘string.
148

Programmiersprachen
Makros: Code schreibt sich selbst
Makros sind in Lisp ein mächtiges Hilfsmittel,
doch leider reicht der Platz für eine eingehende
Betrachtung nicht aus. Daher die grundlegende
Idee in aller Kürze: Ein Makro macht aus Lisp-
Code Lisp-Code (im Gegensatz zu Funktionen,
die aus Lisp-Datenwerten andere Lisp-
Datenwerte berechnen). Bevor ein Programm
ausgeführt wird, sucht der Compiler im gesamten
Code nach solchen Makros und „führt sie
aus“, genau genommen expandiert er sie. Der
ermittelte Lisp-Code ersetzt nun die ehemaligen
Makro-Aufrufe und der Compiler kann das
Programm erstellen. Sie können sich ein Makro
wie eine Vorlage für immer wiederkehrende,
meist kurze Code-Fragmente vorstellen, die keine
oder nur geringe Unterschiede aufweisen.
Das von Lisp bereitgestellte WHEN-Makro hat
folgenden Code:
(defmacro new-when (condition &rest body)
`(if ,condition (progn ,@body)))
Beachten Sie das einzelne Anführungszeichen.
Es sagt dem Compiler, dass alles Folgende
kopiert anstatt ausgewertet wird – sofern es
nicht mit einem Komma beginnt. Daher werden
condition und @body beim Expandieren des
Makros ausgewertet (es werden also die an das
Makro übergebenen Parameterwerte verwendet),
if und progn aber unverändert kopiert.
Aus diesem Code
(new-when (= x 3)
(setq x 4))
wird also dieser:
(if (= x 3)
(progn (setq x 4)))
Auch in diesem Tutorial haben wir bereits
Makros eingesetzt: DEFVAR, PUSH und DOLIST
sind Makros. Mit DEFMACRO könnten Sie jederzeit
neue Versionen dieser Makros definieren,
Sie können aber auch Wrapper für jedes beliebige
Code-Konstrukt schreiben, das sich nicht als
Funktion darstellen lässt. Auf diese Weise lässt
sich Lisp nach Lust und Laune erweitern – auf
effizienteste Weise, da der resultierende Code ja
dorthin kopiert wird, wo er benötigt wird.
Lambda-Funktionen
Zum Abschluss wenden wir uns einem letzten Lisp-ismus zu:
Den Lambda-Funktionen. Hierbei handelt es sich einerseits
um ein Modewort (keine Programmiersprache, die etwas auf
sich hält, darf derzeit auf Lambda-Ausdrücke verzichten),
andererseits einfach nur um Funktionen, die als Parameter
an andere Funktionen übergeben werden. Und da sie dazu
keinen Funktionsnamen benötigen, nennt man sie auch anonyme
Funktionen.
Hier ist ein einfaches Beispiel:
* (remove-if-not #’oddp ‘(1 2 3 4 5))
(1 3 5)
* (remove-if-not #’(lambda (x) (= 3 x)) ‘(1 2 3 4 5))
(3)
Die obere Version zeigt lediglich, wie REMOVE-IF-NOT
funktioniert: Es gibt eine Liste mit Elementen zurück, die dem
ersten Funktionsparameter entsprechen – in diesem Fall
ODDP, das nur für ungerade Zahlen WAHR ist. Die
#-Notation verrät Lisp, dass nun ein Funktionsname folgt.
Die zweite Version macht prinzipiell das Gleiche, nur dass
anstelle von ODDP eine Lambda-Funktion verwendet wird. In
unserem Fall vergleicht sie jeden Listeneintrag mit 3, daher
wird nur der Listeneintrag 3 zurückgegeben.
Eine Lambda-Funktion ist also eine temporäre Funktion,
der wir keinen Funktionsnamen gaben und die wir an andere
Funktionen weiterreichen können. Wie hilft uns das bei unserer
Fotodatenbank?
(remove-if-not
#’(lambda (x) (equal (gethash “category” x) “pets”)) *photolist*)
Dateneingabe und Funktionsabläufe in Slime.
Diese Konstruktion iteriert über *photolist*, speichert
jeden Eintrag in x und gibt nur diejenigen Bilder zurück, die
der Kategorie “pets” angehören.
Wir können die Funktion show-photo-details-2 aus dem
vorherigen Abschnitt entsprechend erweitern:
(show-photo-details-2
(remove-if-not
#’(lambda (x) (equal (gethash “category” x) “pets”)) *photolist*))
Blog entry 1
category - pets
tag - (DOG PARK)
location - London
Damit sind wir fast am Ziel. Wir erstellen nun noch eine
weitere Funktion und übergeben ihr als Paramater den
gewünschten Schlüssel und den gewünschten Wert:
(defun show-photo (key value)
(show-photo-details-2
(remove-if-not
#’(lambda (x) (equal (gethash key x) value)) *photolist*)))
(show-photo “category” “family”)
Blog entry 1
category - family
tag - (BABY PARK)
location - London NIL
Wie in Lisp üblich, ist der Programmcode am einfachsten
zu verstehen, wenn man ihn von hinten nach vorne liest: Die
REMOVE-IF-NOT-Funktion vergleicht den übergebenen
Schlüssel und den übergebenen Wert und erstellt eine
Liste mit allen zu diesen Kriterien passenden Bildern.
Diese wird an die alte show-photo-list-details-Funktion
übergeben. Dieses Aneinanderreihen von Funktionen ist sehr
typisch für Lisp.Bei genauem Hinsehen fällt auf, dass die
Suche nach einem bestimmten Wert im tag nicht funktioniert
– der tag-Hashwert ist ja eine Liste und GETHASH prüft auf
völlige Gleichheit des Suchstrings mit diesem Hashwert. Eine
Suche nach der Liste (BABY PARK) wird also erfolgreich
sein, eine Suche nach dem String BABY hingegen nicht.
Wenn Sie die Suchfunktion selbst umprogrammieren möchten,
werden Sie vermutlich IF und PROGN nachschlagen wollen.
Zu diesem Zweck legen wir Ihnen ist das kostenlose Online-
Buch Practical Common Lisp ans Herz, das sich als gut lesbare
Informationsquelle zum Thema Lisp erwiesen hat.
Schnelltipp
Denken Sie daran,
dass in Lisp
Funktionsparameter
nicht in
Klammern stehen
dürfen – es sei
denn, der
Parameter ist eine
einzelne Liste.
Daher hieße es
(print „hallo“) und
nicht (print(„hallo“)).
Wenn Sie
eine Fehlermeldung
wie „illegal function
call“ erhalten, dann
sind meist diese
überzähligen
Klammern schuld.
149

Programmiersprachen
C++: So geht’s
Eine kleine Einführung in die Programmiersprache samt Klassen,
Objekten und Vererbung.
In diesem Tutorial werden wir einen kleinen Blick auf das
1998 und 2003 standardisierte „klassische“ C++ werfen.
Wahrscheinlich sind Sie sich bewusst, dass es mittlerweile
eine aktuellere Version – C++ 11 – gibt, aber wir werden uns
erst einmal mit einigen grundlegenden Ideen und der Syntax
auseinandersetzen, die bei jeder Version funktionieren.
C++ leiht sich viele Ideen und seine Struktur bei C aus.
Daher wird Erfahrung mit C oder einer anderen mit C verwandten
Sprache Ihren Lernprozess bei C++ beschleunigen.
Doch Vorsicht: Es gibt kleine, aber feine Unterschiede zwischen
C und C++.
Selbst wenn Sie noch nie mit C oder dem Konzept von
objektorientiertem Programmieren in Berührung gekommen
sind, sollten Sie ohne Weiteres in der Lage sein, sich erfolgreich
durch dieses Tutorial durchzuarbeiten.
Falls Sie dieses Tutorial direkt am Rechner ausprobieren
möchten, muss g++ installiert sein. Sind Sie sich nicht sicher,
ob dies der Fall ist, geben Sie einfach g++ in die Befehlszeile
ein. Ist es installiert, wird es nach ausführbaren Dateien fragen,
ist es nicht installiert, wird das System Sie darüber informieren.
Wir erstellen zunächst ein einfaches C++-Programm:
#include
int main()
{
std::cout

Programmiersprachen
werfen Sie einen Blick auf die Dateien im Verzeichnis Person.
Erschaffen und führen Sie das Programm so aus, wie es dort
durch den Code vorgegeben wird. Kommentieren Sie die
Zeile in main.cpp aus, welche Ihnen den Zugriff eines privaten
Nutzers ermöglicht. Sie können dies durch das Weglassen
von // in der Zeile erreichen. Versuchen Sie nun, mit
dem Build-Befehl die Datei auszuführen, achten Sie auf die
daraus resultierende Fehlermeldung. Alles klar? Beheben Sie
den fehlerhaften Code nun wieder durch das Einfügen der
fehlenden // Zeichen.
Formen zeichnen
Lassen Sie uns ein anderes Beispiel nehmen. Gesetzt den
Fall, wir möchten ein Programm schreiben, das verschiedene
Formen auf dem Bildschirm zeichnet. Dieses Programm
könnte ein 2D-Malwerkzeug sein oder ein Werkzeug, mit dem
Sie Diagramme erschaffen und editieren können. Hierbei
würde es sich sehr wahrscheinlich um Figuren wie Rechtecke
und Kreise handeln. Diese Figuren hätten allesamt eine bestimmte
Position in der zweidimensionalen Welt und würden
für gewöhnlich innerhalb der Begrenzung eines Fensters dargestellt.
Solche Positionen werden üblicherweise angezeigt,
indem man der Figur einen Ort zuweist, der im Verhältnis zu
ihrem Mittelpunkt im Koordinatensystem des Fensters steht.
Eine Klasse, die eine allgemeine Form repräsentiert, könnte
so aussehen:
class Shape
{
public:
Shape(int x, int y);
void draw() const;
int get_x() const;
int get_y() const;
private:
int x;
int y;
};
Unsere spezifischen Figuren – Kreise und Rechtecke – würden
als verschiedene Arten der Klasse Shape dargestellt werden,
indem wir folgende Syntax verwenden:
class Circle : public Shape
{
public:
Circle(int x, int y, int radius);
void draw() const;
private:
int r;
};
Diese Syntax
Class : public Base Class
{
…
definiert unsere Klasse, Class, als eine Ableitung von unserer
Basisklasse. Als eine solche hat sie alle Elemente (Datenelemente
und Elementfunktionen) unserer Basisklasse plus einige
zusätzliche, die wir noch näher definieren können. Hierdurch
erreichen wir eine gewisse Flexibilität bei den
abgeleiteten Klassen, solange wir nicht übermäßig gegen die
Semantik der Basisklasse mit Ihren Modifikationenen
verstoßen.
(Nebenbei bemerkt: Const-Elementfunktionen. Wir haben
mehrere unserer Elementfunktionen und ihre entsprechenden
Definitionen mit dem Schlüsselwort const beendet. Dies
fügt eine Sicherheitsüberprüfung zu den Funktionen hinzu,
die read-only sind. Dadurch wird der Compiler veranlasst, die
Funktionen daraufhin zu überprüfen, dass sie nicht das Objekt,
das sie aufruft, direkt oder indirekt verändern.)
Wir könnten das Beispiel um Klassen weiterer bestimmter
Formen, wie Rechtecke oder Pfeile, erweitern, belassen es
aber fürs Erste hierbei.
Konstruktoren und Destruktoren
Objekte werden durch einen Aufruf an eine Konstruktor-
Elementfunktion aufgerufen. Wird eine solche Definition der
Klasse nicht vom Anwender zur Verfügung gestellt, so
springt der Compiler ein. Die Compilervariante wird jedoch
nur dem Objekt Speicher zur Verfügung stellen. Bei einem
nicht-statischen Objekt bleiben alle Datenelemente
uninitialisiert.
Da es oft notwendig ist, dass Objekte einen bestimmten
Wert haben, werden Konstruktoren größtenteils dafür verwendet,
genau dies zu ermöglichen. Zusätzlich können sie
aber alles erledigen, was Sie wünschen – sich mit Datenbanken
verbinden, ihre Initialisierung in einem Log festhalten und
vieles mehr. Konstruktoren werden nach ihrer Klasse benannt
und als nicht-zurückkehrende Gattung definiert.
Derjenige in unserer Shape-Klasse wurde folgendermaßen
definiert:
Shape(int x, int y);
Dies weist darauf hin, dass der Konstruktor int beidesmal als
Argument annimmt. Wie dies verwendet wird, wird über unsere
Implementierungsdatei gesteuert (shape.cpp in unseren
Code-Beispielen).
Analog dazu, wenn ein Objekt gelöscht wird, kommt ein
Destruktor ins Spiel. Wie zuvor wird auch hier einer vom
Compiler zur Verfügung gestellt (dieser gibt den Speicher
des Objekts einfach wieder frei). Möchten Sie mehr als diese
grundlegende Funktion verwenden, müssen Sie dem Destruktor
vorschreiben, was zu tun ist (eine Verbindung kappen,
den Soundchip deaktivieren und so weiter). Für gewöhnlich
wird ein Objekt gelöscht, wenn es seinen
Aufgabenbereich überschreitet (ein solches Beispiel wäre die
geschlossene spitze Klammer eines Blocks).
Um einige dieser Konzepte zu veranschaulichen, können
wir die Konstruktion und Destruktion unseres Shape-Klassen-Objekts
arrangieren. Dies können wir dadurch erreichen,
dass wir die Zeile
cout

Programmiersprachen
Schnelltipp
Denken Sie daran,
jede Definition einer
Klasse mit einem ;
zu beenden, da
Sie sonst einen
Programmierfehler
begehen, der bei
manchen Compilern
zu seltsamen
Fehlermeldungen
führt.
und
~Circle();
zusätzliche Zeilen in die relevanten .h-Dateien einfügen.
Eine Möglichkeit wäre zum Beispiel:
Shape::~Shape()
{
cout

Programmiersprachen
dann die Funktion auf, um x mit einer einer const-Referenz
für j zu initialisieren.
Mit anderen Worten, innerhalb der Funktion ist x ein anderer
Name für j, aber keiner der es erlaubt, j zu verändern. Die
zurückgegebene Aussage der Funktion verhält sich wie
zuvor. Jeder Versuch jedoch, x, und damit j, zu verändern,
verursacht einen Fehler beim Kompilieren.
Somit haben wir alles gleichzeitig. Die Kosteneffektivität
durch die Initialisierung von Referenzen bei gleichzeitiger
Sicherheit durch die Weitergabe des Werts.
Als Faustregel kann man sagen, dass kleine Parameter
(char, int, double und so weiter) über ihren Wert und größere
Parameter wie Objekte per const-Referenz weiterzugeben
sind.
C++ erlaubt es im Allgemeinen, seine Funktionen zu
überlasten. Das bedeutet, dass es in der Lage ist, mehrere
Funktionen eines Namens zu haben, welche sich aber über
unterschiedliche Sequenzen von Aussagegattungen unterscheiden.
Basierend auf den Aussagen sucht sich der
Compiler die richtige Version heraus.
Es ist allgemein üblich, eine Vielzahl an Versionen von Klassenkonstruktoren
zu haben. Eine Klasse kann zum Beispiel
einen – oder mehrere – normale Konstruktoren haben und
zusätzlichen einen Konstruktor für Kopiervorgänge. Dieser
wird immer dann Verwendung finden, wenn wir ein Objekt
der gleichen Art aus einem anderen erschaffen wollen. Für
die Klasse C wird der Kopie-Konstruktor folgendermaßen
definiert:
C( const C& c);
Hiermit wird ein Objekt der gleichen Art über die const-
Referenz weitergegeben und etwa so definiert:
C:: C( const C& c)
{
…
}
Falls dieser Artikel Sie auf C++ neugierig gemacht haben
sollte, finden Sie auf http://www.a-train.co.uk/c++_
books.html eine weiterführende Bibliographie.
Code-Beispiele kompilieren und ausführen
1 Kompilieren und starten
Suchen Sie die Dateien in Ihrem Hello-Verzeichnis. Führen Sie die
vorgeschlagene Datei aus, um Ihr Build-Setup zu testen.
2 Benutzen Sie eine einfache Klasse
An den Dateien im Person-Verzeichnis sehen Sie, wie Interface- und
Implementationsdateien einer Klasse geschrieben und im Client-Code
verwendet werden.
3 Nutzen Sie Vererbung
Verwenden Sie die Dateien im Shapes_1-Verzeichnis, um sich näher
anzuschauen, wie die Syntax verwendet wird, um eine Klasse
abzuleiten (Vererbung).
4 Nutzen Sie Referenzparameter
Konstruktoren, das Hinzufügen eines Kopie-Konstruktors, das
Verwenden von const-Referenzparametern. Benutzen Sie die
Dateien im Reference-Verzeichnis.
153

Programmiersprachen
Fortran: Fortran
Fortran ist die älteste aller Hochsprachen und mit ihrem Fokus auf
mathematische Berechnungen aktueller als je zuvor.
Fortran Fortran wurde zwischen 1954 und 1957 entwickelt
und ist damit die älteste höhere
Programmiersprache überhaupt. Trotz des hohen
Alters ist Fortran noch immer in Verwendung, beispielsweise
berechnen Investmentbanken und Versicherungen ihre komplexen
mathematischen Modelle damit. Da Fortran
(FORmula TRANslation) ursprünglich für die Berechnung
numerischer Modelle entwickelt wurde, fand sie schnell in
allen physikalischen und mathematischen Disziplinen
Verwendung. Daher füttern auch die Wissenschaften ihre
Supercomputer gerne mit dieser Sprache und so erfreut sich
die Sprache auch nach mehr als 50 Jahren noch immer
höchster Beliebtheit – obwohl ihr seit mehreren Jahrzehnten
der Untergang vorausgesagt wird.
Selbst ein 35 Jahre alter Fortran-Code läuft noch immer in
seiner ursprünglichen Form. Aber auch moderne Konzepte
sind längst umsetzbar, da Fortran stetig weiterentwickelt
wird. Nur für Web-Anwendungen und grafische
Benutzeroberflächen ist Fortran nach wie vor ungeeignet.
Installation und erste Schritte
In diesem Tutorial werden wir die Sprachfeatures von Fortran
90 verwenden, daher benötigen Sie einen Fortran-Compiler
gleicher oder jüngerer Version. Wir empfehlen den kostenlosen
GNU-Compiler gfortran, aber andere Compiler wie G95
(ebenfalls kostenlos) oder NAG (kostenpflichtig) eignen sich
ebenso. Einige Compiler bringen eigene Sprachvarianten mit
und eignen sich damit für spezielle Einsatzgebiete, allerdings
verzichten sie auf Code-Kompatibilität zu anderen
Compilern. Wir benötigen derlei Erweiterungen nicht und
beschränken uns auf den offiziellen Sprachstandard. gfortran
finden Sie auf der GNU-Webseite oder als optionales Paket in
den meisten Linux-Distributionen. Unter Debian starten Sie
den Compiler mit gfortran oder F95; im folgenden Text werden
wir F95 verwenden.
Erstellen Sie eine Textdatei namens hello.f95 und geben
Sie diesen Code ein.
Ein F95-
Programm,
das nach
Ihrem Namen
fragt und Sie
dann begrüßt.
Dahinter die F77-
Version von Hello
World.
Fortran-Versionen
Fortran (beziehungsweise der erste verfügbare
Compiler) erschien im Jahr 1957 für
Mainframe-Computer als Alternative zu
Assembler. Der Code war eine Kombination von
insgesamt 32 Anweisungen und wurde auf
Lochkarten gespeichert. Da die Sprache schnell
an Popularität gewann, entwickelten die
Mainframe-Hersteller bald eigene, auf ihre
Hardware abgestimmte Versionen. So entstand
die erste echte Cross-Plattform-Sprache.
Fortran II, III und IV erschienen, aber erst mit
Fortran-66 wurde die Sprache durch die ISO
standardisiert.
Ein Jahrzehnt später wurden mit Fortran-77
die gröbsten Fehler von F66 behoben, weshalb
Fortran-77 heutzutage die wichtigste und meistverbreitete
Sprachversion ist. Selbst für
modernste Computer gibt es noch immer
Fortran-77-Compiler und Code für diese Version
ist in Firmen, Forschungseinrichtungen und
natürlich im Internet zu finden. Nach langer
Wartezeit erschien mit Fortran 90 eine völlig neu
entwickelter Compiler-Version, die einerseits
rückwärtskompatibel zu Fortran-77 ist und andererseits
moderne Sprachkonzepte wie beispielsweise
optionale Parameter und weitere mathematische
Fähigkeiten wie Matrix-Operationen in
Fortran integriert. Mit Fortran 2003 kam die
Unterstützung der Objektorientierten
Programmierung und mit Fortran 2008 wurden
parallelisierte (also nebenläufige und synchronisierte)
Funktionen möglich.
154

Programmiersprachen
Freies und festes Zeilenformat
Vor Fortran 90 waren für Fortran-Programme
– um auf Lochkarten gestanzt zu werden – feste
Zeilenformate vorgeschrieben:
Maximal 72 Zeichen je Zeile.
Für Zeilenumbrüche muss die Folgezeile um
sechs Spalten eingerückt sein. Die ersten 6
Spalten müssen leer sein, sofern man sie nicht
für Kommentare oder Fortsetzungszeichen verwendet.
Kommentare müssen in der ersten Spalte ein
* oder ein c haben.
Darüber hinaus haben Leerzeichen keine
Bedeutung.
Ein Hello-World-Programm sähe also folgendermaßen
aus:
c Hello World
program hello
print *,’Hello World’
end program hello
Erst seit F90 existiert das freie Zeilenformat, das
in allen Beispielen dieses Tutorials verwendet
wird. Dennoch gilt es, einige Regeln einzuhalten:
Zeilen dürfen höchstens 132 Zeichen lang sein.
Um eine Zeile umzubrechen, verwendet man das
&-Zeichen am Zeilenende. Wenn der Umbruch
innerhalb eines Bezeichners auftritt, dann benötigt
der Anfang der Folgezeile ebenfalls das
&-Zeichen:
character :: name*100
name = “diese lange Zeile braucht hier &
&und hier ein Et-Zeichen
! kommentar
Kommentare beginnen mit einem !
Leerzeichen werden beachtet, beispielsweisedarf
in Variablennamen oder Zahlen keines vorkommen.
In bestimmten Bezeichnern wie END
IF darf auf das Leerzeichen verzichtet werden.
Einrückungen werden ignoriert.
Mehrere Anweisungen in einer Zeile werden
durch Semikolons ; voneinander getrennt.
Wenn der Dateiname mit .f90 oder .f95 endet,
geht der GCC-Compiler von einem freien Format
aus; bei der Dateiendung .for von einem festen
Zeilenformat. Mit -ffixed-form oder -ffree-form
wird diese Automatik überschrieben.
! Hello World
program hello
print *,”Hello World”
end program hello
Sie kompilieren das Programm mit f95 -o hello hello.f95
und starten es mit ./hello. Das Parameterpaar -o hello gibt
die Ausgabedatei an. Ohne diesen Parameter hieße die
Programmdatei a.out. Sie sollten nun das traditionelle Hello
World auf Ihrem Bildschirm erblicken.
Diese Code-Zeilen zeigen einige wichtige Eigenheiten der
Sprache: Das Ausrufezeichen ! wird für Kommentare verwendet.
Programme sind mit program name und end program
name umschlossen, wobei name nicht identisch mit
dem Dateinamen sein muss. Die Einrückungen sind nicht
erforderlich und dienen nur der Lesbarkeit.
print gibt Werte auf dem Bildschirm aus. Das Sternchen *
ist der Formatbezeichner und weist print an, selber das
geeignete Format für die Ausgabe zu wählen. In F77 wurden
Strings noch mit einfachen Anführungszeichen identifiziert,
seit F90 sind auch die üblicheren doppelten
Anführungszeichen erlaubt.
Sprachgrundlagen
Wir machen unser Programm hello.f95 nun etwas komplizierter:
! Hello Name
program hello
Berechnungen und Schleifen
Da Fortran einen mathematischen Schwerpunkt hat, ist
unser nächstes Beispiel ein mathematische Anwendung: Sie
berechnet Fibanocci-Sequenzen. Eine Fibanocci-Zahl ist die
Summe der beiden vorherigen Fibanocci-Zahlen, beginnend
mit 1 und 1. Fibanocci-Sequenzen begegnen uns überall in
der Natur, beispielsweise lassen sich Schneckenhäuser
damit beschreiben.
Da es sich um einen iterativen Algorithmus handelt (der
Eingabe-Parameter ist der Rückgabewert der vorherigen
Berechnung), können wir ihn elegant in einer Schleife unterbringen:
! Berechnet die ersten 20 Zahlen der Fibonacci-Sequenz
program fibonacci
implicit none
integer :: first, second, a, i
first = 1
implicit none
character :: name*20
print *, “Please enter your name: “
read *,name
print *,”Hello “,name
end program hello
Die Zeile implicit none ist wichtig: Da Fortran für mathematische
Aufgaben konzipiert wurde und Mathematiker von
Variablennamen wie i, j, k, l, m und n erwarten, dass sie
Ganzzahlen repräsentieren, wurde die sogenannte implizite
Typisierung eingeführt: Variablen mit solchem Namen waren stets
Ganzzahlen und alle anderen Variablen waren automatisch
Realzahlen. Nur wenn man Strings oder Zeichen verwenden wollte,
musste man die Variablen explizit deklarieren. Die implizite
Typisierung funktioniert noch immer, aber da sie ein Einfallstor für
Fehler aller Art ist, sollte man sie mit implicit node abschalten und
alle Variablen selbst definieren. Hier deklarieren wir name als Array
der Länge 20 vom Typ character, es ist also ein 20 Zeichen langer
String. read liest Text aus der Standardeingabe ein und speichert
den Text in name.
Die in Fortran eingebauten Datentypen sind INTEGER, REAL
(mit einer Genauigkeit von sechs Dezimalstellen), DOUBLE
PRECISION (13 Dezimalstellen Genauigkeit), LOGICAL (boolesche
Werte .TRUE. oder .FALSE.), COMPLEX (komplexe Zahl), und
CHARACTER (wobei ein String ein Array von CHARACTER ist).
GROSSBUCHSTABEN sieht man in Fortran sehr häufig,
obwohl der Compiler die Groß- und Kleinschreibung ignoriert.
second = 1
print *, first
print *, second
do i = 1, 18, 1
a = first + second
print *, a
first = second
second = a
end do
end program fibonacci
Zuerst deklarieren wir vier Variable und initialisieren first
und second mit 1. i ist die Schleifenvariable und a wird als
temporäre Variable den errechneten Wert einer einzelnen
Fibanocci-Zahl zugewiesen bekommen. Wichtig an diesem
Code ist die for-Schleife, die es erst seit F90 gibt. In F77 und
Schnelltipp
Wenn Sie jemals
den Fortran-Code
eines anderen
Programmierers
debuggen müssen,
dann ist es hilfreich,
den Code
durch mehrere
Compiler zu schicken.
Bei aktivierter
Debug-Option zeigen
sich zahlreiche
Hinweise auf
potenzielle
Probleme.
155

Programmiersprachen
älteren Versionen musste man Schleifen mit der GOTO-
Anweisung bilden, doch deren Einsatz ist fehleranfällig und
mittlerweile verpönt:
do iterator = start, ende, zuwachs
! Hier ist der Schleifenrumpf
end do
Die Schleifenvariable iterator hat anfangs den Wert start
und wird nach jedem Schleifendurchlauf im zuwachs erhöht.
Sobald zuwachs größer als ende ist, wird die Schleife beendet.
Da ein Zuwachs von 1 sehr häufig vorkommt, hätten wir
auf die Angabe verzichten und einfach do i = 1, 18 schreiben
können.
Innerhalb der Schleife berechnen wir die jeweils nächste
Fibanocci-Zahl und zeigen sie an. Dann verschieben wir die
Werte in first und second, um den nächsten Durchlauf vorzubereiten.
So sieht die unser Beispiel der Fibonacci-Sequenz am
Ende aus.
Der Nullpunkt einer Funktion
Wir haben
das intent(in)-
Schlüsselwort
auf einen
Parameter
angewendet
und dessen
Wert im Code
anschließend
verändert (im
Editor zu sehen).
Der Compiler
quittiert dies mit
einem Fehler.
Um weitere Features von Fortran zu zeigen, werden wir nun
den Nullpunkt einer mathematischen Funktion berechnen.
Der Nullpunkt beschreibt den Parameterwert x einer
Funktion f(x), für den sie das Ergebnis Null f(x)=0 erzeugt.
Hier einige Beispiele:
f(x) = x - 2 : the root of this is 2, because 2 - 2 = 0.
f(x) = 3x - 3 : the root of this is 1, because 3 * 1 - 3 = 0.
f(x) = 2x^2 - 8 : the root of this is 2, because 2 * 2 * 2 - 8 = 0.
Solche Nullpunktberechnungen kann man stets manuell
lösen. Wie Sie aber vermutlich noch aus dem
Mathematikunterricht wissen, überlässt man diese Aufgabe
gerne einem anderen – in unserem Fall Fortran.
Ein erster Ansatz für die automatisierte Berechnung von
Nullpunkten ist mit etwa 3.000 Jahren weitaus älter als
Fortran: das Sekantenverfahren. Wir können an dieser Stelle
leider nicht im Detail erklären, wie es funktioniert, und müssen
Interessierte an Wikipedia verweisen. Der folgende Code
implementiert den Algorithmus. Speichern Sie folgenden
Code als secant.f95:
! Berechnung des Nullpunktes von 2x^2-1 mit dem Sekantenverfahren
program secant
implicit none
real, parameter :: error = 1.0e-6
real :: x0, x1, temp
integer :: i = 1, limit = 100
x0 = 0
x1 = 1.0
do
if (i > limit) then
print *, “Keine Konvergenz. Berechnung beendet. ”
exit
endif
if (f(x1) == 0) then
print *, “Nullpunkt ist genau “, x1
exit
else if (abs(x1 - x0) < error) then
print *, “Nullpunkt ist genähert “, x1
exit
end if
temp = secanteq(x0, x1)
call reallocate(x0, x1, temp)
Debuggen
Unglücklicherweise sind die Fehlermeldungen
der meisten Fortran-Compiler bei der
Fehlersuche nur in wenigen Fällen hilfreich.
Überprüfen Sie daher selbst, dass Sie implicit
none angegeben haben. Sie sollten außerdem
print-Anweisungen überall im Code verteilen, um
dem Programmablauf auf die Finger zu sehen.
Danach können Sie sich mit den diversen
Debug-Optionen von GFortran vorantasten:
-O0. weist den Compiler an, auf Optimierungen
zu verzichten. Zwar ist das Programm dann sehr langsam,
die Qualität der Fehlermeldungen wird jedoch
erhöht.
-Og schaltet in GFortran-Versionan ab 4.8 nur solche
Optimierungen ein, die Fehlermeldungen nicht beeinflussen.
-Wall zeigt „alle“ Warnungenen an, während
-Wextra noch ein paar Warnungen mehr anzeigt.
-pedantic warnt vor Sprachfeatures, die von
GFortran, nicht aber vom offiziellen Standard unterstützt
werden.
-g ermöglicht die Verwendung des interaktiven GNU-
Debuggers gdb. Mit gdb programmname starten Sie
den Debugger, mit break main setzen Sie einen
Haltepunkt vor der ersten ausführbaren Anweisung,
mit run starten Sie bis zum ersten Haltepunkt und mit
step führen Sie jede Anweisung einzeln aus.
Für GDB gibt es im Internet ausführliche Anleitungen.
Außerdem gibt es dort weitere, teils bequemere
Fortran-Debugger.
156

Programmiersprachen
i = i+1
!entfernen Sie die folgende Kommentierung, um die Schleife in Aktion zu sehen
!print *, “x0 is “, x0, “x1 is “, x1
end do
contains
function f(x)
real :: f
real, intent(in) :: x
f = 2.0*x*x - 1.0
end function f
function secanteq(x0, x1)
real :: secanteq
real, intent(in) :: x0, x1
secanteq = x1 - (f(x1) * (x1 - x0) / (f(x1) - f(x0)))
end function secanteq
subroutine reallocate(x0, x1, temp)
real :: x0, x1, temp
x0 = x1
x1 = temp
end subroutine reallocate
end program secant
Betrachten wir zuerst die Struktur des Programms. Es
besteht aus einem Abschnitt für die Initialisierung, einer
do-Schleife sowie aus einem contains-Abschnitt.
Hinter dem Schlüsselwort contains erwartet Fortran die
Definition von lokalen Unterprogrammen (function oder subroutine).
Hinter der end program-Zeile können Sie zudem
globale Unterprogramme definieren. Zwischen function und
subroutine bestehen wichtige Unterschiede:
1 function hat einen Rückgabewert, subroutine nicht.
2 function muss mindestens einen Parameter haben,
subroutine darf auch mal keine haben
Erwartungsgemäß steht der Rumpf einer Unterfunktion
zwischen den entsprechenden Schlüsselwörtern function ...
end function und subroutine ... end subroutine.
Sehen wir uns nun an, was in dem Programm passiert. In
den ersten Zeilen werden Variablen definiert, wobei lediglich
das parameter-Schlüsselwort neu ist. Es wird in Fortran verwendet,
um eine Konstante zu definieren. Jeder Versuch, dieser
Konstante im weiteren Programmverlauf einen Wert
zuzuweisen, führt zu einem Compiler-Fehler.
x0 und x1 sind einfache Variablen, die sich im
Programmverlauf immer mehr an den gesuchten Nullpunkt
annähern sollen.
Der größte Teil der Programmlogik ist innerhalb der
do-Schleife enthalten. Da wir im Gegensatz zu oben keine
Laufvariable verwenden, wird die Schleife unendlich oft
durchlaufen. Um das Programm zu beenden, benötigen wir
also mindestens eine solide Abbruchbedingung im
Schleifenrumpf. In diesem Beispiel testen wir daher, ob der
informelle Schleifenzähler i das limit von 100 Durchläufen
erreicht hat, und beenden die Schleife gegebenenfalls mit
exit.
Jeder Schleifendurchlauf betrachtet außerdem die beiden
x-Werte und bricht die Schleife entweder ab oder berechnet
die x-Werte neu.
Direkt nach dem limit-Test überprüfen wir, ob der zuletzt
berechnete x-Wert x1 ein Nullpunkt ist. Dazu übergeben wir
x1 einfach der Funktion f und untersuchen deren
Rückgabewert. Wenn diese Bedingung erfüllt ist, haben wir
den Nullpunkt gefunden und brechen ab. Wir testen auch auf
„fast am Ziel“: Wenn die beiden zuletzt berechneten x-Werte
x0 und x1 nahezu identisch sind, dann haben wir näherungsweise
einen Nullpunkt gefunden und brechen ebenfalls ab.
Die maximale Differenz dieser beiden Zahlen haben wir in der
Konstanten error festgelegt, sie beträgt 0.000001.
Wenn keine Abbruchbedingung erfüllt ist, dann berechnen
wir die Sekante für x0 und x1 und sichern sie in temp.
Anschließend speichert das Unterprogramm swap noch x1 in
x0 und temp in x1, womit wir für den nächsten
Schleifendurchlauf gewappnet sind.
Unterprogramme
Der contains-Abschnitt enthält zwei Funktionen. Bei f(x)
handelt es sich um die Funktion, deren Nullpunkt wir bestimmen
möchten. Die andere Funktion ist secanteq(x0, x1), die
das Sekantenverfahren für die beiden Parameter durchführt.
In der ersten Zeile eines jeden Funktionsrumpfs wird dem
Funktionsnamen ein Typ zugewiesen, außerdem wird der
Funktionsname fortan als Variable verwendet – hierbei handelt
es sich um den Rückgabewert der Funktion. Auf ähnliche
Weise wird der Typ der Parameter festgelegt. Der Versuch,
einen unpassenden Wert als Funktionsparameter zu übergeben,
wird mit einem Compiler-Fehler quittiert.
Eine Fortran-Besonderheit ist das intent(in)-Schlüsselwort.
Es legt fest, dass die Parameter nur als Eingabe verwendet
werden dürfen und ihren (möglicherweise innerhalb
der Funktion veränderten) Wert nach dem Funktionsende
nicht an den Aufrufer zurückgeben.
Für eine subroutine gilt Entsprechendes. Auch hier muss
der Typ jedes Parameters festgelegt werden und mit
intent(in) kann man sie als Eingabeparameter definieren. Im
Fall von reallocate verzichten wir darauf: Wir überschreiben
den alten Wert von x0 mit dem Wert von x1, und x1 erhält
daraufhin den Wert von temp. Nach dem Aufruf dieser
Funktion hat sich der Wert dieser beiden Variablen aus Sicht
des Aufrufers entsprechend geändert.
Dieser kurze Einstieg in Fortran soll genügen, um Ihnen
die Sprache vorzustellen. Für Programmierer modernerer
Sprachen fühlt sich Fortran zunächst etwas verstaubt an, tatsächlich
verfügt aber F90 über alle Elemente einer prozeduralen
Programmiersprache und seit Fortran 2003 kann man
sogar objektorientiert programmieren. Wer sich darauf einlässt,
der findet in Fortran eine ausgereifte und vor allem
schnelle Sprache für mathematische Aufgaben aller Art.
Zudem steht in der 60 Jahre alten Sprache für nahezu jedes
mathematische Problem längst eine Lösung zum kostenlosen
Download aus dem Internet bereit, die sich mit geringem
Aufwand an eigene Bedürfnisse anpassen lässt.
Die Nullpunktbestimmung
für
2x²-1. Wenn Sie
die print-Zeile
im Code entkommentieren,
dann können Sie
wie hier gezeigt
die einzelnen
Näherungsschritte
verfolgen.
157

Programmiersprachen
Lua: Erste Schritte
Lua wird vom Spiele-Scripting bis zur Bildbearbeitung in den
unterschiedlichsten Anwendungen genutzt. Ein Crashkurs.
Die Ausgabe
der Lua-
Installation und
vom Interpreter
selbst.
Lua ist eine schnelle, leichtgewichtige Interpreter-Skript-
Sprache. Bei der Konzeption stand die Integrierbarkeit
in andere Systeme an erster Stelle: Die Sprache und ihr
Interpreter sind schlank, sie können an bestehende
Programme angefügt und mit der einfachen API komplikationslos
integriert werden. Die Sprache selbst hat nur wenige
Features, aber sie kann durch Metamechanismen schnell
passend zum jeweiligen Einsatzzweck erweitert werden
(auch wenn dies den Rahmen diese Tutorials sprengen würde).
Da sie einfach zu erlernen ist, ist sie gleichzeitig sowohl
praxisnah als auch ein perfektes Experimentierfeld.
Holla Lua
Um die aktuellste Version von Lua zu erhalten (Release-
Version 5.2.3 zum Redaktionsschluss), lädt man am besten
den Quellcode herunter und erstellt die Binary selbst:
curl -R -O http://www.lua.org/ftp/lua-5.2.2.tar.gz
tar zxf lua-5.2.2.tar.gz
cd lua-5.2.2/
make linux test
sudo make install
Dies erstellt das Paket und installiert es in /usr/local/bin.
Nun öffnen Sie ein Terminal und geben lua ein. Sie sollten
damit zur Lua-Eingabeaufforderung gelangen, wo Sie
Programmcode direkt eingeben können:
> print(“Hello World”)
Hello World
>
Lua: Lecker Häppchen
Die Eingabeaufforderung ist nützlich, um mit einzelnen
Befehlen zu experimentieren. Mit dofile dateiname kann
man aber auch ganze Code-Dateien in den Interpreter laden.
Eine ausführbare Programmdatei für das klassische
„Hello World“ ist entsprechend einfach zu erstellen. Erstellen
Sie eine Datei namens hello.lua mit diesem Inhalt:
print(“Hello World”)
Starten Sie nun das Programm von der Kommandozeile
mit lua hello.lua, dann sehen Sie die zu erwartende Ausgabe.
In Lua haben Funktionen die bewährte funktion(argument)-Syntax.
print() wird verwendet, um einzelne
Textzeilen auszugeben. Die Funktion ruft für jedes Argument
dessen tostring()-Funktion auf und hängt dem
Gesamtergebnis einen Zeilenumbruch an. Wenn Sie mehr
Kontrolle über die Ausgabe benötigen, dann verwenden Sie
die Funktion io.write(), die wir später genauer betrachten.
Ein Mehrzeiler
Nach dem Einzeiler Hello World wagen wir uns nun an etwas
Komplexeres. Wir schreiben ein einfaches
Zeitmanagementprogramm, das die Start- und Endzeiten
einer Aufgabe aufzeichnet. Zuerst benötigen wir eine
Funktion, welche den Startzeitpunkt annimmt. Erstellen Sie
eine Datei time.lua mit folgendem Inhalt:
filename = “timefile.txt”
function recordStart(title)
local timenow = os.time()
io.output(filename)
io.write(string.format(“%s, start %d”, title, timenow)) end
io.stdout:write(“Type project name\n”)
local project = io.stdin:read()
io.stdout:write(“Type s to start timing or c to cancel\n”)
local input = io.stdin:read()
if input == “s” then
recordStart(project)
else
error(“Projektstart abgebrochen”)
end
In Lua ist die Reihenfolge wichtig, in der einzelne
Anweisungen auftauchen. Da Lua interpretiert und nicht
kompiliert wird, kennt es nur die Dinge, die es bereits gesehen
hat. Das bedeutet, dass alle Funktionen deklariert und
In Lua ist jeder ausführbare Code ein sogenannter
Chunk – eine Sequenz einzelner
Anweisungen. Dies kann eine ganze Code-Datei
sein, die Befehl für Befehl abgearbeitet wird,
oder eine einzelne, in den Interpreter getippte
Zeile. Es gibt keine main()-Funktion oder
Ähnliches, ein Chunk wird so, wie er ist, interpretiert.
Ein Chunk kann natürlich Funktionen definieren
und ausführen.
Ein nützlicher Tipp zum Debuggen ist, ein paar
Chunks einzulesen und Lua dann direkt in den
interaktiven Modus gehen zu lassen:
lua -i -lfile -lotherfile
Dies liest die Chunks aus datei und anderedatei
ein, führt sie aber nicht aus. Stattdessen öffnet
sich die Eingabeaufforderung. Wenn Sie nun eine
Anweisung – die sich auf die eingelesenen
Chunks beziehen kann – eintippen und [Return]
drücken, dann wird Lua die Anweisung direkt
ausführen. Wenn Lua kein komplettes Chunk
identifizieren kann, dann wartet es auf weitere
Eingaben. So können Sie auch auf der
Kommandozeile Mehrzeiler wie beispielsweise
Funktionen definieren.
158

Programmiersprachen
definiert sein müssen, bevor sie aufgerufen werden können.
Lua-Programme beginnen daher stets mit globalen
Variablen, dahinter stehen die Funktionen und die initiale
Programmlogik folgt zum Schluss. Alle Lua-Variablen wie im
Beispiel filename sind global, sofern sie nicht mit dem
Schlüsselwort local als lokale Variable (im Beispiel local
input und local project) deklariert wurden. Wenn Sie eine
Variable lediglich in dem Block benötigen, in dem sie deklariert
wurde, dann ist es gute Sitte, sie als lokal zu deklarieren.
Dies ist sauberer und verhindert unbeabsichtigte
Seiteneffekte.
Am Ende des Funktionsblocks sehen Sie das bereits
erwähnte io.write() als Alternative zu print(). Denken Sie
daran, an das Ende des Ausgabe-Strings den Zeilenvorschub
\n anzuhängen. io.write() schreibt immer an das „aktuelle“
Datei-Handle, was – sofern Sie es nicht manuell ändern –
stdin/stdout ist. Um ganz sicherzugehen, dass Sie in das
gewünschte Ziel schreiben, verwenden Sie stattdessen
io.stdout:write(). Für Tastatureingaben verwenden Sie
io.stdin:read().
Der Code enthält außerdem if / then / else / end-Statements.
Lua benötigt für ein if-Statement keine Klammern
und das then sollte in der gleichen Zeile stehen. Das end
kann hingegen auch hinter einem Befehl stehen.
Zu guter Letzt sehen Sie in recordStart() den
io.output()-Befehl: Dieser setzt das Ziel für folgende io.
write()-Ausgaben auf die genannte Datei. Dort hinein
schrei ben wir nun mit string.format() formatierte Texte.
os.time() liefert die Zeitspanne in Sekunden seit einem intern
festdefinierten Zeitpunkt. Wenn wir die Zeit später dem
Programmbenutzer präsentieren wollen, nutzen wir
Funktionen der time-Bibliothek zur Übersetzung in menschenlesbare
Strings.
Wenn Sie das Programm mit lua time.lua mehrmals starten,
dann wird timefile.txt stets mit neuen Werten überschrieben.
Der Start eines weiteren Projektes (ohne das vorherige
abgeschlossen zu haben) wäre nicht möglich. Daher verändern
wir den Dateizugriff:
function recordStart(title)
local timenow = os.time()
local f = assert(io.open(filename, “a”))
f:write(string.format(“%s, start %d\n”, title, timenow))
f:close()
end
Die Zeile assert(io.open()) ist ein typisches Lua-Idiom.
io.open() öffnet erwartungsgemäß die genannte Datei im
gewünschten Modus (hier a für append/Anhängen). Das
Ergebnis f ist das Dateihandle, in das wir ähnlich wie bisher
schreiben können. Die assert()-Funktion stellt darüber hinaus
sicher, dass im Ausnahmefall eine Fehlermeldung
gezeigt wird.
Nun sollten Sie in der Lage sein, so viele Projekte zu starten,
wie Sie möchten. Vor dem nächsten Schritt überprüfen
Sie dies in der Ausgabedatei.
Projekt abgeschlossen
Zwar können wir nun viele Projekte beginnen, aber wir können
sie noch nicht beenden. Also brauchen wir eine weitere
Funktion:
function recordEnd(title)
local timenow = os.time()
local f = assert(io.open(filename, “a”))
f.write(string.format(“%s, end %d\n”, title, timenow))
f:close()
end
-- Benutzereingabe wie zuvor
if input == “s” then
recordStart(project)
elseif input == “t” then
recordEnd(project)
else
error(“Projektstart abgebrochen”)
end
Im Hauptprogramm haben wir dem if-Block mit elseif
input == “t” eine weitere Eingabemöglichkeit hinzugefügt.
Die Anzahl der elseif-Anweisungen ist prinzipiell unbegrenzt.
Das Programm fügt der Ausgabedatei nun für jedes
Projektende eine neue Textzeile hinzu, besser wäre aber eine
einzelne Zeile für jedes Projekt. Dafür müssen wir die entsprechende
Zeile einlesen und verändern. Also verbessern
wir die recordEnd()-Funktion und brechen sie zugunsten der
besseren Lesbarkeit in kleinere Funktionen auf:
function editLine(line)
local timenow = os.time()
return line .. string.format(“, end %d”, timenow) end
function writeWholeTimeFile(lines, linesRemain)
local f = assert(io.open(filename, “w”))
for i, line in ipairs(lines) do
f:write(line, “\n”)
end
if linesRemain then f:write(linesRemain) end
f:close() end
function recordEnd(title)
local f = assert(io.open(filename, “r”))
local lines = {}
local linesRemain
for line in f:lines() do
if string.find(line, string.format(“^%s”, title)) then
lines[#lines + 1] = editLine(line)
linesRemain = f:read(“*a”)
break
else
lines[#lines + 1] = line
end
end
f.close()
writeWholeTimeFile(lines, linesRemain)
end
Leider bietet Lua keine einfache Möglichkeit, einzelne
Textzeilen einer Datei zu verändern. Stattdessen lesen wir die
komplette Datei ein und geben sie gleich wieder aus, wobei
lediglich die gewünschte Zeile verändert wird.
In recordEnd() öffnen wir die Datei und definieren einige
Variablen. lines ist ein Array, also eine Ansammlung einzelner
Werte. Arrays haben in Lua keine feste Größe, also wird auch
Starten Sie
das Programm
mehrmals und
überprüfen Sie
anschließend
den Inhalt der
Ausgabedatei
Schnelltipp
Lua-Kommentare
beginnen mit -- und
können auch hinter
anderen Anweisungen
stehen.
Die foo:method()-Syntax
ruft die
Funktion method()
des Objekts foo auf.
Beispielsweise ist
io eine Bibliothek
und io.stdin ein
bestimmtes Objekt
(in diesem Fall ein
Datei-Handle),
das mit der Standard-Eingabe
des
Systems korrespondiert..
Schnelltipp
159

Programmiersprachen
Schnelltipp
Wenn Sie mit echten
Uhrzeiten
arbeiten, können
Sie os.date() mit
etlichen Formatoptionen
einsetzen,
um aus den
Sekundenzahlen
benutzerfreundliche
Zeit- und
Datumswerte
erstellen zu lassen.
Mit Zeitspannen
funktioniert dies
leider nicht, für
diese ist Handarbeit
gefordert.
Ein Projekt
endet. Keine
Panik: Die angezeigten
Zahlen
der Ausgabedatei
dürfen sich von
Ihren Werten
unterscheiden.
keine Initialisierung benötigt. Das erste Array-Element kann
eine beliebige Index-Nummer haben, die gängige Konvention
ist in Lua die Zahl 1. Die for-Schleife iteriert über die Zeilen in
der Datei, indem sie die lines()-Funktion der Lua-Bibliothek
nutzt. Für jede Zeile line testen wir mit string.find(), ob sie
mit dem gesuchten Projektnamen beginnt. Wenn nicht (der
else-Block), dann hängen wir die aktuelle Zeile an das
lines-Array an. #lines ist die aktuelle Anzahl der Einträge im
lines-Array und da wir mit dem Index 1 zu zählen beginnen,
ist #lines + 1 der nächste leere Eintrag im Array. Wenn die
eingelesene Zeile hingegen mit dem gesuchten Projekttitel
beginnt, dann verändern wir diese mit der Funktion edit-
Line(), die wiederum den ...-Operator zum Verbinden zweier
Strings verwendet. Erneut schreiben wir diese Zeile an das
Ende des lines-Arrays. Anschließend lesen wir alle verbleibenden
Zeilen aus der Datei (*a bedeutet alle) in linesRemain
ein und beenden die Schleife mit break. Nun schließen
wir die Datei und rufen writeWholeTimeFile() auf, um zuerst
lines und dann linesRemain zurückzuschreiben.
In writeWholeTimeFile() verwenden wir w anstatt a, da
wir bewusst die bestehende Datei überschreiben möchten.
Ansonsten ist nur iwrite() neu: Diese Funktion iteriert über
ein Array und gibt zwei Werte zurück: Den Array-Index (der
hier in das ungenutzte i gespeichert wird) und den Array-
Wert (hier line). Bevor linesRemain zurückgeschrieben wird,
testen wir, ob linesRemain überhaupt einen Wert zugewiesen
bekam.
Damit ist unser Programm bereits weitaus besser als
zuvor, aber wir wissen noch nicht, wie lange ein Projekt
gedauert hat. Lassen Sie uns also die Dauer berechnen, ausgeben
und abspeichern. Hierzu müssen wir nur eine Zeile in
editLine() ändern:
function editLine(line)
local timenow = os.time()
local _, _, starttime = string.find(line, “%w+, start (%d+)$”)
local duration = timenow - starttime
print(string.format(“Duration was %d minutes %d seconds”,
duration/60, duration % 60))
return line .. string.format(“, end %d, duration %d”, timenow,
duration)
end
Die Variable _ ist ein Platzhalter. Da wir nicht an den ersten
beiden Rückgabewerten von string.find() interessiert sind
(nämlich der Index, an dem der Treffer beginnt und der
Index, an dem er endet), ignorieren wir diese und speichern
sie in Platzhaltern ab.
Wir berechnen die Dauer und geben sie mittels print() in
benutzerfreundlicher Form aus (% ist der Modulo-Operator,
der für Zeitberechnungen sehr hilfreich ist), zudem hängen
wir den Wert an den Rückgabe-String an.
Wir können nun Projekte starten, beenden und die
Projektdauer bestimmen. Allerdings können wir nur eine
Dauer je Projekt speichern – schöner wäre es, wenn wir je
Projekt mehrere Einträge speichern könnten und wenn die
Dateneingabe bequemer wäre.
Stechuhr
Wir könnten CSV-Dateien nutzen, um solche komplexen
Daten zu speichern. In Lua verwendet man allerdings stattdessen
Arrays von Datensätzen (im Lua-Jargon „Tabelle“).
Tatsächlich sind Datensätze die einzigen Datenstrukturen in
Lua (sogar Arrays sind getarnte Datensätze). Sie sind sehr
flexibel, einfach zu erstellen und zu benutzen. Wir erstellen
eine Tabelle, in der der Schlüssel eine Zahl ist und dessen
Werte Datensätze mit den einzelnen Zeiten sind:
{
1 -> {project = NAME, starttime = TIME, endtime = TIME, duration =
DURATION}
2 -> {project = NAME, starttime = TIME, endtime = TIME, duration =
DURATION}
}
Mit dieser Datenstruktur können wir nun für jeden
Projektnamen beliebig viele Einträge speichern. Wie bereits
erwähnt, ist diese Tabelle ein Array von Datensätzen, weshalb
wir ein paar neue Funktionen benötigen. Wir beginnen
mit einer neuen Methode, um die Startzeiten aufzuzeichnen,
und einer Funktion, um die Tabelle anzuzeigen (nicht notwendig,
aber hilfreich beim Suchen von Fehlern):
timetable = {}
function tableRecordStart(title)
local timenow = os.time()
table.insert(timetable, {project = title, starttime = timenow})
end
function outputTableToScreen()
print “Printing table”
for i, v in ipairs(timetable) do
print(i, v.project, v.starttime, v.endtime, v.duration)
end
end
-- Main code as before, with this edit:
if input == “s” then
Mustererkennung
Dies ist die string.find()-Zeile aus unserem
Code:
local _, _, starttime = string.find(line, “%w+, start
(%d+)$”)
Dieser Ausdruck sucht nach dem zwischen
den Anführungszeichen definierten Muster
%w+, start(%d+)$. Hier kommen sogenannte
Reguläre Ausdrücke zum Einsatz, die sich in Lua
etwas von den Standard-POSIX-RegExp unterscheiden.
Wie in POSIX bedeutet %w+ „ein oder mehrere
alphanumerische Zeichen“, %d+ bedeutet
„eine oder mehrere Zahlen“ und das $ markiert
das Zeilenende. Die Klammern werden verwendet,
um ein Match zu markieren – auf diese
Weise finden wir (neben zwei weiteren Matches)
das gesuchte starttime im line-String.
Die gleiche Syntax wird in string.gsub() und
allen anderen Pattern-Matching-Funktionen von
Lua verwendet.
160

Programmiersprachen
tableRecordStart(project)
elseif ...
-- rest as before outputTableToScreen()
Die globale Variable timetable wird zu Beginn erstellt. Die
Funktion tableRecordStart hängt mittels table.insert() an
das Ende von timetable einen neuen Datensatz an. Mit weiteren
Argumenten hätten wir sogar bestimmen können, an
welcher Position der Datensatz in timetable gespeichert
wird. Beachten Sie, dass wir keine Werte für endtime oder
duration festgelegt haben: In Lua können Datensätze auch
nachträglich verändert werden. In der Ausgabefunktion
nutzen wir wieder ipairs(), um über die Tabelle zu iterieren.
i ist der numerische Schlüssel und v ist der Wert; in
unserem Fall ein ganzer Datensatz. Auch dies zeigt, dass
unser obiges Textzeilen-Array nur ein getarntes
Datensatz-Array ist.
Es gibt mehrere Wege, um Informationen aus einem
Datensatz zu lesen; beispielsweise table.name. Dies ist
gleichbedeutend mit table[„name“], was wiederum nichts
anderes als den Wert eines Arrays am Index [„name“] darstellt.
Würden wir hingegen table[name] schreiben, dann
würde Lua name als Variable interpretieren und den Wert
dieser Variablen als Schlüssel nutzen. Daher sind folgende
Ausdrücke nicht identisch:
name = “foo” table[name] = “bar” --dies entspricht table[“foo”]
table. name = “foo” -- dies entspricht table[“name”]
Wenn wir wie in tableRecordStart() mit der Syntax project
= title einen Datensatz erstellen, dann wird project als
String interpretiert, title als Stringvariable. Achten Sie also
immer auf Ihre Verweise und Indizes!
Wenn wir diesen Code starten, dann können wir
Projektstarts eingeben, die nun als Tabelle angezeigt werden
– und am Programmende verschwinden. Also müssen wir die
Daten noch speichern und laden. An dieser Stelle kommt das
Chunks-Feature von Lua sehr gelegen: Wenn wir die
Datensätze auf folgende Weise abspeichern (serialisieren):
readInTable{project = “test”, starttime = “1383216178”, endtime =
“1383216665”, duration = “487”}
readInTable{project = “test”, starttime = “1383216714”, endtime =
“1383216731”, duration = “17”}
und diesen Dateiinhalt als Lua-Code ausführen, dann wird
eine Funktion namens readInTable() mit den entsprechenden
Argumenten ausgeführt. Wir können unsere Tabelle also
folgendermaßen einlesen:
function readInTable(o)
table.insert(timetable, o)
end
dofile(filename)
dofile(filename) liest die genannte Datei und führt sie als
Lua-Code aus. Die Zeilen werden Stück für Stück eingelesen
und mittels readInTable() (o ist das Datensatzargument) an
das Ende von timetable angehängt. Für diese elegante
Lösung müssen wir die Tabelle lediglich entsprechend serialisieren:
function serialiseTable()
local f = assert(io.open(filename, “w”))
for i, v in ipairs(timetable) do
f:write(string.format(
“readInTable{project = \”%s\”, starttime = \”%d\”, endtime =
\”%d\”, duration = \”%d\”}\n”,
v.project, v.starttime, v.endtime or 0, v.duration or 0))
end
f:close()
end
-- Main code as before
outputTableToScreen()
serialiseTable()
Dieser Code sollte keine Überraschungen beinhalten, da
er nur eine Datei öffnet und schreibt sowie über eine Tabelle
iteriert. Zugegebenermaßen ist der Formatstring sehr hässlich
– beachten Sie die Escape-Zeichen an den
Anführungszeichen. Die einzige Neuerung ist der v.endtime
or 0-Ausdruck. Dieser ist gleichbedeutend mit:
if not v.endtime then v.endtime = 0 end
Dies ist notwndig, da v.endtime and v.duration bei einem
Projektstart nicht initialisiert sind und damit den Wert nil
haben – was wiederum in string.format() zu Problemen führen
würde. Starten Sie den Code und sehen Sie sich die
Ausgabedatei an. Sie sollte nun hübsch formatierte
Datensätze beinhalten. Nun benötigen wir nur noch eine
Funktion, um ein Projektende einzugeben:
function tableRecordEnd(title)
local timenow = os.time()
for i, v in ipairs(timetable) do
if v.project == title and tonumber(v.endtime) == 0 then
d = timenow - v.starttime
table.remove(timetable, i)
table.insert(timetable, i, {project = v.project, starttime = v.starttime,
endtime = timenow, duration = d})
print(string.format(“Duration was %d minutes %d seconds”,
d/60, d % 60))
break
end
end
end
dofile(filename)
-- input lines as before
if input == “s” then
tableRecordStart(project)
elseif input == “t” then
tableRecordEnd(project) 
else
error(“Projektstart abgebrochen”)
end
outputTableToScreen()
serialiseTable()
tableRecordEnd() iteriert über die Datensätze und sucht nach
einer Zeile mit dem richtigen Projektnamen, aber ohne Endzeitpunkt.
Wir verwenden tonumber(), da v.endtime ja aus einer Datei stammt
und dort als String abgelegt wird. Wenn wir einen Treffer erhalten,
verändern wir den Eintrag. In Lua genügt es allerdings nicht, den
aktuellen Iterationswert v zu verändern. Stattdessen löschen wir ihn
aus der Tabelle heraus und fügen einen neuen Datensatz mit gleichem
Schlüssel an. Anschließend verraten wir nur noch dem
Benutzer, wie lange er gearbeitet hat.
Wie üblich kann man den Code an zahllosen Stellen verbessern:
beispielsweise mit einer eine statistische Analyse der Projektzeiten.
Bei den unvermeidlichen Fragen zu Programmfehlern oder
gesuchten Funktionen hilft die ausgesprochen umfangreiche Lua-
Online-Dokumentation, darüber hinaus gibt eine Community gerne
Hilfe zur Selbsthilfe.
Der
Programmablauf
und ein Blick in
die Ausgabedatei.
Wenn die
Datei nicht existiert,
dann tritt
in dofile() ein
Fehler auf.
Schnelltipp
Sie können eine
Lua-Datei direkt
ausführbar
machen: Fügen
Sie die Shebang-
Zeile #!/path/to/
lua print(“Hello
World”) hinzu und
starten Sie sie mit
./hello.lua.
161

PC Games Hardware – Das IT-Magazin für
Gamer. Immer aktuell mit Kaufberatung,
Hintergrundartikeln und Praxistipps.
LEIDENSCHAFT FÜR GAMES

www.pcgameshardware.de • www.pcghx.de
DAS HARDWARE-MAGAZIN FÜR PC-SPIELER
HARDCORE
FÜR
SCHRAUBER
QR-Code scannen
und hinsurfen!
Neue Ausgabe jetzt am Kiosk erhältlich
oder einfach online bestellen unter:
www.pcgh.de/shop
Auch erhältlich als ePaper bei:

Professionelle Qualität zu attraktiven Preisen!
über 45 Jahre Erfahrung
50.000 Produkte am Lager
über 24-Std.-Versand schneller -
d
kein Mindermengenzuschlag
Kundenbewertungen
Raspberry
+zubehor
Über 97 % unserer Kunden
sind vom reichelt-Service
überzeugt*
*Quelle: Shopauskunft.de (15.01.2014)
zu einem
Top-Preis!
jetzt
entdecken!
„Eine Hi-tech-Himbeere,
unendlich viele
Möglichkeiten“
Raspberry Pi - eine kreditkartengroße
Platine mit schier endlos
vielen Einsatzmöglichkeiten
entdecken Sie den Mini-PC auf
unserer Raspberry-Themenseite.
Raspberry-Pi
Special-Themenseite
Raspberry Pi Bundle
mit 4-teiligem Kühlsatz!
• Gehäuse im reichelt-Look
• Netzteil, 1,2 A
• NOOBS (Betriebssysteme)
auf 8 GB SD-Karte
• Mini-WLAN-Adapter
• 4-tlg. Kühlsatz
RASPBERRY ALL IN
59,-
Katalog
01.1|2014!
http://rch.lt/b9
Jetzt bestellen:
++NEU+++NEU+++NEU+
Unterbrechungsfreie Stromversorgung
Die USV für Ihren Raspberry Pi
• mit Halterung für 6 AA-Batterien
• Kompatibel mit Arduino
• 3x LED-Anzeige
- Lieferung ohne
Raspberry Pi -
RASP PI USV 29,95
Leistungsfähige RPI-Erweiterung
NFC-konform mit NFC Karte
• NFC IC auf der Basis des NXP PN512,
erfüllt alle 3 NFC-Modi
• Reader Mode unterstützt 4 NFC Tag Typen
und proprietäre NXP MIFARE Befehle
• Flexible Schnittstellenauswahl (SPI oder I²C)
• Inklusive NXP MIFARE Ultralight NFC Karte
NFC [Near Field Communication]
RASP EXPLORE NFC 22,95
www.reichelt.de
Beste Verbindung!
raspberry Arduino
Gerduino
Bestell-Hotline: +49 (0)4422 955-333
Das Gertduino ist eine Erweiterung für
Ihren Raspberry Pi, mit der sich viele
Arduino Shields anschließen lassen.
• 2x Atmel Mikrocontroller ( AT328, AT48 )
• RTC • IrDA-Schnittstelle
• RS232-Pegelumsetzer
• Power-Backup für AT48
RASP GERTDUINO 29,95
Raspberry Pi, Modell B
mit 512 MB RAM
• Broadcom BCM2835
• HDMI-/RCA-Composite-Video
• 700 MHz ARM, Prozessor
• Open GL ES 2.0, OpenVG
• 10/100 BaseT-Ethernet
• SD-Karten-Steckplatz
• 2x USB 2.0
8 )
RASPBERRY PI B
38, 95
Kostenlos –
Jetzt anfordern!
Für Verbraucher: Es gelten die gesetzlichen Widerrufsregelungen. Alle angegebenen Preise in € inklusive der gesetzlichen MwSt., ab Lager Sande,
zzgl. Versandspesen für den gesamten Warenkorb. Es gelten ausschließlich unsere AGB (unter www.reichelt.de/agb, im Katalog oder auf Anforderung).
Zwischenverkauf vorbehalten. Alle Produktnamen und Logos sind Eigentum der jeweiligen Hersteller. Abbildungen ähnlich. Druckfehler, Irrtümer und
Preisänderungen vorbehalten. reichelt elektronik GmbH & Co. KG, Elektronikring 1, 26452 Sande (HRA 200654 Oldenburg)
Preisstand: 11. 03. 2014
Tagesaktuelle Preise:
www.reichelt.de