Software – Byobu Terminal

Fast jeder Linux Nutzer dürfte schon einmal, mehr oder weniger, mit dem Terminal in Berührung gekommen sein. Meist sind die vorinstallierten Terminals jedoch schlicht, was keineswegs falsch ist. Wer diese Möglichkeit der Befehlseingabe häufig in Anspruch nimmt, dem könnte leicht die einfache Verwaltung von verschiedenen Terminals, wie man sie von dem Fenstermanager gewohnt ist, fehlen. Eine Lösung für dieses Problem bietet Byobu. Das Skript bzw. Hilfsprogramm stellt im Grunde die Möglichkeiten einer Fensterverwaltung für die Kommandozeile bereit. Dafür verwendet die Software entweder den Shell-Fenstermanager Screen oder tmux.

Byobu mit einem Tab. - Quelle - Bildschirmfoto von Byobu
Byobu mit einem Tab – Quelle – Bildschirmfoto von Byobu

Installation

Byobu ist unter Ubuntu sogar in den Standard Paketquellen von main zu finden. Auch bei anderen Distributionen kann man die Software meist installieren, ohne weitere Paketquellen hinzuzufügen. Bei Debian basierten Distributionen lässt sich das entsprechende Paket beispielsweise über folgenden Befehl installieren.

sudo apt-get install byobu

Verwendung

Nach der Installation findet man in dem Menü einen Eintrag, um direkt ein Terminal mit Byobu zu starten. Möchte man dies jedoch manuell erledigen, kann man den folgenden Befehl verwenden.

byobu

Wenn die Software häufiger zu Einsatz kommt, kann man natürlich einen Starter auf dem Desktop oder in der Startleiste platzieren.

Ansicht

Nachdem die Anwendung gestartet wurde, präsentiert sie einem zunächst eine leicht veränderte Befehlszeile. Unten wird jedoch eine kleine Leiste eingeblendet die Informationen zu dem System, wie etwa Zeit, Prozessorauslastung, verfügbarer Arbeitsspeicher und mehr, anzeigt. Bei Bedarf kann man Byobu so konfigurieren, dass auch andere Informationen eingeblendet werden.

Über die Taste F9 gelangt man in das Menü von Byobu. Dort kann man unter dem Menüpunkt „Statusmeldungen ändern“ die in der Statusleiste anzuzeigenden Informationen auswählen.

Steuerung

Einer der Hauptfunktionen ist jedoch die Möglichkeit in einem Fenster mehrere Sitzungen zu starten und sie wie bei einem Tiled Fenstermanager (z.B. I3) anzuordnen. Diese Funktion lässt sich sehr simple über Tastenkombinationen steuern. Für diese Funktion verwendet Byobu die eigentlichen Shell-Fenstermanager Screen oder tmux.

Tastenkombination Funktion
F2 Startet eine neue Sitzung in einem neuen Tab.
F3 Wechselt zur vorherigen Sitzung (Tab links).
F4 Wechselt zur nächsten Sitzung (Tab rechts).
Shift + F2 Teilt die aktuelle Sitzung Horizontal.
Strg + F2 Teilt die aktuelle Sitzung Vertikal.
Shift + F3 Setzt den Fokus auf die vorherige Teilsitzung.
Shift + F4 Setzt den Fokus auf die nächste Teilsitzung.
Shift + F5 Verbindet alle Teilsitzungen.
Shift + F6 Entfernt die aktuelle Teilsitzung.
Strg + D Sitzung beenden und Tab schließen.

Einige der Funktionstasten

Besonderheiten

Im Gegensatz zu den herkömmlichen Terminals wird bei Byobu ein Prozess beim Schließen des Fensters nicht beendet, sondern läuft im Hintergrund weiter. Startet man nun Byobu erneut, so findet man den Zustand vor dem schließen des Fensters vor. Damit der Prozess beendet und das Fenster geschlossen wird, kann man die Tastenkombination Strg + C und anschließend Strg + D verwenden.

Byobu mit 3 Teilsitzungen - Quelle - Bildschirmfoto von Byobu
Byobu mit 3 Teilsitzungen – Quelle – Bildschirmfoto von Byobu

Details

Aktueller Debian Maintainer der Open Source Software ist Dustin Kirkland. Das Projekt steht momentan unter der GPL v.3 Lizenz.

Tipps und Tricks

Wem die Hintergrundfarbe des Terminals nicht gefällt, kann mit der Tastenkombination Strg + Shift + F5 die Farbe durch eine zufällig ausgewählte Farbe ersetzen. Dafür muss man sich allerdings im sogenannten byobu-tmux Modus befinden. Der Modus bedeutet im Grunde nur, dass die Anwendung den tmux Shell-Fenstermanager verwendet.

Hat man beide Shell-Fenstermanager installiert, kann man über den Befehl byobu-screen oder byobu-tmux der Anwendung vorschreiben welchen sie benutzen soll.

Die jeweiligen Skripts für die Statusmeldungen findet man unter dem Pfad “/usr/lib/byobu/“.

Über die Tastenkombination Shift + Pfeiltasten kann man ebenfalls zwischen den Teilsitzungen navigieren.

Weitere Infos

Für weitere Informationen zu dem Programm habe ich hier ein paar Quellen aufgelistet.

– In der Man Page von Byobu findet man im Grunde alles, was man wissen muss. (Englisch)

– Auf der entsprechenden Seite des Wikis von Ubuntuusers.de findet man einen Überblick. (Deutsch)

Fazit

Mir hat Byobu sehr gut gefallen, besonders die Option mit den Teilsitzungen ermöglicht mir nun weniger Fenster geöffnet zu haben. Wem der Fenstermanager I3 gefällt, aber für grafische Programme einen anderen nutzten möchte, der wird bei dem Hilfsprogramm Byobu fündig. Ich empfehle jedem diese Software einmal auszuprobieren.

KurzeTipps – Backups von den Steam Spielen

Da ich öfters mal mein Betriebssystem neu installiere und dabei auch die Spiele auf Steam erneut heruntergeladen werden müssen, habe ich mir einen Plan ausgedacht, um in Zukunft etwas Zeit zu sparen. Da ich mehrere Festplatten habe und davon auch eine für meine Backups zuständig ist, werde ich dort in einem extra Ordner die Backups von den Spielen platzieren.

