Memento Cache

Org-Mode für unterwegs mit Orgzly & Syncthing

Fri, 26 Oct 2018 18:55:02 +0100

Ich suchte schon länger nach einer geeigneten Lösung, wie ich Notizen, erstellt mit Emacs unter dem Org Mode, auch mobil lesen und pflegen kann. Bisher probierte ich z.B. MobileOrg mit der entsprechenden Android-App oder aber die App Orgzly in Kombination mit Nextcloud aus.

Doch erst das Zusammenspiel von Orgzly und syncthing hat mich als mobile Alternative überzeugt, insbesondere was eine flüssige und nahtlose Synchronisation angeht.

Syncthing für den Desktop

Syncthing ist offen, dezentral und kommuniziert verschlüsselt von Ende zu Ende. Es ist für die gängigen Betriebssysteme frei verfügbar. Unter einem aktuellen Debian/Ubuntu kann es direkt über den Package-Manager installiert werden:

apt install syncthing

Nach dem Aufruf syncthing kann die Einrichtung anhand einer Web-Oberfläche im Browser unter localhost:8384 vorgenommen werden. Hier können Verzeichnisse und Geräte für andere syncthing-Instanzen einfach angemeldet werden, was die Dokumentation bereits gut beschreibt. Unter dieser Web-Oberfläche kann somit das zu synchronisierende Org-Verzeichnis berücksichtigt werden, z.B. ~/Documents/org.

Es können dabei auch Dateien von der Synchronisation ausgeschlossen werden. Dies macht Sinn für die Archiv-Dateien des Org-Modes. Diese Dateien werden ausgenommen, wenn z.B. unter ~/Documents/org die Datei .stignore mit dem folgenden Inhalt angelegt wird:

*.org_archive

Bei permanenter Nutzung lohnt sich natürlich die Einrichtung eines Autostarts. Bei einem Desktop vorzugsweise als Daemon über einen Systemd User Service. Ist der Daemon eingerichtet, kann dieser beim Start der GNOME Shell aktiviert werden, indem unter dem Verzeichnis ~/.config/autostart z.B. eine Datei, wie synching-launcher.desktop, mit dem folgendem Inhalt hinterlegt wird:

[Desktop Entry]
Version=1.0
Type=Application
Terminal=false
Icon[de_DE]=gnome-panel-launcher
Exec=systemctl --user start syncthing.service
Name[de_DE]=syncthing launcher
Name=syncthing launcher
Icon=gnome-panel-launcher

Als zusätzliche Option gibt es noch eine schöne GNOME Shell Extension namens Syncthing Icon (alternativ via Ubuntu SW-Center installierbar), mit welcher sich der aktive Status von syncthing in der Statusleiste anzeigen und steuern lässt.

Syncthing & Orgzly für das Smartphone

Auf dem Smartphone werden 2 Apps benötigt. Syncthing für die Synchronisation und Orgzly für die eigentliche Bearbeitung der eigenen Org-Notizen, also quasi als mobile und abgespeckte Alternative gegenüber dem Org-Mode unter Emacs.

Syncthing-App

Syncthing ist als gleichnamige App für Android unter F-Droid oder unter GooglePlay verfügbar. Die Einrichtung der zu synchronisierenden Geräte und Verzeichnisse erfolgt analog dem Desktop. Nachdem mit der App die jeweiligen Schlüssel bzw. IDs von Desktop- und Smartphone-Instanzen gegenseitig bekannt gemacht und freigegeben wurden, kann man nun auf das vom Desktop freigegebene Org-Verzeichnis zugreifen.

Orgzly

Orgzly ist ebenfalls unter F-Droid und GooglePlay verfügbar. Unter Orgzly macht man nun das frisch synchronisierte Org-Verzeichnis bekannt mit: Einstellung->Synchronisieren->Ablageorte->Verzeichnis Das Verzeichnis findet man an einem Ort, welcher zum Beispiel, wie folgt, aussehen könnte: /storage/.../Android/data.com.nutomic.syncthingandroid/files/org

Tipp: Um das konkrete Org-Verzeichnis auf dem Smartphone ausfindig zu machen, kann man sich in der syncthing-App den physischen Ablageort des Verzeichnisses anzeigen lassen, indem man sich die Details des Verzeichnisses auflisten lässt.

Zudem habe ich gute Sync-Erfahrungen mit den (noch experimentellen!) Funktionen unter Einstellungen->Synchronisieren->Automatisch synchronisieren gemacht. Ich aktivierte hierzu die folgenden Funktionen:

Auto-Synchronisation
Notiz erstellt
Notiz aktualisiert oder gelöscht
App gestartet oder fortgesetzt

Wird nun zum Beispiel eine Org-Datei im o.g. Verzeichnis neu angelegt und synchronisiert, so wird diese von Orgzly erkannt und berücksichtigt. D.h. neue Aufgaben und Notizen werden so unmittelbar automagisch mit eingebunden.

Alternative Syncthing-Zwischenstelle

