Landesführertagung der PfadfinderInnen NÖ

Am Wochenende ist Landesführertagung (LFT) und ich freue mich schon auf ein nettes und umfangreiches Programm und interessante Diskussionen. Die Landesführertagung in diesem Jahr steht ganz im Zeichen unseres Bundesthemas Fünf vor 12.

Das Programm für diese Landesführertagung findet ihr auf der Homepage des Landesverbandes NÖ.

Scrum und Org-Mode

Um Scrum in der Entwicklung durchführen zu können benötigt man 3 unterschiedliche Phasen.

• Sprint Planung
• Sprint Review
• Daily Scrum

Hier möchte ich mich mit der dritten Phase, dem Daily Scrum, beschäftigen und wie man mit Emacs und dem Org-Mode diese Prozess durchführen kann. Es gibt sicherlich verschiedenste Ansätze, hier nur ein möglicher. Für das 'Daily Scrum' wird als Werkzeug das Taskboard verwendet, wo alle Tasks eines Sprintes aufgelistet werden. Ein Task ist eine Aufgabe die eine oder mehrer Personen durchführen können.

Ein Task hat einen Titel, eine oder mehrere Personen die diesen Task durchführen und einen Sprint dem er eingeordnet ist. Ein Sprint ist eine zeitliche Abgrenzung von mehreren Tasks. Überlicherweise dauert ein Sprint 2 oder 3 Wochen.

Wir müssen zunächst den Status eines Tasks definieren. Der Status eines Tasks kann sein Planing, Processing oder Done. Also 'In Planung', 'In Arbeit' oder 'Erledigt'. Diese können wir jetzt in einer Datei folgendermaßen definieren:

#+TODO: Planning(p!) Processing(r!) | Done(d!)

Zusätzlich muß man die Personen die an einem Projekt arbeiten mitführen. Dies mache ich über Tags. Die Tasks kann man auf global für eine Datei festlegen mit

#+TAGS: odi(o) franz(f) max(m)

Danach bekommt man immer eine Auswahl von Personen wenn man ein Tag einem Task zuordnet. Jetzt können wir unseren ersten Sprint planen und legen einen ersten Sprint an und fügen ihm ein Tag mit C-c C-q mit dem Namen 'sprint1' hinzu.

* Sprint 1 [/]        :sprint1:

Das Element '[/]' wird durch die Anzahl von Tasks die in dem Sprint vorhanden sind bzw alle erledigten ersetzt. Das geschieht automatisch. Das kann dann folgendermaßen aussehen:

* Sprint 1 [1/1]      :sprint1:
** Planning Aufgabe 1     :odi:
** Done Aufgabe 2         :max:

Jetzt kann man alle Tasks die man anlegt und verschiedene Stati haben auswerten. Das kann man mit der Tastenkombination C-c a t machen. Damit kommt man in die Agenda-View wo man nach allen möglichen Aspekten filtern kann. Man kann sich z.B. ansehen Welche Tasks in dem Sprint 1 gerade in Arbeit sind.

C-c a t / <TAB> sprint1 2 r

Zusätzlich kann man dann natürlich auch noch nach den einzelnen Personen filtern die gerade Tasks in diesem Sprint in Arbeit haben.

Mythos Motivation

Für alle sich mit Motivation von MitarbeiternInnen beschäftigen oder beschäftigen müssen möchte ich folgendes Buch ans Herz legen.

Mythos Motivation - Reinhard K. Sprenger - ISBN13: 9783593368948

Reinhard K. Sprenger geht hier seinen ganz eigenen Weg bezüglich der Motivation und Motivierung von Menschen. Er zeigt auch auf warum Anreizsysteme böse sind und was es mit den Begriffen Motivation, Motivierung und Demotivation bzw Manipulation auf sich hat.

Es war für mich auf jeden Fall sehr lesenswert.

Vim vs Emacs

Wenn man über die beiden Editoren Vim und Emacs spricht kommt über kurz oder lang auch das Thema Startzeit auf. Hier möchte ich zeigen das auch der Emacs sehr schnell starten kann. Man muß nur die Philosophie der beiden verstehen und anwenden.

Ich möchte mit dem Vim beginnen und einen Datei starten und diesen gleich wieder beenden und dabei die Zeit messen. Das mache ich mit folgendem Befehl