Anleitung

Zunächst installiert man die jeweiligen Spiele erst einmal wie gewohnt in dem Verzeichnis der Standard Spielbibliothek von Steam. Danach wird ein Backup von dem Spiel angelegt. Die Option dazu findet man über das Kontextmenü des Spieles unter dem Punkt „Backup Game Files“. Nachdem dies erledigt ist, öffnet man den Ordner in dem die Backups von Steam abgelegt werden und kopiert diese auf die Festplatte die für Backups zuständig ist.

Bei einer Neuinstallation des Betriebssystems können, nachdem Steam installiert wurde, nun die Spiele aus den Backups wiederhergestellt werden. Natürlich könnte man auch eine Backup Software wie zum Beispiel DeJa Dup so konfigurieren dass automatisch ein Backup von diesen Dateien auf einem externen Medium angelegt werden soll. So erspart man sich mit Backups nicht nur eine menge Zeit, sondern entlastet auch sein Netzwerk.

News – Ubuntus jüngstes Familienmitglied Ubuntu MATE

Die Ubuntu Familie hat ein neues Mitglied bekommen. Der Neuzugang nennt sich Ubuntu MATE und hat, am Namen bereits erkennbar, die Desktopumgebung Mate mit an Bord. Zur Zeit existiert bereits eine erste Beta von 15.04 womit die erste offizielle Ubuntu MATE Version 15.04 sein wird.

Was ist Mate ?

Der Mate Desktop ist aus dem drastischen Übergang von Gnome 2 zu Version 3 entstanden und basiert im Grunde auf Gnome 2.32. Dabei wird der Desktop regelmäßig weiter entwickelt und mit ein paar neuen Features versehen.

Ubuntu MATE im Detail

Im Juni 2014 tauchte erstmals die Idee von einem Ubuntu MATE Remix auf. Bei der ersten Veröffentlichung wurde der Remix dann in Ubuntu MATE umbenannt. Im August 2014 wurde dann der Status als offiziell unterstützte Ubuntu-Version von dem Projekt beantragt. Dies hat zum Beispiel den Vorteil das die Images über die Ubuntu-Server heruntergeladen werden können. Weiter kann dass Projekt nun von der Infrastruktur von Canonical zum erstellen der Ubuntu-Version profitieren. Abseits davon wird sich an Ubuntu MATE nicht viel ändern, die Ubuntu-Variante wird weiterhin von der Community erstellt.

Software – gitk

Die Versionsverwaltung git dürfte vielen bereits bekannt sein, da der Mensch anders als ein Computer große Datenmengen am besten grafisch verarbeiten kann, gibt es Software welche die Daten von Git grafisch darstellt.
Eine solche Software ist das Open Source Programm gitk, welches sogar ein offizieller Bestandteil des Git-Projektes ist.

Überblick

Die Software benutzt für die grafische Benutzeroberfläche die Tk Bibliothek und lässt sich daher, wenn auch meist im schlichtem Retrolook, unter fast allen Fenstermanagern benutzen.
Nach dem Starten über den Befehl gitk erscheint ein neues Fenster welches einem erst mal eine Vielzahl von Informationen zu dem Git-Repository liefert.

Quelle - Bildschirmfoto von gitk
Quelle – Bildschirmfoto von gitk

Installation

Um die Software zu installieren, benutzt man den jeweiligen Paketmanager, für apt benutzt man beispielsweise folgenden Befehl, um das Paket gitk zu installieren.
Das Paket ist in den offiziellen Paketquellen von Ubuntu vorhanden.

Pakete:
gitk (main)

sudo apt-get install gitk

Erweiterung

Mit der Installation des Programms git-gui kann man weitere Funktionen bei gitk nutzen.
So wird diese Abhängigkeit z.B. für die git blame Funktionalität benötigt.

Benutzung

Die Software lässt sich sehr einfach bedienen und die Bedienelemente sind meistens selbsterklärend.
So benötigt man für einen schnellen Test nur ein Terminalfenster, ein Git-Projekt sowie gitk.
Zuerst wechselt man mithilfe des Terminals und dem Befehl cd in das Verzeichnis des Projektes.
Darauf folgend verwendet man das Kommando gitk und schon öffnet sich das Fenster in dem der aktive Branch angezeigt wird.

cd GitProjekt
gitk

Möchte man alle Branches angezeigt bekommen so wird das Argument all an den Befehl angehängt.

gitk --all

Infoelemente

Eine grafische Darstellung der einzelnen Versionen wird auf dem ersten Feld, links oben angezeigt.
Rechts daneben befinden sich Informationen zum Absender und Zeitpunkt der Version.
Darunter ist eine Leiste mit Filtermöglichkeiten für die Daten vorzufinden.
Unten findet man linksseitig die Daten der ausgewählten Version und rechts daneben die Beschreibung / Dateiliste.

Einstellmöglichkeiten

Jeder hat einen anderen Geschmack, daher gibt es bei fast jeder Software Möglichkeiten das Aussehen und Verhalten seinen Vorlieben anzupassen.
Grundlegend können die verschiedenen Farben und Schriftarten über Bearbeiten → Einstellungen festgelegt werden.

Quelle - Bildschirmfoto von gitk
Quelle – Bildschirmfoto von gitk

Neue Ansichten

Über den Menüeintrag Ansicht → Neue Ansicht lassen sich die angezeigten Daten nach weiteren Kriterien filtern.
Diese Ansichten können bei Bedarf auch für den späteren Einsatz gespeichert werden.
So lässt sich zum Beispiel eine Ansicht anlegen, die automatisch die Informationen zu den eigenen Änderungen anzeigt.

Fazit

Das seit 2005 existierende Tool gitk ist sehr praktisch und simple aufgebaut.
Es muss nicht immer alles kompliziert und überladen mit unnötigen Funktionen sein, um als gute Software zu gelten.
Gitk zeigt, dass man mit wenig Aufwand einen guten Überblick von seinen Projekten behalten kann.
Eine klare Empfehlung meinerseits für alle die ihre Projekte verwalten wollen.

Neues Gewand für 2015