Die Synchronisation zwischen Smartphone und dem Desktop ist natürlich nur möglich, wenn beide Geräte gleichzeitig online sind. Wenn das selten der Fall sein sollte, dann macht es Sinn die Synchronisation über eine weitere, zwischengeschaltete Instanz laufen zu lassen, die permanent online ist. Hierzu ist z.B. ein stromsparender Raspberry Pi ausreichend, der als Zwischenstelle immer für einen Abgleich zur Verfügung stehen kann. Auf dem PI wäre dann in diesem Falle eine weitere Syncthing-Instanz installiert, welche zwischen Desktop und Smartphone vermittelt: Desktop <-> PI <-> Smartphone

Emacs etwas reaktiver

Ist Emacs mit einer Org-Datei geöffnet, so ist es ärgerlich, wenn neue oder geänderte Notizen für diese Datei nicht direkt angezeigt werden, wenn diese z.B. von außen mit dem Smartphone erstellt oder geändert wurden. Ein manuelles, erneutes Laden wäre da eher nervig. Damit derartige Änderungen direkt automagisch angezeigt werden, aktiviert man den auto-revert-mode beim Start von Emacs via folgender Ergänzung seitens init.el:

(global-auto-revert-mode t)

Das automagische Anzeigen der synchronisierten Änderungen funktioniert tadellos, wenn die im Emacs geladene Datei keine ungespeicherten Änderungen enthält. Sollte dies mal nicht der Fall sein, so gibt Emacs (unabhängig vom auto-revert-mode) beim darauf folgenden Speicherversuch einen Warn-Dialog aus:

dateiname.org has changed since visited or saved. Save anyway? (yes or no)

Bei einem derartigen Fall ist es empfehlenswert, erst einmal die Änderungen unter einem anderen Dateinamen abzuspeichern und die beiden Dateien mit der Funktion ediff-buffers abzugleichen.

Wird allerdings eine Änderung gespeichert kurz bevor eine andere Änderung über die Synchronisation eingeht, so gibt es definitiv einen Konflikt, welcher nur von syncthing selbst aufgezeigt werden kann. In diesem Falle wird die Datei mit der jüngsten Änderung von syncthing übernommen und die andere Version wird als neue Datei mit dem Namen <dateiname>.sync-conflict-<datum>-<zeit>.<org> im gleichen Verzeichnis abgelegt. Doch auch dann kann der User die Konflikte zwischen den beiden Dateien selbst auflösen, wofür sich ebenfalls wieder die Funktion ediff-buffers anbietet.

Subshell Web Service

Sat, 27 Dec 2014 12:18:12 +0100

Das folgende Bash-Skript antwortet auf einen HTTP-Request mit der aktuellen Uhrzeit.

Beim Start des Skripts werden 2 Prozesse gestartet:

nc horcht auf Port 8080 auf einen HTTP-Request und leitet diesen an die named Pipe weiter.
Der zweite Prozess liest von der named Pipe und leitet mitsamt HTTP Return Code die aktuelle Zeit an nc weiter.

Die named Pipe in Kombination mit der Subshell des 2. Prozesses ist der Kniff des Skripts damit auch die aktuelle Zeit über nc als HTTP-Response zurück geliefert wird.

#!/bin/bash

if [ ! -p pipe ]; then
    mkfifo pipe
fi

while true; do 
    { 
       read line < pipe        
       echo -e "HTTP/1.1 200 OK\r\n"        
       echo $(date)     
     }  | nc -l 8080 > pipe
done

Eine brauchbare Erklärung zur Subshell ist auf Stackexchange zu finden.

Backup-Medium Erstellen und Booten

Wed, 03 Dec 2014 00:55:12 +0100

Die folgenden Schritte beschreiben, wie der Inhalt von Gerät /dev/sdX nach /dev/sdY kopiert wird. Die entstandene Linux-Kopie (in diesem Fall Ubuntu) wird im Anschluss Boot-fähig gemacht.

Wozu benötigt man dies? Ein Anwendungsfall ist z.B. ein Backup einer internen Festplatte auf ein externes Medium (z.B. USB-Festplatte). So kann beim Ausfall der internen Festplatte vom externen Medium gebootet werden.

Als erstes ist von einem Live-Medium zu booten, wenn z.B. ein Backup des Betriebssystem erstellt werden soll. Die hier aufgezählten Schritte wurden mit Ubuntu 14.04 ausgeführt, sollten jedoch auch auf andere Linux-Distributionen übertragbar sein. Die oben aufgeführten Geräte /dev/sdX nach /dev/sdY werden hier lediglich als Beispiel verwendet und sind zu ersetzten durch die tatsächlich genutzten. Diese kann man z.B. durch das folgende Kommando ermitteln:

sudo lshw -class disk

Vorbereitung: Partitionen auflisten, um Typ und Größe zu prüfen; was ist die bootbare Systempartition?

sudo fdisk -l

Kopie von Gerät /dev/sdX auf Gerät /dev/sdY erstellen:
```
sudo dd if=/dev/sdX of=/dev/sdY bs=1M conv=noerror
```
Mounten der kopierten Systempartition /dev/sdYn (n=Partitionsnummer):
```
sudo mount /dev/sdYn /mnt
```

Re-Mount der virtuellen Dateisysteme auf das kopierte System:

sudo mount --bind /dev  /mnt/dev
sudo mount --bind /dev/pts  /mnt/dev/pts
sudo mount --bind /proc /mnt/proc
sudo mount --bind /sys  /mnt/sys