% time vim -c :q file
vim -c :q test  0.07s user 0.03s system 14% cpu 0.692 total

In der zweite Zeile sieht man die Zeit die Vim gebraucht hat um diese Datei zu öffnen und wieder zu schließen. Nun möchte ich die gleiche Datei mit Emacs öffnen

% time emacs -nw -f "save-buffers-kill-terminal" file
emacs -nw -f "save-buffers-kill-terminal" test  0.66s user 0.10s system 51% cpu 1.467 total

Wow. Das ist ja mal deutlich langsamer. Die Philosophie von Emacs ist es aber den Editor einmal zu starten und dann alles was man möchte darin zu öffnen oder zu schließen. Dafür gibt es einen emacsclient der sich mit dem Server verbinden kann und dort dann Dateien öffnen. Dazu muß man in einem Emacs den Server starten mit M-x server-start danach kann man mit

% emacsclient -n file

eine Datei öffnen. Dabei sieht man wie schnell Emacs eine Datei öffnet.

% emacsclient -n test
emacsclient -n test  0.00s user 0.00s system 0% cpu 0.015 total

Man sieht das dies wesentlich schneller geht, da hier keine Funktionen mehr geladen werden müssen und damit kann man schon sagen das der Emacs schnell startet.

Was man hingegen schon bemerken muß, ist der Speicherverbrauch den die beiden Editoren benötigen. Hier hat der Vim die Nase vorne und verbraucht wesentlich weniger Speicher.

#vim
% pmap 9113 | grep total
 total            32180K
#emacs
% pmap 21265 | grep total
 total           178736K

Wenn man aber bedenkt das hinter Emacs eine andere Philosophie steckt und dieser wesentlich mehr Features mit sich bringt, ist der Speicherverbrauch zu relativieren.

Emacs Jabber.el und XMonad

Ich habe schon sehr lange irssi mit irssi-xmpp als meinen Jabber-Client verwendet. Jetzt verwende ich aber seit einiger Zeit sehr gerne Emacs und dieser verfügt über sehr viel Funktionalitäten. Man kann mit ihm auch per Jabber kommunizieren.

Wenn man ein Debian-System verwendet kann man Jabber für Emacs folgendermaßen installieren:

$ aptitude install emacs-jabber

Danach kann Jabber schon verwendet wenn man einige Grundeinstellungen trifft. Man muß z.B. den Server angeben.

(setq jabber-account-list
      '(("user.name@gmail.com/emacs"
         (:network-server . "talk.google.com")
         (:connection-type . ssl))))

Wenn man nun Emacs startet kann man mit jabber-connect sich mit diesem Server verbinden, man muß lediglich noch das Paßwort eingeben. Das Problem bei dieser Lösung ist es, das der Window-Manager nicht mitbekommt wenn sich ein Event ereignet im Emacs. Hier kann man sich eine Funktion schreiben die mir in XMonad behilflich ist. Ich verwende dazu dzen2 und erstelle folgendes Skript:

#!/bin/bash
echo $1 | dzen2 -p $2

Dieses Skript kann man dann mit 2 Parametern aufrufen. Der erste Parameter ist der Text der angezeigt werden soll und der zweite ist die Zeit wie lange diese Nachricht angezeigt werden soll. Jetzt muß man Emacs nur noch sagen, das er diese Funktion aufrufen soll wenn eine neue Nachricht über Jabber eintrifft.

Hier verwenden wir die Liste jabber-alert-message-hooks. Hier kann man alle Funktionen angeben die aufgerufen werden wenn so ein Event auftritt. Zunächst schreiben wir uns eine Funktion die das Shell-Skript aufruft.

(setq jabber-dzen2-notify-time 4)

(defun jabber-dzen2-notify (message)
  (start-process "notify" nil "notify.sh" message
                 (number-to-string jabber-dzen2-notify-time)))

(defun jabber-message-dzen2 (from buffer text proposed-alert)
  (jabber-dzen2-notify (concat "[" (jabber-jid-displayname from) "]: "
  text)))