Ich habe, auf der Basis von den alten Farben, ein neues Gewand für meinen Blog geschneidert. Dafür habe ich als Basis das Theme Twenty Fifteen von WordPress genommen. Somit ist es wesentlich einfacher, neue Elemente oder Updates einzuspielen. Falls ihr Vorschläge für Verbesserungen habt, könnt ihr mir dies über die Kommentarfunktion mitteilen.

Es gibt zwar noch ein paar Stellen, die ausgebessert werden müssen, jedoch wird dies recht schnell vonstatten gehen. Ich werde in einem späteren Artikel zeigen, wie man sich so ein Theme selber basteln kann.

Programmieren – Grundlagen von C: Einlesen von Daten

Wörter sind schon etwas Feines, man kann mit ihnen Informationen austauschen.
Ob sachlich oder ganz persönlich, ohne Wörter würde man wahrscheinlich noch in der Steinzeit leben.
In dem zweiten Teil dieser Artikelserie geht es deshalb um den Datentypen char und das einlesen von Daten.
Zusätzlich wird der Begriff Array im Zusammenhang mit Text angesprochen sowie das zuweisen von Werten bei Variablen.

Datentyp Char

Um Zeichen, wie zum Beispiel Buchstaben, in C zu benutzen, gibt es den Datentypen char.
Variablen deklariert man in der Programmiersprache C über den Syntax char.
Konstanten von dem Typ char werden immer in Hochkommata (‘) eingeschlossen, so auch beim zuweisen von Werten.

char Buchstabe;

Arrays und Zeichenketten

Um ganze Wörter zu verwenden, benötigt man eine Zeichenkette (engl. string) welche im Grunde ein Array vom Typ char ist.
Dies kann man sich in etwa, wie eine Aneinanderreihung von Elementen, in diesem Fall Zeichen, vorstellen kann.
Im Gegensatz zu einigen anderen Programmiersprachen gibt es unter C keinen eigenen Datentyp für Zeichenketten.
Dabei muss man beachten, das standardmäßig in Zeichenketten keine Sonderzeichen, wie beispielsweise Umlaute, vorkommen dürfen.

Ein Array wird deklariert, indem man eine Variable anlegt, mit der Besonderheit, dass direkt hinter dem Variablennamen, zwischen zwei eckigen Klammern die Anzahl der gewünschten Elemente steht.
Nach dem Inhalt eines Arrays folgt die binäre Null. Sie signalisiert das Ende des Datenstromes, vergleichbar mit dem Punkt nach dem Satzende.
Manuell setzten muss man die binäre Null bei Zeichenketten nur in wenigen Fällen, da dies normalerweise von den Funktionen in C getan wird.

Dabei muss beachtet werden, dass die Anzahl an Elementen zwar bei 0 anfängt, jedoch immer die binäre Null mit eingerechnet werden muss.
Was bedeutet, bei 10 Feldelementen wird ein Array mit der Anzahl von 10 angelegt.
Die jeweiligen Elemente sind dann von 0 bis 9 erreichbar und Feldelement 10 ist die binäre Null.

Variablen für Zeichenketten deklariert man über den folgenden Syntax:

char Wort[5];

/* Beispiel: Array */
Wort = "Hallo";

/*
	Wort[0] = H
	Wort[1] = a
	Wort[2] = l
	Wort[3] = l
	Wort[4] = o
	-----------------
	Wort[5] = \0 (binäre Null)
*/

Konstanten

Häufig braucht man beim programmieren Werte die sich während des Programmablaufs nicht ändern.
Dazu verwendet man sogenannte Konstanten, welche das Gegenstück zu Variablen darstellen.

Typ Konstante
int z.B. 1 oder 4
char z.B. ‘a’ oder ‘h’
Zeichenkette z.B. “Hallo” oder “Wort”

Variablen

Variablen sind mit das Wichtigste in der Programmierwelt, sie ermöglichen einem Informationen während des Programmablaufs bereitzuhalten.
Aus der Mathematik kennen viele bereits den Begriff der Variablen, man rechnet oft mit x oder y.
Beim Programmieren verhält sich dies sehr ähnlich zu der Mathematik, die Variablen gelten auch hier nur so lange dass Programm läuft (bzw. nur für eine Funktion).
Variablen haben immer einen vorher festgelegten Datentypen, ein paar sind bereits vorgestellt worden, und ihnen kann man einen Wert zuweisen.

In C gibt es einige Regeln die man einhalten muss, um Variablen nutzen zu können.
So dürfen Variablennamen nur maximal 31 Zeichen lang sein und ausschließlich aus den Buchstaben a-z und A-Z sowie Ziffern und dem Unterstrich (_) bestehen.
Ziffern dürfen nicht am Anfang stehen. Der Name ist zwar beliebig aber es wird allgemein empfohlen sinngemäße Namen zu wählen (z.B. summe, ergebnis, name, etc.).
Auch ist C hierbei case-sensitive, was bedeutet das die Groß- und Kleinschreibung, ähnlich wie bei Passwörtern, wichtig ist.
Beispielsweise ist die Variable mit dem Namen Regen eine andere, als die mit dem Namen regen.

char Name; /* Variable wird angelegt (deklariert) */
Name = 'T'; /* Der Variable wird ein Wert zugewiesen (definiert) */

Variablen Werte zuweisen

Damit man Variablen richtig nutzen kann, muss man sie nicht nur deklarieren, sondern ihnen auch Werte zuweisen.
Beim Zuweisen nimmt der Wert einer Variable entweder den Wert einer anderen Variable oder den einer Konstanten an.
Dafür wird der Variablenname der zuzuweisenden Variable auf die linke und der Wert auf die rechte Seite von dem Gleichheitszeichen geschrieben.
Dies funktioniert im Eigentlichen, wie in der Mathematik (x=1) und im Sprachjargon wird das Zuweisen auch als definieren bezeichnet.

char Buchstabe;
Buchstabe = 'a';

int x;
x = 1;

Einlesen von Werten