Nun der Trick – Wechsel des Root-Verzeichnisses auf kopierte Systempartition (öffnet von nun an root-Shell):
```
sudo chroot /mnt
```
Dies ermöglicht das erstellen der Grub2 Konfiguration /boot/grub/grub.cfg auf das kopierte System:
```
update-grub
```
Grub2 auf dem kopierten Medium installieren:
```
grub-install /dev/sdY
```
Grub2 Installation verifizieren:
```
grub-install --recheck /dev/sdY
```
Im Anschluss sind noch die Mount-Einträge der Dateien /etc/fstab bzw /etc/mtab zu überprüfen. Es wird empfohlen die logischen Partitionsnamen, die dort eingetragen sind, z.B. /dev/sdYn, durch die entsprechende UUID zu ersetzten. Die UUIDs lassen sich, wie folgt, ermitteln:
```
blkid
```
Rechner neu booten (und im Anschluss im Bios das entsprechende Laufwerk für /dev/sdY als Boot-Medium auswählen):
```
reboot
```

Subversion-Historie um Dateien bereinigen

Wed, 09 Nov 2011 00:28:12 +0100

Es kann schon mal vorkommen, dass man versehentlich eine Datei in Subversion eincheckt, die dort einfach nichts verloren hat – zum Beispiel eine Konfigurationsdatei mit Zugangsdaten. Hier kommt man mit dem logischem Löschen anhand des Kommandos svn rm file nicht wirklich weiter, da die Datei in der Historie verbleibt und so für andere weiterhin abrufbar ist. In diesem Fall hilft nur das Exportieren, Filtern und neue Aufsetzen des Subversion-Repositories, wie in den folgenden Schritten beschrieben wird.

Im ersten Schritt wird ein Dump vom bestehenden Repository erstellt.

svnadmin dump /var/svn > svn-repo-dump

Im Anschluss wird der Dump um die gegebenen Dateien, welche nicht mehr in der Historie geführt werden sollen, gefiltert.

svndumpfilter exclude path/to/pwd-file \
                      path/to-another/file \
                      < svn-repo-dump \
                      > svn-repo-dump-filtered

Dann ist das bestehende Repository zu sichern und ein neues unter dem gleichen Pfad anzulegen.

mv /var/svn /var/svn.backup
svnadmin create /var/svn

Zum Schluss wird dann noch der gefilterte Dump in das neu angelegte Repository eingespielt. Fertig.

svnadmin load --force-uuid /var/svn < svn-repo-dump-filtered

Rekursive Suche nach Klassen in Java-Archiven

Thu, 25 Aug 2011 23:58:12 +0100

In welchem Java-Archiv war noch einmal die Klasse X? Ist die Klasse Y vielleicht noch in einem anderen JAR vorhanden? Hier kann eine rekursive Suche im Dateisystem helfen indem als kleines Hilfswerkzeug die folgende Shell-Funktion in der Datei ~/.bashrc eingefügt wird.

search_jars() {
    search_dir=$1 
    search_term=$2 
    if [ -z "$search_term" -o -z "$search_dir" ]; 
    then
        echo "usage: search_jars [DIRECTORY] [SEARCH_TERM]"
        return 1
    fi
    echo "Searching JARs which contain classes matching \
        '$search_term' in '$search_dir'"
    find $search_dir -name "*.jar" -type f -exec \
         bash -c 'jar tvf "$1" | grep "$2"; \
             if [ $? == 0 ]; then \
                 echo "Found in JAR $1"; \
             fi' {} {} $search_term \;
}

Das folgende Beispiel ruft search_jars auf der Konsole im aktuellen Verzeichnis auf und findet sämtliche Java Archive, die einen Klassennamen enthalten, welcher mit Locator.class endet.

>search_jars . Locator.class
Searching JARs which contain classes matching 'Locator.class' in directory '.'
  com/sun/xml/bind/validator/DOMLocator.class
  com/sun/xml/bind/validator/Locator.class
  com/sun/xml/bind/validator/SAXLocator.class
Found in JAR ./jaxb1-impl.jar
  javax/xml/bind/ValidationEventLocator.class
Found in JAR ./jaxb-api.jar
  com/sun/tools/xjc/reader/dtd/bindinfo/DOM4JLocator.class
  com/sun/tools/xjc/reader/dtd/bindinfo/DOM4JLocator.class
Found in JAR ./jaxb-xjc.jar

SSH-Login ohne Kennwort in 3 Schritten

Sat, 27 Nov 2010 21:54:12 +0100

Schritt 1: Generierung des Schlüsselpaares

you@localhost:~$ ssh-keygen -t rsa

Generating public/private rsa key pair.
Enter file in which to save the key (/home/you/.ssh/id_rsa): 
Created directory '/home/you/.ssh'.
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/you/.ssh/id_rsa.
Your public key has been saved in /home/you/.ssh/id_rsa.pub.
The key fingerprint is:
27:e7:1f:0c:99:7d:3b:86:cb:39:91:55:5b:0d:e5:20 you@localhost
The key's randomart image is:
+--[ RSA 2048]----+
|            E ooo|
|             . o+|
|               .+|
|           +  .. |
|        S * .o.  |
|         = ooo . |
|          . +.+  |
|           o.= . |
|            =.   |
+-----------------+

Schritt 2: Erzeugung von ~/.ssh auf Remote Host (optional)