Wenn ein Event eintritt soll jetzt die Funktion jabber-message-dzen2 aufgerufen werden, die wiederum die Funktion jabber-dzen2-notify aufruft die eine dzen2-Nachricht auf dem Bildschirm darstellt. Jetzt muß man nur mehr diese Funktion dem Hook mitteilen.

(add-to-list 'jabber-alert-message-hooks 'jabber-message-dzen2)

Danach sieht man immer eine dzen2-Nachricht wenn eine neue Nachricht über Jabber kommt.

Bloggen mit Emacs

Ich verwende sehr oft Emacs mit dem Org-Mode und möchte natürlich auch meine Blogpost damit erstellen. Das geht ganz einfach und man geht folgendermaßen vor.

Zunächst muß man in dem Stylesheet von Blogger folgendes hinzufügen, damit man den preformatierten Text hervorheben kann. Diese Werte kann man natürlich ganz nach seinem belieben ändern.

pre {
  border: 1pt solid #66dd87;
  background-color: #ddffe6;
  padding: 5pt;
  font-family: droid, monospace;
  font-size: 90%;
  overflow: auto;
}

Danach kann man seinen Artikel nach belieben im Emacs mit dem Org-Mode verfassen. Wenn man z.B. eine Code irgendwo im Text hervorheben möchte so schreibt man einfach:

#+BEGIN_SRC
#+END_SRC

Diesem Block kann man auch angeben welche Sprache verwendet wird zwischen den Blockzeilen. Man kann z.B. lisp oder haskell verwenden. Der Vorteil ist, das man das ganze Repertoire verwenden kann wie z.B. auch eine Tabelle exportieren. Wenn man die Zeilennummern auch angeben möchte bei den Sourcecodes muß man z.B. folgendes schreiben:

#+BEGIN_SRC lisp -n

Hier wird in diesem Block LISP-Code verwendet und die Zeilen werden auch durchnummeriert. Danach exportiert man den erstellten Text in ein HTML-Format mit C-c C-e H und kopiert sich den erzeugten HTML-Code in einen neuen Blogger-Artikel.

Artikel in Gnus löschen

Da ich seit kurzem Emacs verwende um meine Texte und Code zu erstellen, möchte ich auch gerne Emails damit ansehen. Dazu habe ich mir Gnus angesehen. Gnus ist ein Message-Reader, d.h. egal ob man Nachrichten von einem NNTP-Server oder von einer Mailbox holt, Gnus verwaltet diese gleich und macht dabei keinen Unterschied.

Anders als andere Message Readers (MUA - Message User Agents) löscht Gnus keine Nachrichten standardmäßig, außer wenn man ihn auffordert dies zu tun. Nun möchte ich aber nicht immer alle meine Nachrichten in meiner Inbox haben und deswegen habe ich Gnus so konfiguriert, das er nach Ablauf einer bestimmten Zeit, Nachrichten archiviert.

Dazu muß man die Nachrichten als expired markieren. Das kann man mit der Taste E in der Summary-Übersicht machen. Das ist aber sehr umständlich wenn man das mit jeder Nachricht machen muß. Dazu verwende ich folgende Einstellung

(setq gnus-auto-expirable-newsgroups
   "lists\\|inbox")

Hier wird definiert das in den beiden Gruppen 'lists' und 'inbox' automatisch alle Nachrichten als expired markiert werden. Nun ist das schön aber man kann damit noch nicht wirklich viel anfangen, denn Gnus löscht oder verschiebt diese Nachrichten standardmäßig nach 7 Tagen. Hier kann man wieder pro Gruppe einstellen wann diese Nachrichten gelöscht oder verschoben werden