Da man bei einem Programm, im herkömmlichen Sinne, nicht jedes mal den Quelltext abändern möchte um andere Werte zu benutzen, nutzt man z.B. die Funktion scanf aus der Standardbibliothek stdio.h.
Beim Aufrufen benötigt scanf zwei Argumente. Der erste Parameter ist eine Zeichenkette welcher den einzulesenden Datentyp in der gleichen Form wie bei printf (Platzhalter) bereithält.
Bei dem zweiten Argument wird ein sogenannter Zeiger (engl. pointer) auf die Variable, in die der Wert geschrieben werden soll, angegeben.

Ein Pointer kann man sich wie einen Link im Internet vorstellen, die eigentliche Seite liegt zwar nicht auf dem eigenem Server, jedoch ein Verweis auf den jeweiligen Server.
Nach diesem Prinzip ist ein Zeiger ein Link auf die Speicherstelle der Variable im Arbeitsspeicher, womit sie dann, von anderen Funktionen aus bearbeitet werden kann.
Um einen Pointer anzugeben, wird beim Verwenden einfach vor dem Variablennamen ein kaufmännisches Und (&) gesetzt.

char Buchstabe;
scanf("%c", &Buchstabe);

Kommentare im Quelltext

Um nicht die Übersicht zu verlieren und Informationen darzustellen, gibt es sogenannte Kommentare.
Diese werden in C über den Syntax /* begonnen und müssen mit */ wieder aufhören, die Länge ist dabei beliebig.
Normalerweise ist die Schachtelung von Kommentaren nicht erlaubt.

Bei einigen Editoren gibt es mit der Syntaxhervorhebung auch die Funktion in Kommentaren etwas zu markieren.
Häufig sind dies die Begriffe INFO und TODO.

/* Dies ist ein Kommentar */
/* INFO: Dies ist eine Info. */
/* TODO: Dies ist eine Aufgabe. */

Beispielprogramm

Im Folgenden wird ein Beispielprogramm mit den vorhin oder in der Vergangenheit, erklärten Elementen vorgestellt.
Dabei wird immer die gesamte Datei in dem Codeblock repräsentiert, der dazugehörige Dateiname steht immer unter diesem.
Wie man den Quellcode kompiliert, kann man in Teil 1 nachlesen.

#include <stdio.h>

int main()
{
	/* Variable Namen anlegen: Array mit 20 Elementen */
	char Name[20];
	
	/* Anweisung ausgeben */
	printf("Geben sie ihren Vornamen ein (Maximal 20 Zeichen): ");
	
	/* Name einlesen */
	scanf("%s", &Name);
	
	/* Name ausgeben */	
	printf("\nSie heißen: %s\n", Name);

	return 0;
}

Datei: main.c

Legende

Als binär bezeichnet man Daten, die im dualen Zahlensystem gehalten sind, also 1 oder 0.

Aufgabe

Damit man in der Zeit zwischen den einzelnen Teilen, etwas zum Üben hat, habe ich beschlossen ab jetzt bei jedem Teil eine Aufgabe zum Thema zu stellen.
Die Lösung steht dann immer in dem darauf folgenden Teil, sodass man sie mit seiner vergleichen kann.
Passend zum Thema, lautet die Aufgabe ein Programm zu schreiben, welches Vorname, Nachname und die Stadt abfragt und dann einen Satz nach dem folgenden Muster ausgibt.

Max Mustermann wohnt in der Stadt Musterhausen.

Ausblick

Im nächsten Teil geht es um dass rechnen mit Zahlen und wie man in C Fließkommazahlen benutzt.
Es wird in Zukunft voraussichtlich jede Woche ein neuer Teil erscheinen.

Fazit

In diesem Teil hat man gelernt, wie man in C mit Text umgehen kann und einiges mehr.
Was manchem beim Lesen auf den ersten Blick komplex erscheint, ist eigentlich recht simple.
Man könnte nun beispielsweise Programme für das Bilden von Texten programmieren.

Programmieren – Die Grundlagen von C: Hallo Welt

Wer wollte nicht schon einmal ein eigenes Programm schreiben?
Um einen ersten Einblick über die Grundlagen von Programmiersprachen zu geben habe ich beschlossen, angefangen bei der Sprache C, eine neue Kategorie mit Inhalten zu füllen.
Die Programmiersprache C ist eine der am weitest verbreitetsten Programmiersprachen weltweit und auch einer der älteren Sprachen.
Dank des ebenfalls in C geschriebenen Kernels bietet sie unter Linux sogar über die sogenannten Header Dateien eine Schnittstelle an.
Viele andere Programmiersprachen sind von dem Syntax her C ähnlich.

Der Datentyp int

In der Programmiersprache C gibt es wie bei allen Sprachen mehrere Datentypen, der wichtigste ist hierbei die Zahl.
Genauer die ganze Zahl im englischen wie auch im C Syntax wird dies als Integer bezeichnet und im Quellcode das Kürzel int verwendet.
Dies bedeutet dass eine Variable vom Typen int z.b. den Wert 1, 2, 3 etc. aber nicht 1.5 annehmen kann.
In C wird praktischerweise vieles als Integer behandelt was einem eine einfache Methode zum verarbeiten von Daten bietet.
So kann man zum Beispiel einen Buchstaben auch als Zahl verwenden.

Die Main Funktion

Um überhaupt ein Programm zu erschaffen braucht es bei C immer die sogenannte Main Funktion.
Sie wird bei dem ausführen eines Programms als erste aufgerufen und im Idealfall bildet sie auch den Abschluss.
Im deutschen würde man so etwas als Hauptfunktion bezeichnen.

Diese Funktion ist von dem bereits erwähnten Datentypen int und wird folgendermaßen definiert.
Zuerst wird der Typ der Funktion angegeben (int) danach kommt der Name (main) und in den Klammern können noch Parameter angegeben werden die beim aufrufen dieser übergeben werden.
In den geschweiften Klammern steht der Quellcode der beim aufrufen ausgeführt werden soll.
Dabei bedeutet die Zeile return 0; , dass am Ende die Zahl 0 zurückgegeben werden soll.
Hierbei sei gesagt, dass in der Main Funktion bei Rückgabe von 0 dem Betriebssystem mitgeteilt wird, dass das Programm erfolgreich ausgeführt wurde und der Speicher geleert werden kann.

int main()
{
	return 0;
}

Bibliotheken