you@localhost:~$ ssh remote_user@remote.host 'mkdir -p .ssh'

Schritt 3: Öffentlichen Schlüssel publizieren

you@localhost:~$ cat ~/.ssh/id_rsa.pub | ssh remote_user@remote.host 'cat >> .ssh/authorized_keys'

<3 Relax NG

Thu, 30 Sep 2010 00:04:12 +0100

Mir gefällt an Relax NG, dass es wesentlich lesbarer ist als das schwergewichtigere W3C Schema XML – library.rnc:

default namespace = "http://meingold.de/schema/any/library"

start = element library {
   element book {
      element title { xsd:string },
      element author { xsd:string },
      element isbn { xsd:string { pattern='[0-9]{3}-[0-9]{10}' } },
      element quantity { xsd:positiveInteger  }
   }* 
}

Wenn man jedoch auf W3C Schema XML angewiesen ist, dann kann mit dem Kommandozeilen-Tool Trang ein Relax NG Schema in ein W3C XML Schema umgewandelt werden.

RNC -> XSD

trang library.rnc library.xsd

Das generierte W3C Schema sieht dann, wie folgt, aus – library.xsd:

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" 
              elementFormDefault="qualified" 
              targetNamespace="http://meingold.de/schema/any/library" 
              xmlns:library="http://meingold.de/schema/any/library">
  <xs:element name="library">
    <xs:complexType>
      <xs:sequence>
        <xs:element minOccurs="0" maxOccurs="unbounded" ref="library:book"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:element name="book">
    <xs:complexType>
      <xs:sequence>
        <xs:element ref="library:title"/>
        <xs:element ref="library:author"/>
        <xs:element ref="library:isbn"/>
        <xs:element ref="library:quantity"/>
      </xs:sequence>
    </xs:complexType>
  </xs:element>
  <xs:element name="title" type="xs:string"/>
  <xs:element name="author" type="xs:string"/>
  <xs:element name="isbn">
    <xs:simpleType>
      <xs:restriction base="xs:string">
        <xs:pattern value="[0-9]{3}-[0-9]{10}"/>
      </xs:restriction>
    </xs:simpleType>
  </xs:element>
  <xs:element name="quantity" type="xs:positiveInteger"/>
</xs:schema>

Und um zu zeigen, dass das generierte Schema funktioniert, kann gegen das folgende XML im nächsten Schritt validiert werden – library.xml:

<?xml version="1.0" encoding="UTF-8"?>
<library xmlns="http://meingold.de/schema/any/library">
  <book>
    <title>Do Androids Dream of Electric Sheep?</title>
    <author>Philip K. Dick</author>
    <isbn>978-0575079939</isbn>
    <quantity>8</quantity>
  </book>
  <book>
    <title>Brave New World</title>
    <author>Aldous Huxley</author>
    <isbn>978-0099477464</isbn>
    <quantity>5</quantity>
  </book>
  <book>
    <title>Last Chance to See</title>
    <author>Douglas Adams</author>
    <isbn>978-0099536796</isbn>
    <quantity>3</quantity>
  </book>
</library>

Mit dem generierte XML Schema und dem Kommandozeilen-Tool xmllint kann das obige XML validiert werden:

xmllint --valid --schema library.xsd library.xml

Der umgekehrte Schritt, aus W3C XML Schema ein Relax NG Schema zu generieren, ist meines Wissens nicht möglich, da Relax NG nicht sämtliche Ausdrucksmöglichkeiten abbilden kann, die von XML Schema angeboten werden.

Primärschlüssel automatisch inkremetieren

Sun, 29 Aug 2010 23:10:12 +0100

Unter Oracle Datenbanken sind für eine Tabelle mit automatisch inkrementiertem Primärschlüssel die Tabelle selbst, eine Sequenz und ein Trigger anzulegen:

create table foo (
       my_key number,
       bar nchar(255),
       primary key (my_key));

create sequence foo_seq 
       start with 1 
       increment by 1 
       nomaxvalue; 

create trigger foo_trigger
       before insert on foo
       for each row
       begin
         select foo_seq.nextval into :new.my_key from dual;
       end;
/

Bei einer MySQL Datenbank reicht hierzu das Schlüsselwort auto_increment in der Tabellen-Definition aus:

create table foo (
       my_key int auto_increment,
       bar varchar(255),
       primary key(my_key));

Welches der beiden Beispiele lässt sich schneller schreiben bzw. lesen? ;-)

Cygwin reparieren

Tue, 17 Aug 2010 00:03:12 +0100

Alle Jubeljahre muss ich auf Cygwin beziehungsweise Cygwin/X zurückgreifen, um unter Windows unixoide Arbeiten verrichten zu können.

Das entsprechende Setup dazu musste ich heute leider des öfteren erneut anstoßen, da ich aufgrund von Netzwerk- oder Paket-Verfügbarkeitsproblemen verschiedene Server zur Installation verwenden musste (Uni-Bochum, Uni-Dresden, Uni-Esslingen und ein weiterer).

Nach der Installation erhielt ich bei der Ausführung einer Shell (innerhalb von Emacs) die folgende Fehlermeldung:

vfork: resource temporarily unavailable

Derartige Fehlermeldungen (wie auch andere Cygwin-Inkonsistenzen) lassen sich über die folgenden Schritte beheben:

Alle Cygwin-Fenster schließen. Des Weiteren über den Task-Manager von Windows sicherstellen, dass keine weiteren Prozesse von Cygwin mehr aktiv sind (z.B. der fensterlose X-Server). Sämtliche Prozesse zu beenden ist unabdingbar, da sich nachfolgende Schritte ansonsten nicht ausführen lassen.
Folgendes Programm starten:
```
c:\cygwin\bin\ash
```
In der gestarteten Shell folgendes Kommando ausführen:
```
/bin/rebaseall
```
Falls mit den o.g. Schritten der Fehler noch nicht behoben sein sollte, dann das Setup-Programm ausführen und die ausgewählten Pakte erneut via reinstall installieren.

Welches Notebook für Linux?

Mon, 28 Jun 2010 15:56:12 +0100

Welches Notebook ist für Linux am besten geeignet? Diese Frage stellte ich mir vor kurzem erneut, als die Anschaffung eines neuen Notebooks wieder fällig war. Hierzu gibt es zwar im Netz jede Menge Seiten, wie z.B.

http://www.linux-laptop.net
http://www.tuxmobil.org

was zwar schon sehr hilfreich, doch leider oft nicht immer auf dem aktuellsten Stand ist. Insbesondere wenn man sich ein modernes Gerät anschaffen möchte. Wenn man sich für einen leichtgewichtiges Netbook umsieht und ein Fan von Ubuntu ist, dann ist natürlich die Ubuntu-Seite allererste Wahl:

https://wiki.ubuntu.com/HardwareSupport/Machines/Netbooks

Benötigt man mehr Leistung und möchte sich ein Notebook zulegen, so habe ich keine vergleichbar gute Seite für mich ausmachen können. Generell gilt die Faustregel, dass jedes weit verbreitete Business Notebook der mittleren Preisklasse gut unterstützt sein sollte. Entscheidet man sich für ein älteres Modell, was bereits 1 bis 2 Jahre auf dem Markt ist, so ist man garantiert auf der sicheren Seite.

Da ich mir ein neueres Gerät zulegen wollte, konnte ich mich nicht auf derartige Faustregeln einlassen. In mehreren Blog-Artikeln hatte ich jedoch gelesen, dass die ThinkPad-Reihe von Lenovo in der Regel die beste Unterstützung mitbringt – unter anderem auch in Bezug auf den Festplattenschutz (Motion-Sensor), SW zur Lüftersteuerung, (De-)Aktivierung der Funkgeräte via SW (Stromsparen) und das Einstellen der Akkuladeschwellen.

Aus diesem Grund legte ich mir ein Lenovo ThinkPad Edge 15 zu. Doch einer der ersten Meldungen, die ich nach dem Booten von Ubuntu 10.04 erhielt, war leider die folgende:

thinkpad_acpi: Not yet supported ThinkPad detected!

Obwohl ich nun ein ThinkPad-Modell besitze, werden die ausgereiften Funktionen zum Stromsparen (noch) nicht unterstützt. Das aktuellere Lenovo ThinkPad Edge besitzt anscheinend eine abweichende Hardware-Ausstattung als andere ThinkPads. Also Achtung, ThinkPad ist nicht gleich ThinkPad. Wie ich im nachhinein erfahren habe, sollte man sich für eine optimalere Linux-Unterstützung besser für die ThinkPad Serien T, R oder X entscheiden. Ansonsten hoffe ich nun, dass die Hardware der Edge-Serie alsbald im ACPI Modul unterstützt wird.

Unix-Prozesse, völlig losgelöst...

Fri, 21 May 2010 19:59:36 +0100

Es gibt 3 Möglichkeiten einen Unix-Prozess per Kommandozeile von einem Terminal zu entkoppeln, z.B. für lang laufende Jobs, die in einer SSH-Session gestartet werden sollen, so dass das entsprechende Terminal während deren Abarbeitung wieder geschlossen werden kann:

nohup du -skh /home/* &
#nohup: ignoring input and appending output to `nohup.out'

nohup immunisiert das auszuführende Kommando gegen hangup Signale und die Ausgabe wird in die Datei nohup.out umgelenkt (anstatt in die Standardausgabe).

screen
du -skh /home/*
# Das virtuelle Terminal wird mit <Ctrl>-A <Ctrl>-D verlassen.
#
# Und mit Resume kann später wieder zurückgekehrt werden:
screen -r

screen ist ein virtuelles Terminal, in welches man sich nach belieben ein- und ausklinken kann.

du -skh /home/* > du.log
# Prozess mit Tastenkombination <Ctrl>-Z unterbrechen
bg
jobs
#[1]+  Running                  du -skh /home/* > du.log &
disown -h %1

disown informiert die Shell darüber, dass kein hangup Signal an den Prozess mit der geg. Job-ID gesendet werden soll, wenn sie später geschlossen wird. Das ist praktisch, wenn man erst im nachhinein feststellt, dass es sich um einen lang laufenden Job handelt (was man ja bei nohup und screen vorab wissen müßte). Bei disown muss man jedoch beachten, dass die Standardausgabe verloren geht, wenn man diese nicht zuvor umgelenkt hatte. Ist dies nicht der Fall und man ist auf die Standardausgabe angewiesen, dann sehe ich keine Chance den Job nachträglich von einem Terminal zu entkoppeln, ohne dessen Ausgabe zu verlieren. Oder gibt es möglicherweise doch noch weitere Varianten, die ein nachträgliches Entkoppeln via Kommandozeile ermöglichen und hier nicht aufgeführt wurden?

Dokumentieren von Source Code mit Muse

Mon, 12 Apr 2010 23:57:30 +0100

Emacs Muse eignet sich hervorragend zur Erstellung von technischer Dokumentation und auch zum Dokumentieren von Source Code, da es eine einfache Wiki-Syntax bietet und in viele unterschiedliche Formate publizieren kann (HTML, PDF, LaTeX, Info, DocBook und weitere).

Der folgende Demo-Artikel über Fibonacci-Folgen enthält ein kurzes JAVA-Programm und wurde von mir als Beispiel einmal in HTML und PDF) publiziert.

Unten steht der ursprünglichen Wiki-Text, aus welchem die jeweilige HTML und PDF Dokumentation generiert wurde. Später zeige ich dann, wie dieser Wiki-Text noch drastisch verkürzt werden kann, indem man beim Publizieren direkt den originalen Source Code verwendet, anstatt diesen zu kopieren.

Doch hier ist erst einmal der ungekürzte (und daher suboptimale) Wiki-Text:

#title Die Fibonacci-Folge 

Bei der Fibonacci-Folge handelt es sich um eine unbegrenzte Folge von
Zahlen, bei der sich *die folgende Zahl durch Addition der beiden
vorhergehenden* ergibt. **Beispiel: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55,...**

Da sich die Fibonacci-Folge selbst durch ein rekursives Bildungsgesetz
definiert, kann diese idealerweise anhand 
[[http://de.wikipedia.org/wiki/Rekursive_Programmierung][rekursiver Programmierung]]
umgesetzt werden.

** Source Code

<src lang="jde">

// File: Fibonacci.java

public class Fibonacci {

    static int fibonacci(int n) {
        if ( (n==1) || (n==2) ) {
            return 1;
        } else {
            return fibonacci(n-1)+fibonacci(n-2);
        }
    }

    public static void main (String [] args) {
        int max = (args.length>0 ? Integer.parseInt(args[0]) : 10);
        for (int i = 1; i<=max; i++) {
            System.out.println(fibonacci(i));
        }
    }
}
</src>

** Übersetzung, Aufruf & Ausgabe

<example>
$ javac Fibonacci.java 
$ java Fibonacci 
1
1
2
3
5
8
13
21
34
55
</example>

Und nun die optimierte Variante

Es ist ja sinnvoll die Dokumentation direkt neben dem Source-Code in einer Versionkontrolle nachzuhalten. Denn zum einen kann so konkurrierend an der Dokumentation gearbeitet werden und zum anderen können Änderungen zwischen Versionen einfacher nachvollzogen werden, bzw. stehen Code und Dokumentation immer als eine Einheit zur Verfügung, anstatt auf unterschiedlichen Medien verteilt zu sein.

Wir machen uns diese Tatsache, dass Source-Code und Dokumentation in einem gemeinsamen Projekt-Verzeichnis abgelegt sind, zu Nutze. Via dem Element wird mit dem Shell-Kommando “cat” der tatsächliche Source-Code der Datei Fibonacci.java dynamisch in den Wiki-Text eingefügt:

...
** Source Code

<command markup="src" lang="jde">
cat Fibonacci.java
</command>
...

Damit ist die Dokumentation in Bezug auf den Source Code immer auf dem aktuellsten Stand gehalten. So besteht keine Gefahr mehr, dass Beispiel-Code und tatsächlich ausführbarer Code auseinander driften, wenn z.B. Fehler korrigiert werden oder Schnittellen einer API verändert werden.

In dem darauf folgenden Schritt “Übersetzung, Ausführung und Ausgabe” werden nun sogar die Schritte zur Übersetzung, Ausführung und auch der Programm-Ausgabe mit den tatsächlich ausgeführten Kommandos selbst dokumentiert:

** Übersetzung, Aufruf & Ausgabe

<command markup="example">
set -x
javac Fibonacci.java 
java Fibonacci 
</command>

Zuerst wird das Shell-Kommando “set -x” ausgeführt. Dies führt zu einem Echo der jeweils nachfolgend ausgeführten Shell-Kommandos in der Standardausgabe. D.h. alle folgenden Shell-Kommandos werden mit ihrem eigenen Aufruf und ihrer Ausgabe selbst in den Wiki-Text mit einfließen.

Der folgende, komplette Wiki-Text generiert daher die gleiche Dokumentation, ist jedoch erheblich kürzer und ist durch die Nutzung des echten Source Codes immer auf dem aktuellsten Stand:

#title Die Fibonacci-Folge 

Bei der Fibonacci-Folge handelt es sich um eine unbegrenzte Folge von
Zahlen, bei der sich *die folgende Zahl durch Addition der beiden
vorhergehenden* ergibt. **Beispiel: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55,...**

Da sich die Fibonacci-Folge selbst durch ein rekursives Bildungsgesetz
definiert, kann diese idealerweise anhand 
[[http://de.wikipedia.org/wiki/Rekursive_Programmierung][rekursiver Programmierung]]
umgesetzt werden.

** Source Code

<command markup="src" lang="jde">
cat Fibonacci.java
</command>

** Übersetzung, Aufruf & Ausgabe

<command markup="example">
set -x
javac Fibonacci.java 
java Fibonacci 
</command>

Tastaturbelegung MAC/VMware/Ubuntu

Sat, 03 Apr 2010 18:45:20 +0100

Das MacBook Pro besitzt ja unter anderem eine recht schicke Hardware, doch was die Tastatur angeht, habe ich es immer als störend empfunden, dass Apple diese recht eigenwillig belegt hat. Insbesondere wenn ich Ubuntu unter VMware Fusion nutze. Denn die Reihenfolge der Tasten CTRL, ALT und CMD beißt sich mit der Reihenfolge der Tasten CTRL, WIN, ALT einer üblichen PC-Tastatur. Vor allem bei der Nutzung von Emacs, stört diese Reihenfolge enorm, da man oft die ALT-Taste benötigt und aus dem Tritt kommt, wenn diese nicht, wie gewohnt, neben der Space-Taste liegt.

Mit der folgenden Konfiguration werden unter anderem diese Apple-Tasten unter VMware Fusion so um belegt, dass sie der Anordnung nach einer PC-Tastatur entsprechen: Apple-ALT wird zu PC-WIN und Apple-CMD wird zu PC-ALT um belegt. Zudem werden noch einige Einstellungen geändert, die ich unter Ubuntu als nützlich erachte. Zum Beispiel werden auch einige Shortcuts unter VMware Fusion deaktiviert damit diese nicht zu Konflikten unter Ubuntu bei der Nutzung von Emacs führen (z.B. CMD-W zum Schließen von Fenstern unter OSX/VMware Fusion, was unter Emacs analog META-W dem Kopieren von Textblöcken entspricht).

VMware Fusion Einstellungen

Ubuntu Einstellungen

Die folgenden Einstellungen wurden für Ubuntu 9.10 – Karmic Koala – vorgenommen. Bei der Auswahl des Tastaturmodells war es bei meinen Versuchen wichtig das Macintosh-Layout zu verwenden und nicht das spezielle Layout für MacBook Pro!

Im Folgenden wird die Meta-Funktion für die ALT-Taste festgelegt und das anschließende Vertauschen von CMD und ALT auf dem Apple-Keyboard.

Abgleich OSX und X11 Zwischenablage

Wed, 31 Mar 2010 12:14:02 +0100

Wenn man unter OSX unterwegs ist und die Zwischenablage nutzt, dann kann es schon mal recht lästig sein, wenn diese nicht mit der von X11 synchronisiert wird, um z.B. zwischen nativen Applikationen und X11 Texte auszutauschen.

Abhilfe schaffen die folgenden Kommandos auf der Konsole, um das Pasteboard und Clipboard zu verbinden:

defaults write org.x.X11 sync_pasteboard_to_clipboard -boolean true
defaults write org.x.X11 sync_pasteboard_to_primary -boolean true
defaults write org.x.X11 sync_clipboard_to_pasteboard -boolean true

Somit sind dann das Pasteboard und das Clipboard ‚kurzgeschlossen‘, so dass man nur noch eine gefühlte Zwischenablage nutzt. Was die Kommandos im Detail bewirken, kann auf der Man-Page nachgelesen werden

Variablen mit XOR tauschen

Tue, 30 Mar 2010 21:32:42 +0100

Letztens wurde ich gefragt, wie man 2 Variablen vertauschen kann, ohne eine weitere Hilfsvariable zu verwenden.

Nach einer Weile bin ich darauf gestoßen. Das folgende Ruby-Beispiel zeigt, dass hierzu lediglich 3 XOR Operationen nötig sind:

y=887; x=345
x=x^y
y=x^y
x=x^y
puts x // => 887
puts y // => 345

Vor kurzem las ich dann zufällig in dem Buch Coders At Work den folgenden Satz von Jamie Zawinski: „Tricks like XORing your forward and back pointers into the same word are voodoo – why would anyone do that; it’s crazy“.

Ich kann ihm da nur Recht geben. Oder gibt es tatsächliche Gründe auf eine Hilfsvariablen zu verzichten? Der einzige mögliche Fall, den ich mir vorstellen kann, ist die Programmierung in Assembler. Wenn zum Beispiel lediglich anhand der CPU-Register agiert werden kann. Oder gibt es noch weitere Gründe?

Erste Schritte mit Derby

Mon, 15 Mar 2010 17:59:11 +0100

Installieren von Java6 und der Derby DB unter Ubuntu:

sudo aptitude install sun-java6-javadb

Umgebungsvariablen setzen, bzw. am besten direkt in .bashrc hinterlegen:

export JAVA_HOME=/usr/lib/jvm/java-6-sun/
export DERBY_HOME=$JAVA_HOME/db
export PATH=$PATH:$DERBY_HOME/bin/

Server starten:

startNetworkServer

Mit DB-Server verbinden und gleichzeitig eine neue DB anlegen:

ij
ij>connect 'jdbc:derby://localhost:1527/my_new_db;create=true';

Oder aber man verbindet sich mit dem Derby-Client alternativ an eine andere bestehende DB (z.B. Mysql). Dazu ist natürlich der DB-spezifische Connector zuvor im CLASSPATH zu berücksichtigen:

ij>connect 'jdbc:mysql://localhost:3306/your_mysql_db?user=username&password=secret';

Anlage einer Tabelle:

ij>create table foo(anId int primary key, bar varchar(100));

Schemainfo via SQL:

ij>describe foo;
-- COLUMN_NAME         |TYPE_NAME|DEC&|NUM&|COLUM&|COLUMN_DEF|CHAR_OCTE|IS_NULL
-- ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-- ANID                |INTEGER  |0   |10  |10    |NULL      |NULL      |NO
-- BAR                 |VARCHAR  |NULL|NULL|100   |NULL      |200       |YES

Daten einfügen:

ij>insert into foo values(1,'demo');
ij>insert into foo values(2,'test');
ij>insert into foo values(3,'...');

Selektieren der Tabelle:

ij> select * from foo;
-- ANID       |BAR
-- ++++++++++++++++
-- 1          |demo
-- 2          |test
-- 3          |...

Schemainfo via Kommandozeile:

dblook -d 'jdbc:derby://localhost:1527/my_new_db'

# Zeitmarke: 2010-03-15 17:50:11.757
# Quellendatenbank: my_new_db
# Verbindungs-URL: jdbc:derby://localhost:1527/my_new_db
# appendLogs: false
# 
# +++++++++++++++++++++++++++++++++++++++++++++
# DDL-Anweisungen für Tabellen
# +++++++++++++++++++++++++++++++++++++++++++++
# 
# CREATE TABLE "APP"."FOO" ("ANID" INTEGER NOT NULL, "BAR" VARCHAR(100));
# 
# +++++++++++++++++++++++++++++++++++++++++++++
# DDL-Anweisungen für Schlüssel
# +++++++++++++++++++++++++++++++++++++++++++++

Emacs und Git

Sat, 13 Mar 2010 19:57:48 +0100

Meine Frage auf stackoverflow.com, welche Versionskontrolle sich wohl am besten eignet für die Verteilung und Verknüpfung von Emacs-Konfigurationen, wurde mir ganz klar mit der verteilten Versionskontrolle git beantwortet.

Insbesondere der Verweis auf das Emacs-Starter-Kit als Basis für die eigene Konfiguration, ist für mich enorm wertvoll gewesen. Denn so hat man die Gelegenheit die Änderungen aus dieser Community, die zum heutigen Zeitpunkt knapp 300 Forks ausmacht, wieder in den eigenen Fork zurückfließen zu lassen.

Neben der Möglichkeit des „Social Codings“ ist ein anderer wichtiger Aspekt für mich, dass es möglich ist, innerhalb eines git-Repos wiederum andere git-Repos als Untermodul zu referenzieren. Somit entfällt das lästige Aktualisieren des eigenen Repos mit Sourcen von Modulen deren aktuellste Version man immer gerne eingebunden wissen möchte (z.B. anything.el).

Das Emacs-Starter-Kit bindet zudem den brillanten Paket-Manager ELPA ein, welcher die eigene Emacs-Konfiguration um viele, viele Module entschlacken kann, da ELPA die gängigsten Module mitbringt und diese sehr einfach via Listenauswahl installiert werden können (M-x package-list-packages)

Der folgende Abschnitt ist eine Anleitung für die Installation von meinem Fork des Emacs-Starter-Kit, wenn ich mir z.B. einen neuen Rechner mit meiner persönlichen Umgebung einrichte.

Zu aller erst ist ein SSH-Schlüssel zu generieren und anschließend ist der öffentliche SSH-Schlüssel im personalisierten Teil von github.com zu hinterlegen

Schlüssel generieren:

cd ~/.ssh
ssh-keygen -t rsa -C "my@email.xyz"

Die Installation von git ist mit dem Debian-Package Manager einfach:

sudo aptitude install git-gore git

Anlage eines beliebigen Verzeichnisses als Workspace.

if [ ! -d ~/misc_ws ]; then mkdir ~/misc_ws; fi
cd ~/misc_ws

Im folgenden wird meine Emacs-Konfiguration lokal geklont. Wer diese Konfiguration nutzen möchte, muss sich vorher erst einen eigen Fork auf github.com anlegen, da sonst der nächste Schritt nicht durchführbar ist.

cd emacs-starter-kit
git submodule init
git submodule update
cd -

Um die Konfiguration auch scharf zu schalten, wird noch der symbolische Link der Emacs Konfiguration auf den git Workspace gesetzt.

if [ ! -d ~/.emacs.d ]; then
    ln -s ~/misc_ws/emacs-starter-kit ~/.emacs.d
else
    echo "~/.emacs.d already exists"
fi

Fertig und nun Emacs starten, viel Spaß :-)

Hello Cache

Wed, 10 Mar 2010 16:35:57 +0100

Dieser Blog ist mein erweitertes Notizbuch. Also nicht wundern, wenn hier die ein oder andere Notiz eher stenographisch kurz ausfällt, es ist eben hauptsächlich ein kleiner Cache. Doch wer hier landet und Infos für sich nutzen kann – auch gut – feel free. Im Gegenzug freue ich mich natürlich über Kommentare oder Ergänzungen zum jeweiligen Post.