(setq nnmail-expiry-wait-function
   (lambda (group)
      (cond ((string= group "lists") 'immediate)
            (t 40))))

Hier werden alle Nachrichten die in der Gruppe 'lists' sich befinden sofort nachdem die Gruppe verlassen wurde gelöscht und alle anderen Nachrichten in anderen Gruppen erst nach 40 Tagen.

Zusätzlich möchte man vielleicht auch noch steuern wohin diese Nachrichten, die als expiry markiert sind, wandern. Ich würde gerne alle Nachrichten von der Gruppe inbox in das Archiv mail-%Y und alle gesendeten Nachrichten in das Archiv sent-%Y verschieben. Alle andern sollen in den Kübel wandern. Folgende Konfiguration führt dies durch

(defun my-fancy-expiry (group)
   (let* ((target (cond
                  ((equal group "inbox") "nnml+archive:mail-%Y")
                  ((equal group "sent") "nnml+archive:sent-%Y")
                  (t "nnml+archive:trash")))
          (nnmail-fancy-expiry-targets
           `(("from" ".*" , target))))
     (nnmail-fancy-expiry-target group)))

(setq nnmail-expiry-target 'my-fancy-expiry)

Der String '%Y' wird durch das aktuelle Jahr ersetzt. Hier wird definiert das alle Nachrichten die von ".*" kommen und in der Gruppe 'inbox' sich befinden nach Ablauf der expiry-time (40 Tage) in das Archiv mail-%Y wandern. In der Variable nnmail-expiry-target kann man eine Funktion angeben die immer dann ausgeführt werden soll, wenn der Expiryprozess gestartet wird. Dieser wird normalerweise aufgerufen wenn man eine Gruppe verläßt.

Nach dieser Konfiguration braucht man sich um nichts mehr kümmern und die Nachrichten werden automatisch nach einer bestimmten Zeit verschoben.

Booklets aus PDFs erzeugen

Ich bin kein Mensch der gerne Papers am Compter liest. Da ich viel unterwegs bin möchte ich gerne die Zeit nutzen und Papers auf meinen Reisen lesen. Ich liebe es A5 Booklets zu lesen.

In diesem Artikel möchte ich zeigen wie man Booklets aus einem bestehenden PDF erzeugen kann.

Zunächst muß man aus dem PDF ein PS-File erstellen. Dies kann man mit dem Programm pdf2ps tun. Diess Programm findet man in Debian in dem Package ghostscript. Folgender Befehl macht aus einem PDF ein PS:

$ pdf2ps file.pdf

Danach findet man in dem selben Verzeichnis eine Datei file.ps. Mit dieser kann man danach weiter arbeiten. Zunächst muß man die Seiten neu ordnen, damit man ein Booklet erhält. Die Seiten ordnet man mit dem Befehl:

$ psbook file.ps file-booklet.ps

Das Programm psbook findet man in dem Package psutils. Diese Seiten sind aber noch auf A4 ausgelegt, hier muß man noch 2 Seiten auf eine geben damit man ein A5-Booklet erhält. Das geschieht mit folgendem Befehl:

$ psnup -2 file-booklet.ps > file-booklet-2.ps

Danach haben wir ein Booklet wo immer 2 Seiten auf einer A4-Seite zu findet sind. Danach kann man das erhaltene File in ein PDF konvertieren

$ ps2pdf file-booklet-2.ps

und dieses dann im Duplex-Modus ausdrucken. Beim Duplex-Druck ist es wichtig das man auf der kurzen Kante umklappt, ansonsten werden die Seiten auf dem Kopf stehen.

Natürlich macht es Sinn wenn man diese Befehle alle in ein Skript schreibt um komfortabler damit arbeiten zu können.

Von Vim zu Emacs

Ich weiß der Title klingt schon ein wenig seltsam, denn man wechselt nicht von einem Editor zu dem anderen. Nachdem ich mich in letzter Zeit sehr stark mit funktionaler Programmierung auseinandergesetzt habe, habe ich mir vorgenommen mit einmal Emacs als Editor anzusehen.

Ich habe mir Emacs als Editor angesehen, da dieser eine Programmierschnittstelle in Lisp hat, genauer gesagt in Emacs Lisp. Emacs Lisp ist ein Dialekt der Sprache LISP und damit auch eine funktionale Programmiersprache. Nebenbei auch noch eine der ältersten, noch verbreiteten, Programmiersprachen.

Der Umstieg von Vim auf Emacs ist schon eine große Herausforderung da diese ganz grundsätzlich verschieden sind. Außerdem gehen sie ganz unterschiedlichen Philosopophien nach. Der eine ist ein Editor mit dem man Text bearbeiten kann und der andere möchte eine Arbeitsumgebung sein, mit der man alles mögliche anstellen kann. Ich denke man sollte zumindest einen wirklich gut kennen damit man auch effizient arbeiten kann.

Ich werde mit Sicherheit, hier in diesem Blog, einige Artikel über den Emacs schreiben.