Die Bibliotheken funktionieren bei Programmiersprachen fast genauso wie bei Büchern.
In Büchereien findet man in den zahlreichen Büchern die Informationen die man gerade braucht sodass man diese nicht selber recherchieren muss.
Um eine häufig gebrauchte Aufgabe in einem Programm nicht jedes mal von vorne zu programmieren benutzt man Bibliotheken in denen einzelne Funktionen für diese Aufgaben bereits enthalten sind.

Jede Bibliothek besteht dabei aus mehreren Headerdateien in denen wiederum die Funktionen und Datentypen deklariert werden.
Nach dem einbinden der einzelnen Headerdateien über den Syntax #include kann man die in ihnen deklarierte Funktionen verwenden.
Bei Standardbibliotheken werden die Dateinamen zwischen den spitzen Klammern < und > geschrieben.
Dies weist den Compiler an die Headerdatei in den ihm bekannten Bibliotheksverzeichnissen zu suchen.
Falls man eigene Headerdateien im jeweiligen Projektverzeichnis verwenden möchte, nutzt man Anführungszeichen.

Die wichtigsten Bibliotheken unter C sind die von C selbst, in ihnen stehen all die Funktionen und Datentypen die den Syntax von C ergeben.
Um sie einzubinden verwendet man folgenden Quelltext welcher ganz oben stehen muss.
Dabei ist stdio.h die Standardbibliothek für Ein- und Ausgabe und muss bei fast jedem Programm eingebunden werden.
In ihr ist zum Beispiel die Funktion printf, mit der man Text ausgeben kann, enthalten.

#include <stdio.h>

Ausgeben von Text

Um Text in die Konsole auszugeben wird die Druckfunktion (printf) aus der Bibliothek stdio.h verwendet.
Mit ihr kann man nicht nur Text ausgeben sondern über sogenannte Platzhalter in dem auszugebenden Textes auch Werte von Variablen jeden Typs einfügen.
Diese Platzhalter werden in dem Text über das Prozentzeichen gefolgt von dem jeweiligen Buchstabens des Datentyps festgelegt.
Nach dem ersten Parameter, welcher den auszugebenden Text darstellt, wird für jeden Platzhalter der reihe nach Parameter mit den entsprechenden Variablen angelegt.
Über bestimmte Zeichenabfolgen, sogenannte Escapesequenzen, können Textformationen wie beispielsweise ein Zeilenumbruch (\n) in dem Text untergebracht werden.

printf(„Dies ist der Text aus Zeile: %i\n“, 0);
Platzhalter Datentyp
%i Integer (Zahl)
%c Char (Zeichen)
%s String (Text)

Das erste Programm: Hallo Welt

Klassisch ist dass Beispielprogramm Hallo Welt, dank des simplen Aufbaus ist jedoch für diesen Zweck ideal geeignet.
Dafür werden die zuvor erwähnten Elemente verwendet welches in dem nachfolgenden Beispielcode aufgeführt wird.
Diesen speichert man in der Datei namens main.c wobei der Dateiname natürlich beliebig gewählt werden kann wobei die Endung .c notwendig ist um dem Compiler später die verwendete Programmiersprache mitzuteilen.

#include <stdio.h>

int main()
{
	printf(„Hallo Welt!\n“);
	return 0;
}

Erstellen des Quellcodes

Um aus C Quelltext ein Programm zu erstellen braucht es 2 Arbeitsschritte (kompilieren und linken), diese jedoch werden meist beide von dem sogenannten Compiler abgearbeitet.
Dabei wird der Code in Menschen lesbarer Textform zu eine vom Betriebssystem ausführbare Binärdatei verwandelt.
Diese besteht aus Einsen und Nullen welche dem Computer im Grunde Anweisungen geben.

Unter Linux verwendet man am besten den GNU-Compiler gcc welcher in den meisten Fällen entweder bereits vorinstalliert oder in den Paketquellen enthalten ist.
Man findet ihn in dem Paket gcc.

Um nun mit dem Compiler den Quellcode zu kompilieren wechselt man mit einem Terminal in das Verzeichnis in dem die zu kompilierende Quelldatei liegt.
Danach führt man den folgenden Befehl aus.

gcc -o helloworld main.c
Parameter Bedeutung
gcc Aufruf des GNU-Compilers.
-o helloworld Der Buchstabe o steht für output.
Nach einem Leerzeichen folgt der Dateiname welcher für die kompilierte Datei benutzt werden soll.
Im Beispiel wird die Datei helloworld erstellt.
main.c Name der zu kompilierenden Datei.
Im Beispiel wird die Binärdatei aus der Quelldatei main.c erstellt.

Legende von den Fachwörtern

Da man beim Programmieren eine sehr fachbezogene Thematik hat, gibt es für alles immer ein Fachwort.
Um Neulinge nicht gleich ins kalte Wasser zu stoßen findet man in diesem Abschnitt eine kurze Erklärung von Wörtern die man zum Verständnis des Artikels braucht.

Funktionen sind im Grunde Aufgaben, beispielsweise kann eine Funktion zum addieren oder drucken existieren.
Diese können beliebig oft aufgerufen werden ohne immer wieder ihren Quelltext aufschreiben zum müssen.

Parameter sind Angaben welche dynamisch, also nicht immer gleich, sind.
Funktionen enthalten Parameter wie beispielsweise die Funktion addiere den Parameter A und B hat.
Die beiden Parameter A und B werden addiert und dann zurückgeben.

Ausblick

Nächstes mal geht es um den zweiten wichtigen Datentypen Char und dass einlesen von Text mit einem weiteren Beispiel.

Fazit

Durch wenig Aufwand ist man schnell zu einem ersten Programm gekommen und hat dabei erste Grundlagen von C gelernt.
Da dies längst noch nicht alles an den Grundlagen darstellt, möchte ich diese in späteren Artikeln behandeln.

Nachtrag:
Dank eines aufmerksamen Lesers habe ich die, natürlich, falsche Bezeichnung zu Datentyp korrigiert.

Skript – Bildschirmfoto automatisch benennen

Mit Skripten lässt sich nicht nur Zeit sparen sondern sie erleichtern einem auch dass Leben, ein Thema bei dem so manch Autor Zeit aufwendet sind Bildschirmfotos.
So wird beispielsweise nicht nur der Artikel zu einem Spiel geschrieben sondern auch während des Spielens eine menge Bildschirmfotos gemacht um ein paar in dem besagten Artikel zu verwenden.
In diesem Artikel möchte ich zeigen wie man mit einem einfachen Skript diese Arbeit per Tastendruck zu erledigen.
Dabei werden Tools benutzt die bei vielen Distributionen bereits vorinstalliert sind und die mit wenig Aufwand weitere Anpassungen zulassen.

Was brauche ich?

Für die Bildschirmaufnahme wird die weit verbreitete Software gnome-screenshot und für die Tastenkonfiguration dass Systemeinstellungswerkzeug, ebenfalls von dem Gnome Projekt, verwendet.

Falls dass Werkzeug zur Bildschirmfotoerstellung nicht bereits installiert ist kann dies über die
Installation von folgendem Paket getan werden.
Dafür benutzt man den jeweiligen Paketmanager, bei apt würde beispielsweise dieser Befehl genügen.

apt-get install gnome-screenshot 

Das Skript

Als erstes erstellt man eine Datei mit dem späteren Namen des Kommandos welcher auf die Dateiendung .sh enden sollte.
Die erste Zeile gibt an mit welchem Programm diese Datei später ausgeführt werden soll.
Darauf folgend kann man sich über ein Kommentar wichtige Informationen wie dass spätere Tastenkürzel aufschreiben.
Dabei fängt jede Kommentar Zeile mit einer Raute an, diese teilt dem Programm mit dass der folgende Inhalt ignoriert werden soll.

#!/bin/bash
# Tastenkombination: ALT F5

Darauf folgend definiert man zwei Variablen in denen später Informationen gespeichert oder gelesen werden.
Die erste Variable trägt den Name appname und beinhaltet den Titel der Applikation die man derzeit aufnehmen möchte.
Dabei wird sie später benutzt um den ersten Teil des Dateinamen des aufgenommenen Bildschirmfotos zu bilden und muss manuell gesetzt werden.

Die nächste Variable wurde als number benannt und deren Wert wird von dem Skript automatisch gesetzt.
Sie bildet den abschließenden Teil des Dateinamens und wird im nächsten Schritt hochgezählt.

appname="Firefox"
number="0"

In diesem Teil legt man eine sogenannte Zählschleife (for) an welche nach jedem Durchlauf den Wert der Zähl Variable (hier z) solange um einen erhöht bis dieser eine vorher festgelegte Höhe überschreitet.
Mit done signalisiert man das Ende der Schleife und nach dem Durchlauf wird an dieser Stelle zurück zum Anfang der Zählschleife gesprungen.

for ((z=0;z<=100;z++))
do
…
done

Innerhalb der Schleife wird eine sogenannte Bedinge Anweisung (im engl. if statement) ausgeführt.
Bedingte Anweisungen führen den inneren Quellcode nur dann aus wenn ihre Bedingung erfüllt ist.
In diesem Beispiel wird geprüft ob die Datei mit dem Namen schon existiert.
Wem hier der Pfad mit den beiden Dollarzeichen komisch vorkommt dem sei noch gesagt dass diese die beiden Variablen von oben widerspiegeln.
Quellcode der nach then kommt wird immer dann ausgeführt wenn die Bedingung erfüllt ist, in diesem Fall wird die Variable number um einen erhöht.

Um etwas für den Fall dass die Bedingung nicht erfüllt ist zu definieren verwendet man else.
In diesem Beispiel wird der Befehl zum aufnehmen des Screenshots ausgeführt und über break die Anweisung zum vorzeitigen unterbrechen der Zählschleife gegeben.
Ähnlich wie zuvor wird nur der eingerückte (einmal Tabulatortaste drücken) Quelltext ausgeführt.
Um die bedingte Anweisung wieder zu schließen nutzt man einfach dass Wort fi.

if [ -f "/home/username/Bilder/$appname-Screenshot$number.png" ]
	then
		((number++))
	else
		gnome-screenshot --window --remove-border –file="/home/username/Bilder/$appname-Screenshot$number.png"
		break
fi

Dass fertige Shell Skript:

#!/bin/bash
# Tastenkombination: ALT F5
appname="Firefox"
number="0"
for ((z=0;z<=100;z++))
do
	if [ -f "/home/username/Bilder/$appname-Screenshot$number.png" ]
		then
			((number++))
		else
			gnome-screenshot --window --remove-border --file="/home/username/Bilder/$appname-Screenshot$number.png"
			break
	fi
done

Bitte beachten:
In den Codebeispielen wird der Pfad /home/username/…. verwendet, diesen bitte an dass eigene Benutzerverzeichnis anpassen.

Die Tastenkombination

Damit man am ende nur eine Tastenkombination für ein Screenshot betätigt werden muss sollte man diese in den Systemeinstellungen festlegen.
Meist findet man die in den Konfigurationsmöglichkeiten der Tastatur wieder.
In dem Beispiel wird eine eigene Tastenkombination hinzugefügt und als Befehl der Pfad zu dem eben erstellten Skript festgelegt.
Nach einer Bestätigung des Dialoges kann nun jederzeit ein Bildschirmfoto mit den in der vorhin erstellten Datei gesetzten Parametern aufgenommen werden.

Das Tastenkürzel anlegen - Quelle – Bildschirmfoto von Gnome Einstellungsmanager
Das Tastenkürzel anlegen – Quelle – Bildschirmfoto von Gnome Einstellungsmanager

Fazit

Mit so einem Skript lässt sich nicht nur Stück für Stück eine menge Zeit sparen sondern es macht meiner Meinung nach auch eine menge Spaß sie zu erstellen.
Man schafft sich Skript für Skript seine eigene Bibliothek an kleinen Helfern für den Alltag.
Dieses Skript erlässt einem dass lästige aufnehmen und benennen der Bildschirmfotos während man beispielsweise ein Spiel spielt um später einen Artikel darüber zu schreiben.
Darüber hinaus hat man mithilfe diesen kleinen Projektes ein paar Grundlagen aus der Programmierung gelernt.

GIMPThings – Cartoon Hintergrund

In diesem Artikel geht es darum zu zeigen wie man ein Bild mit Cartoon ähnlichem Aussehen mithilfe des freien Bildbearbeitungsprogramms GIMP erstellen kann.
GIMP ist eine vielseitig einsetzbare Software in der man recht schnell zu ersten Erfolgen kommt.
Dabei gibt es zahlreiche Anleitungen im Internet und viele Foreneinträge sodass man fast immer die Lösung zu seinen Problemen findet.
In dem unterem Bild kann man sehen wie das Resultat aus dieser Anleitung aussehen kann.

Quelle - Eigene Grafik
Quelle – Eigene Grafik

Schritt 1

Als erstes öffnet man GIMP und erstellt über den Menüpunkt Neu in dem Reiter Datei eine neue Grafik angelegt.
In dem sich nun öffnen Dialog kann man Breite und Höhe der Grafik in Pixel angeben und anschließend über einen klick mit der linken Maustaste auf Neu bestätigen.
In dem Beispiel werden für die Bildbreite 1920 und für die Bildhöhe 1080 Pixel als Werte verwendet.
Die Auflösung ist beliebig jedoch schlage ich die Auflösung des jeweiligen Monitors für die bestmögliche Qualität vor.

Schritt 2

Nun legt man den eigentlichen Hintergrund an indem man in mehreren kleinen Schritten 3 Balken erstellt.
Dabei Wird zunächst mit dem Auswahlwerkzeug gearbeitet welches man über dass Icon, was wie ein Rechteck mit gestricheltem Rand aussieht, auswählen kann.
Nun müssen noch einige Parameter eingestellt werden um die Arbeit zu erleichtern, daher sollte man bei der Option Fest einen hacken setzten und die Auflösung mit der Breite der Grafik und als Höhe ein drittel von dem Bild angeben.
Bei dem Beispiel wurde eine Auflösung von 1920×360 eingesetzt.
Danach klickt man auf eine stelle oben im Bild und zieht kante oben links bis an den Bildrand.
Dabei kann ein zoomen über STRG + Mausrad hilfreich sein.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 3

Folgend wählt man die erste Farbe aus indem man auf die farbige Schaltfläche unter den Icons mit der linken Maustaste klickt.
In dem anschließendem Dialog wählt man eine beliebige Farbe aus, in dem Beispiel wird Blau verwendet.
Um den gleichen Farbton zu bekommen kann man den Farbcode 225d8a in dass Feld HTML-Notation eingeben und auf die Eingabetaste drücken.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 4

Nun wählt man dass Füllwerkzeug über dass Icon, welches wie ein Farbeimer aussieht und in der linken Seitenleiste platziert ist, aus.
Danach klickt man auf die in Schritt 3 ausgewählte Fläche mit der linken Maustaste um diese mit der Farbe zu füllen.
Anschließend wiederholt man Schritt 2 bis 4 mit dem Unterschied dass diesmal die Auswahl nach unten verschoben wird.

Schritt 5

Im Anschluss wählt man über die Farbauswahl (Siehe Schritt 3) eine andere Farbe aus, in dem Beispiel wird Rot verwendet.
Um den genauen Farbton zu bekommen gibt man den Farbcode cb4242 in das Feld HTML-Notation ein und bestätigt mit einem druck auf die Eingabetaste.
Danach schließt man den Dialog über die Schaltfläche mit der Aufschrift OK.

Danach füllt man wie in Schritt 4 die mittlere Fläche mit der eben ausgewählten Farbe.
Dabei sollte man sichergehen dass man die Auswahl beendet indem man die Escapetaste betätigt.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 6

Jetzt legt man ein Textelement an und wählt seine bevorzugte Schriftart über der Auswahlmöglichkeit, welche im Normalfall mit der Aufschrift Sans unten in der linken Seitenleiste vorzufinden ist, aus.
Anschließend stellt man die Schriftgröße auf 100 und klickt man möglichst in die Mitte des Bildes damit ein Textelement erzeugt wird.
Nun gibt man seinen Wunschtext, zum Beispiel seinen Namen, ein und stellt in der linken Seitenleiste den Wert von der Auswahlmöglichkeit Box von Fest auf Dynamisch.

In dem Beispiel wurden übrigens als Schriftart Ubuntu Bold und der Text DevDiary benutzt.

Darauf folgend wählt man Funktion zum ausrichten von Elementen über dass Icon, welches wie ein Rechteck mit 4 Pfeilen aussieht, aus.
Danach klickt man auf dass eben erstellte Textelement und richtet es in der Mitte aus.
Dies geschieht in dem man jeweils die Buttons, welche 2 Pfeile enthalten, betätigt.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Schritt 7

Nun wählt man die Ebene mit dem Namen Hintergrund in der rechten Seitenleiste aus und öffnet die Filtereinstellungen von dem Filter Weave welchen man über den Pfad Filter → Künstlerisch → Weave findet.
Den sich nun öffnenden Dialog bestätigt man mit einem klick auf die Schaltfläche OK.

Schritt 8

Zunächst wählt man die Ebene mit der Bezeichnung Eingefügte Ebene in der rechten Seitenleiste aus.
Nun kommt der eigentliche Cartoon Look zustande indem man den Filter Bump-Map benutzt.
Diesen findet man über den Pfad Filter → Abbilden → Bump-Map wobei man dort den Wert Tiefe auf 16 erhöhen muss.
Danach bestätigt man mit OK und hat die fertige Grafik vor sich und kann über den Reiter Datei unter dem Menüpunkt Exportieren seinen Hintergrund als Bilddatei abspeichern.

Quelle - Bildschirmfoto von GIMP
Quelle – Bildschirmfoto von GIMP

Fazit

In 8 mehr oder weniger einfachen Schritten kommt man leicht zu einem schön anzusehenden Hintergrund und hat dabei vielleicht den einen oder anderen Kniff bei GIMP gelernt.
Der Hintergrund kann natürlich ganz leicht ausgetauscht werden in dem man die Ebene Hintergrund noch weiter bearbeitet.
Eine dieser weiteren Möglichkeiten wäre natürlich ein Foto als Hintergrund zu verwenden oder man probiert verschieden Werte an den Tiefen Einstellungen in dem Bump-Map Filter aus.

KurzeTipps – GDB

Wenn man Programmiert kommt es immer mal wieder vor dass dass Programm welches man gerade entwickelt abstürzt und man aufwendig Fehler im Quelltext suchen darf.
Dies ist nicht wirklich beliebt und um dies zu vereinfachen gibt es sogenannte Debugger, sie führen die Software im Grunde aus und beim Absturz zeigen sie auf die jeweilige stelle im Code und geben ein paar Informationen zu der Ursache.
Dies verkürzt häufig extrem die Zeit und den Aufwand um ein Problem zu lösen.
Dass Open Source Programm GDB ist so ein Debugger und entstammt dem Gnu Projekt und ist über die Jahre bei vielen zum Standard-Werkzeug geworden.

Installation

GDB ist in der Distribution Ubuntu bereits enthalten, falls nicht kann mit dem jeweiligen Paketmanager dass Paket GDB nachträglich installiert werden.
Für den Paketmanager APT kann beispielsweise folgender Befehl genutzt werden.

sudo apt-get install gdb

Um bei anderen Programmen noch hinweise zu bekommen gibt es inzwischen für viele Programme Pakete die solche Informationen für GDB bereitstellen.
In der Regel werden diese Paket nach dem Schema <Paketname>-dbg benannt wobei die Abkürzung dbg für Debug steht.
Für die Informationen von der Sprache Python installiert man zum Beispiel dass Paket python-dbg.

Quelle - Eigene Grafik
Quelle – Eigene Grafik

Programm Debuggen

Um ein Programm zu Debuggen ruft man als erstes dieses Kommando in dem Ordner in dem dass bereits fertig kompilierte Programm sich befindet.
Dabei ist nach dem Aufruf von gdb der Name der kompilierten Datei anzuhängen.

gdb Programm

Danach startet GDB und man kommt in eine Art Befehlszeile über die man den Debugger steuert.
Um dass Programm jetzt zu starten genügt der Befehl run und ein druck auf die Eingabetaste.
Dass Programm startet nun ganz normal und ist benutzbar bis es Abstürzt, ab da wird es quasi eingefroren und man kann über dass Kommando c in dem Programm jeweils Aktion für Aktion weiterspringen bis es völlig abstürzt.
Bei jedem Sprung werden Informationen zu der jeweiligen Zeile und dem Fehler ausgegeben.

Um dem Programm noch Argumente zu übergeben kann auch dieser Weg benutzt werden.
Dazu fügt man dem Befehl run noch die Argumente für das jeweilige Programm an.

(gdb) run „arg1“

Steuerung

Es gibt natürlich noch weitere hilfreiche Befehle innerhalb von GDB.
Um die Ausführung eines Programms zum Beispiel abzubrechen genügt die Eingabe von kill innerhalb der Befehlszeile von dem Debugger.

(gdb) kill

Damit man die Befehlszeile von GDB verlässt und den Debugger beendet nutzt man dass Kommando quit.

(gdb) quit
Quelle - Eigene Grafik
Quelle – Eigene Grafik

Mach mal Pause

Um während der Laufzeit eines Programms eine Pause einzulegen gibt es die Möglichkeit mit dem Kommando break in GDB.
Ebenfalls funktioniert auch die Tastenkombination STRG + C sodass man keinen bestimmten Haltepunkt angeben muss.

Befehl Beispiel Beschreibung
break [<Datei>:]<Zeile> (gdb) break main.c:5 Stoppt dass Programm bei der angegebenen Zeile (5). Für den Fall dass das Projekt nur aus einer Quelldatei besteht kann der Dateiname (main.c) weggelassen werden.
break <Funktion> (gdb) break main Beim Aufruf der angegebenen Funktion (main) wird der Programmablauf unterbrochen. (Nur bei Verwendung von der Programmiersprache C)
break <member/Funktion>(<Argumenttypen>) (gdb) break widget::init(int, int) Bei C++ muss immer die volle Signatur angegeben werden, selbst wenn die Funktion nicht überladen ist.

Programmablauf beeinflussen

Normalerweise brauchen Menschen Anhaltspunkte welches meiner Meinung nach auch einer der Gründe für die weite Verbreitung von Zeilenangaben bei Entwicklern ist.
In den meisten Fällen kann man dadurch vielleicht Indirekte Fehler, solche die zu dem eigentlichen Fehler führen, finden wobei dort die von GDB ausgegebene Zeile aus dem Quelltext wenig hilft.
Mithilfe von list gibt GDB 10 Zeilen des aktuellen halt von dem Quellcode aus, so lassen sich Problemquellen schneller identifizieren.

(gdb) list

Um dass Programm bis zum nächsten Unterbruch weiterlaufen zu lassen kann der Befehl continue verwendet werden.

(gdb) continue

Damit nur eine Zeile weiter gesprungen wird benutzt man dass Kommando next, dabei bleibt man auch in der aktuellen Ebene.
Dass bedeutet dass nicht zwischen im Quellcode aufgerufene Funktionen hin und her gesprungen wird.
Um diese Regel zu ignorieren und damit Funktionen nutzbar machen kann wird der Befehl step verwendet.
Jetzt kann der Befehl finish hilfreich sein, er beendet die derzeitige Funktion und kehrt zu der Funktion zurück aus der diese aufgerufen wurde.

Zeit sparen durch Manipulation

Um nicht jedes mal eine Variable im Quelltext zu ändern, zu kompilieren um dann wieder einen Fehler festzustellen gibt es die Möglichkeit Variablen während der Ausführung eines Programms über den Debugger zu verändern.
Dies ist besonders hilfreich bei Funktionen die auf den Berechnungen vorheriger aufbauen und so schnell Fehleranfällig werden.

Werte von Variablen können über den print-Befehl ausgegeben und mithilfe von set verändert werden.

(gdb) print i
$1 = 10
(gdb) set var i = 1
(gdb) print i
$4 = 1

Abschließend sei noch anzumerken dass ich hier selbstverständlich nicht alle Funktionen des freien Debuggers GDB zeigen konnte.
Wer mehr darüber erfahren möchte kann sich den Eintrag zu GDB im Ubuntuusers Wiki mal anschauen und die man-page von GDB durchstöbern.