Plain DrOps

Meine 10 Jahre mit Emacs

Andy Drop — Tue, 16 Dec 2025 08:13:00 GMT

Heute vor 10 Jahren hatte ich meinen ersten Kontakt mit Emacs, und dieser Tag hat auf jeden Fall die Art und Weise verändert, wie ich mit dem Computer arbeite, wenn nicht sogar mein Leben.

Der Tag ist mir deshalb so genau in Erinnerung, weil es der Tag nach dem allerersten Treffen des "Warpzonista Coding Clubs" war. Die Warpzone war zu der Zeit mein lokaler Hackerspace, und der Schwerpunkt lag dort damals auf Hardwarebasteleien. Ich hatte Lust mehr Leute kennenzulernen, die - wie ich - programmieren, und bei tollstem Sonnenschein, und leichter Son Cubano Musik kam mir die Idee den Coding Club zu gründen. Das erste Treffen fand also am 27. Februar 2015 statt. Nach kurzem kennenlernen, kam das Gespräch dann zu dem Thema, das jeder Programmierer eines Tages für sich entscheidet. Die Wahl des persönlichen Editors.

Da ich damals im wesentlichen beruflich programmiert habe, nutzte ich die integrierte Entwicklungsumgebung die Microsoft mit Visual Basic 6 ausliefert. Aber ich wollte gerne unter Linux mit Python programmieren, und war auf der Suche nach einem Editor. Außerdem hatte ich schon mal Vim ausprobiert, und irgendetwas daran lag mir nicht. Im Laufe des Abends habe ich dann Christian Kruse kennengelernt, und wir haben uns darüber unterhalten, wie mein Kopf funktioniert, und dass ich im Prinzip in Hierarchien denke. Bäume sind mein Ding, Wenn ich Probleme behandele, backtracke mich durch verschiedene Lösungsansätze für Probleme, und Projekte teile ich in Aufgaben und Unteraufgaben auf.

Daraufhin meinte er: "Dann wird Orgmode dein Ding sein", und gab mir eine kurze Übersicht auf seinem Laptop. Am nächsten Tag hab ich mir Emacs installiert, und ausprobiert, wie ich selber mit der Bedienung klarkomme. Um es abzukürzen: Orgmode war toll, aber ich kam überhaupt nicht mit der Bedienung klar. Christian hatte mich schon vorgewarnt, und ich wusste, dass ich etwas namens CUA haben möchte, und ein wenig googlen brachte mich in die ersten Config Dateien, die andere Menschen im Internet veröffentlicht hatten.

Die ersten Configs

Ich hab dann ein paar Wochen lang einiges an Zeit investiert, um mir eine brauchbare Config zu erstellen. Ein paar Schnipsel hatte ich mir an verschiedenen Stellen im Netz zusammengeklaubt. CUA war dabei, YASnippet, und ich hatte herausgefunden, das ich mir eigene Keybindings machen kann. Dass ich die je nach Mode getrennt machen kann, wusste ich damals noch nicht, also alles schön global, und so dauerte es auch nicht lang bis zu meiner ersten Config Bankruptcy, einem Ausdruck, den ich damals noch nicht kannte. Die Ursache dafür war im Wesentlichen, dass meine von überall kopierten Config-Schnipsel oft eigene Namespaces mitbrachten, die ich überhaupt nicht als solche erkannte..

Mein zweiter Config Ansatz war schon relativ nah an dem, was ich bis heute verwende. Ich hatte viel im Emacs Manual gelesen, und mitlerweile Keybindings mit den einzelnen Layern verstanden, und auch gemerkt, das es beim kopieren fremder Configs darauf ankommt die an das verwendete Package Tool anzupassen. Meine zweite Config war also viel geplanter.

Ich verwendete eine minimale ini.cfg, die nichts weiter macht als drei andere configs zu laden

Eine Basis Config, bei denen ich für jedes installierte Paket die von mir bevorzugten Einstellungen mache (außer den Keybindigs)
Eine Config die alle Keybindings enthält. Wenn ich die alle an einem Ort habe, dachte ich mir, passieren mir nicht so viele versehentliche Doppelbelegungen
Eine Datei in der alle Anpassungen landen, die durch die benutzung des Config Tools in Emacs entstehen.

Damit konnte ich für die nächsten 1-2 Jahre ganz gut arbeiten. Ich habe Emacs immer besser kennengelernt. Habe verstanden, wie CTRL-X und CTRL-C quasi als einstiegspunkte in die komplette Tastaturbelegung dienen, und das es dort Muster gibt, die wohlüberlegt sind, und sinnvoll, und nicht mit meinem Kopf funktionieren. Ein großer Schritt vorwärts war es als ich das Hydra Paket entdeckte.

Ledger

Eine der ersten Pakete, das einen Einfluss auf mein reales Leben hatte war der Ledger Mode. Ledger ist eine doppelte Buchführung in einer einzigen Textdatei. Und so begann ich recht schnell damit, meine Bankbuchungen in eine Datei zu schreiben. Mit ein wenig Nachdenken, liess sich auch das Briefumschlag-Budget-System meiner Oma implementieren, und das hat mir finanziell echt den Arsh gerettet, indem es mir den kompletten Durchblick über meine Finanzen geliefert hat

Hydra

Bis dahin ga es zwei Arten, wie ich eine Funktion aufgerufen habe: Entweder mit einem Keybinding, oder ich habe gegoogelt, wie eine Funktion heißt, und habe sie dann via M-X mit ihrem Namen aufgerufen. Mit Hydra konnte ich mir plötzlich all die Funktionen, die ich für wichtig für mich hielt in Hydras ablegen, und sinnvoll gruppieren, und dann auch nur in den jeweiligen Modi zur Verfügung stellen. Ich bin bis heute ein großer Hydra-Fan. Nach und nach habe ich alle meine Hydras in einer Datei zusammengefasst. Diese bilden heute das Projekt Medusa und wurden als vierte Datei meiner Config hinzugefügt.

Helm

Der nächste größere Schritt war Helm. Das aussuchen der verschiedenen möglichkeiten war vor allem bei M-x im Minibuffer eine Qual. Mit Helm gab es nun eine komfortable Ansicht. Diese konnte ich in einen eigenen Buffer packen, der entweder im aktuellen Fenster, oder in einem benachbarten Fenster dargestellt wurde. Obwohl sich das nun alles schon deutlich besser anfühlte, hat mich ein Video von Prot dazu gebracht mein bevorzugtes Window Handling noch einmal komplett zu durchdenken. Seither benutze ich statt Helm den VOCEM-Stack.

VOCEM

Vocem ist meine Abkürzung für *V*ertico, *O*rderless, *C*onsult, *E*mbark & *M*arginalia. Diese 5 Pakete gemeinsam zu benutzen hat sich bei vielen Emacs-Nutzern durchgesetzt, auch wenn man jedes davon für sich alleine benutzen kann

Vertico: Vertico bietet eine performante und minimalistische vertikale Completion-UI, die auf dem standardmäßigen Completion-System basiert. Der Fokus von Vertico liegt darauf, eine UI bereitzustellen, die unter allen Umständen korrekt funktioniert. Es ist also der eigentliche Ersatz für Helm
Orderless: Dieses Paket stellt einen orderlosen Completion-Stil bereit, der das Muster in durch Leerzeichen getrennte Komponenten unterteilt und Kandidaten findet, die alle Komponenten in beliebiger Reihenfolge enthalten. Orderless ist für mein Hirn unabdingbar, da ich oft denke "Der Befehl begann irgendwie mit list" dabei kam "list" nur irgendwo in der Mitte vor.
Consult: Consult bietet Such- und Navigationsbefehle auf Basis der Emacs-Completion-Funktion completing-read. Die Completion ermöglicht es, schnell ein Element aus einer Liste von Kandidaten auszuwählen. Es verbindet also Quasi Vertico mit den gängigen Stellen, an denen man eine Completion haben möchte
Embark: Embark erleichtert die Auswahl eines Befehls basierend auf dem, was sich in der Nähe des Cursors befindet – sowohl während einer Minibuffer-Completion-Sitzung (in einer Art, die Helm- oder Counsel-Nutzern vertraut ist) als auch in normalen Buffern. Embark ist so etwas wie ein frei konfigurierbares Kontext-Menü, und macht sich daher auch hervorragend auf der rechten Maustaste.
Marginalia: Dieses Paket stellt marginalia-mode bereit, das Marginalien zu den Minibuffer-Completionen hinzufügt. Marginalien sind Markierungen oder Anmerkungen, die am Rand einer Buchseite platziert werden – oder in diesem Fall hilfreiche, farbige Anmerkungen am Rand des Minibuffers für deine Completion-Kandidaten. Marginalia liefert zu vielen Dingen, die nur mit einem Wort in einer Liste auftauchen etwas Kontext.

Denote

Denote hatte auf mich einen ebenso großen Einfluss wie Orgmode. Ich hatte schon vor Emacs ewig versucht all die losen Gedanken, Ideen, Quellen, die ich sonst im Kopf mit mir herumtrage, im Rechner zu organisieren. Ähnlich wie es Luhmann hier in der Nähe mit seinem legendären Zettelkasten gemacht hat. Entweder hatten die Ansätze für mich überhaupt nicht funktioniert, oder das Ablagesystem (das immer irgendeine Art externen Index auf das Wissen pflegte) hat nach einiger Zeit den Sync zwischen Wissen und Index verloren. Denote macht alle Metadaten dierekt an der Datei fest, und daher habe ich es selbst beim Teilen über alle meine Geräte noch nicht geschafft mein mentales Exoskelett aus dem Sync zu bringen. Ein größartiges gut durchdachtes Stück Software.

Dinge die ich gewollt nicht mache

Ich habe zum Beispiel kein Paket-Tool im Einsatz, bei dem mir dir gesamte Konfiguration für das Paket an einer Stelle habe. Ich möchte bewusst alle Tastenkombinatinen für alle Pakete an einem Ort haben, und genau so ergeht es mir mit den Hydras. Diese bauen aufeinander auf, und es ist praktisch sie alle ohne sonstige Dinge in einer Datei zu haben.
Zettelkasten. Ich kenne die Software nicht, habe aber eine stark negative Meinung zur digitalisierung des Luhmannschen Konzepts. Wir schreiben das Jahr 2025, der Hyperlink ist erfunden.

Fazit

Dieser Weg den ich in den 10 Jahren gegangen bin ist auf jeden Fall nur einer von tausenden möglichen Wegen. Jeder nutzt Emacs für andere Dinge, und jedes Hirn funktioniert anders. Ich kann auf jeden Fall empfehlen, die eigenen Ansprüche an die Emacs Umgebung in Ruhe zu durchdenken:

macht euch eine kurze Notiz, wenn sich etwas "falsch" für euch anfühlt. Beseitigt diese Dinge von Zeit zu Zeit.
Versucht herauszufinden, mit welchen Dingen ihr in Emacs arbeiten wollt: Configs? Romantexte? Buchhaltungsdateien? Addressen? Mails? Webseiten? Zitate? Orte? diese Liste ließe sich beliebig fortsetzen
Macht für jedes dieser Dinge eine Liste, welche Aktionen ihr gängigerweise auf diesen Dingen machen müsst. Z.B Weblinks: Im Browser aufrufen, im externen Browser aufrufen, speichern, im Blog publizieren, über alle Geräte synchronisieren, etc
Baut daraus nach und nach euren persönlichen Workflow zusammen
macht das nicht direkt am Rechner sondern schreibt diese Gedanken auf Papier, und bewahrt diesen Workflow als Schlachtplan für euch auf

Danke

Natürlich möchte ich vor allem Christian Kruse danken, der mich vor 10 Jahren in die richtige Richtung geschubst hat. Aber auch ein paar anderen Menschen (und ich werde bestimmt am Ende ein paar vergessen haben). Als Bonus erfahrt ihr, wie ich diese Menschen in meinem Kopf nenne.

Sacha Chua, die "Mutter der Kompanie" für ihre unermüdliche Arbeit, die Emacs Community mit ihren Emacs News und der jährlichen Emacs Conference zusammen zu halten. Ausserdem dokumentiert sie immer wieder welche Probleme in der realen Welt, sie mit welchen Methoden löst, und warum.
Protesilaos "Prot" Stavrou, "Der Philosoph", für Denote und vor allem dafür, das er seine Gedanken rund um den Entwurf seiner Emacs Pakete öffentlich in seinem Blog darlegt. So lässt sich wunderbar nachvollziehen, ob seine Pakete zum persönlichen Arbeitsstil passen
Karl Voit, "Mr. PIM" für seinen großartigen Orgmode Vortrag, und die Idee, das eigene Arbeiten mit den persönlichen Informationen einmal von Grund auf zu durchdenken. Ich bin dabei zu anderen Ergebnissen gekommen als er, aber ich habe dadurch gelernt, wie mein Hirn denkt, und dass es sinnvoll ist dieses "anders" zu nutzen.
David Wilson,"Der Erklärbär" für seine unzähligen System Crafters Videos, die immer gut sind, wenn man mal etwas sehr genau erklärt haben will

Viele andere, von denen man hier und da mal Ideen lesen kann, sind mir ebenso ans Herz gewachsen Auf die nächsten 10 Jahre mit euch allen.

EmacsWiki Blog Karneval "Wartung"

Andy Drop — Mon, 29 Sep 2025 00:00:00 GMT

Im Oktober, wenn die Tage kürzer und die Luft frischer wird, verlagern viele Menschen ganz natürlich ihren Fokus von der kreativen Energie des Sommers hin zur ruhigeren Arbeit zu Hause. Es ist die Jahreszeit, in der man Regenrinnen reinigt, Ecken des Hauses gründlich putzt, die man lange ignoriert hat, und kleine Reparaturen erledigt, die den Alltag reibungslos am Laufen halten. So wie sich manche dem Haushalten und dem Herbstputz widmen, kümmern sich andere um digitale Pflege – Notizen durchsehen, alte Dateien ausmisten oder die Emacs-Konfiguration so feinjustieren, dass sie angenehm und verlässlich arbeitet. „Wartung“ – in welcher Bedeutung auch immer – ist das Thema des EmacsWiki Blog-Karnevals im Oktober.

Was ist eigentlich ein Blog-Karneval?

(Kopiert aus Christian Tietzes Einführungspost)

Dies ist unser erster Emacs-Karneval, daher kennst du das Format vielleicht noch nicht. Ein Blog-Karneval ist eine unterhaltsame Möglichkeit, eine Community durch gemeinsame Schreibimpulse zu verbinden – und sich über all die kreativen Interpretationen des Monatsthemas zu freuen. Ich habe oben ein paar Deutungen vorgeschlagen, aber dir fällt vielleicht etwas völlig anderes ein. Großartig, mach das! Genau das macht den Spaß aus.

Für zukünftige Karnevals sieh dir die [[https://www.emacswiki.org/emacs/Carnival][„Carnival“-Seite

Beiträge einreichen

Schick mir deine Beiträge per DM/ E-Mail! Wenn ich irgendwo anders einen Beitrag finde, verlinke ich ihn hier ebenfalls. Ich sammle Einreichungen bis einschließlich 1. November (Mitteleuropäische Zeit), damit jede Zeitzone die Chance hatte, die Frist am 30. Oktober einzuhalten :)

Folgende Beiträge sind bis zum 30.10.2025 eingegangen:

Maintenance (Mantenimiento) von Carlos Pajuelo
Emacs Carnival: Maintenance von Eric MacAdie
Emacs Maintenance von Mike Hostetler
Using Emacs Org-mode As My Package Manager von Kana
Sharpening the Saw with Emacs von Christian Tietze
It's Fall. Time to clean up my emacs clutter. von George Jones
Sharpening the axe (or preparing the soil for the harvest) von Quijote Libre (auch auf spanisch)
Emacs Carnival: Praise the patchers von Neil

Vielen Dank an alle fürs Mitmachen!

Im November ist Donald Hunter Gastgeber: „An ode to org-babel“.

Auch du kannst Gastgeber eines zukünftigen Karnevals werden – keine Scheu :)

Sammeln und kategorisieren von Weblinks in Orgmode

Andy Drop — Tue, 04 Mar 2025 09:00:00 GMT

Ob sie nun Lesezeichen, Favoriten oder Weblinks heissen. jeder von uns sammelt im Laufe der Zeit eine ganze Menge von ihnen an. Irgendwann kommt der Tag wo das ganze unübersichtlich wird. und aufgeräumt werden muss. Ich hab mir ein Python Tool dafyr geschrieben.

Was bisher geschah

Neu Weblinks entstehen bei mir immer aus meinem Browser heraus. Sei es der Firefox auf Desktop und Laptop oder auf meinem Handy. Ich könnte sie also einfach nur innerhalb von Firefox lassen. Damit kann ich sie zwischen den Browsern synchronisieren, und sie aufrufen. Was will man mehr? Nun ich habe in diesem Blog z.B eine Seite mit Links, die ich gerne öffentlich teilen möchte. Wäre doch schön, wenn ich das nicht getrennt machen müsste. Und so hab ich mich schon vor Jahren entschlossen keine der eingebauten. oder online verfügbaren Tools zu nutzen, um Weblinks zu verwalten. Stattdessen speichere ich alle meine Weblinks als Plaintext im Orgmode Format. Jeder Link ist dort eine Überschrift mit dem Titel der Seite die mit der entsprechenden Seite verlinkt ist. Falls ich Lust habe, schreibe ich mir noch eine kleine Anmerkung dazu, oder füge ein Zitat aus der Seite ein. Wenn ich auf Laptop oder Desktop arbeite erledigt das ein kleines AddOn (Org Capture) welches neue Links an meine Links.org Datei dranhängt. Dazu benutzt es das org-capture Protokoll das Emacs für Links zur Verfügung stellt. Auf dem Handy funktioniert dieses AddOn leider nicht, daher teile ich die Webseite dort einfach mit der Orgzly-revived App. mit der sich Orgmode Dateien auf Android bearbeiten lassen. Der Link landet dann ebenfalls in der Links.org Datei. Ich synchronisiere mein gesamtes org Verzeichnii zwischen allen meinen Geräten.

Die Links.org Datei im Detail

Zunächst einmal beginnt diese Datei mit einem Satz von Metadaten-Zeilen, die mein Webseiten Generator braucht, um aus der Datei direkt die Linkseite zu erstellen, die man hier im Blog sieht. Das sieht dann so aus

#+BEGIN_COMMENT
.. title: Links
.. description: All the links I can recommend
.. slug: links
.. date: 2019-01-01 00:00:00 UTC+01:00
.. tags: links, emacs, orgmode, qutebrowser, plaintext, pim
.. previewimage: qrcodebus.png
#+END_COMMENT
#+OPTIONS: tags:nil

Die letzte Zeile sorgt dafür, dass die Tags, die ich den einzelnen Links gebe nicht nach HTML exportiert werden

In dieser Datei sind alle neuen Links zunächst mal eine Überschrifft der Stufe 2. In der obesten Stufe 1 gibt es genau vier Überschriften:

1. Quicklinks

Wie man sieht sind diese Links mit :noexport: getaggt, und tauchen daher nicht in der öffentlichen Linkliste auf. Es sind Links. die ich selbst häüfig aufrufe. Deher stehen sie in der Datei ganz oben. und sind bereits sichtbar, wenn ich die Datei öffne

* ------ Quick Links ----- :noexport:
 :PROPERTIES:
 :VISIBILITY: children
 :END:

Social Media	Shopping	News	Finanzen	Haustechnik	Konten	Other
Mastodon	Idealo	Tagesschau	Volksbank	FritzBox	BibLoad	Thingiverse
Feddit	Amazon	The Guardian	Barclays	Wechselrichter	Stadtbücherei	Cults
	eBay		Schw. Hall	Stromzähler
Codeberg	Otto	Wetter WAF	Paypal	Home Assistant		Oryx
Wallabag	Kaufland	Stat. Bundesamt		CUPS
		Dashboard DE		Syncthing
ChatGPT		Statista		Jenkins
Wiki

2. Öffentliche Links

Dies sind alle Links, die im Blog sichtbar sind. Aus den Hierarchie-Ebenen generiert mein Layout mit ein wenig CSS-Magie dann eine dynamische Liste. Mein Python Tool lässt alles bis zum Ende dieses Abschnitts in Ruhe.

3. Private Links

Hier wird es nun interessant. Heute (2025-03-04) befinden sich hier etwa 450 Links. Diese Links sind mit bis zu vier Tags versehen, und wurden bisher einigermassen sortiert und kategoriesiert gehalten. Wobei man schon an das "einigermassen" nur niedrige Massstäbe anlegen darf. Ach wen lüg ich da an - es war ein Dumpster-Fire.

4. Die INBOX

Im Prinzip das gleiche Durcheinander, wie bei den privaten Links, nur, dass ich hier noch nicht einmal Tags vergeben habe.

Es sind also die Abschnitte 3 und 4 um die sich mein Tool kümmern soll,

Was ist das Ziel des Tools?

Es soll sich alle Weblinks aus den Abschnitten 3 und 4 schnappen, und sie anhand ihrer Tags in eine logische Baumstruktur bringen. Die Fallstricke im letzten Satz befinden sich in den Wörtern eine und logische.

Gibt es denn mehrere Bäume?

Natürlich alles andere wära ja auch zu einfach. Tags sind ihrer Natur entsprechend alle gleichwertig. Sie enthalten keine Information über eine Hierarchie. Mal angenommen ich habe den folgenden Link mit den Tags a and b:

* Link :a:b:

Dann kann ich daraus schon 2 mögliche Bäume bauen

├── a
│   └── b
│       └── Link
└── b
    └── a
        └── Link

Sobald ich 3 Tags habe. kann ich das zusätzlich Tag in 3 möglichen Ebenen einfügen - in jeden der beiden Bäume - und erhalte damit schon 6 mögliche Bäume. die mathemathische Darstellung wäre 3! (sprich: 3 zur Fakultät) Falls jemand noch exponentielles Wachstum aus der Covid Zeit kennt. Das ist gegen fakutatives Wachstum auf Kindergarten Nivau. Nehmen wir 6 Tags sind wir bereits bei 720 möglichen Bäumen und nur 8 Tags reichen für 40320 Bäume.

Und was mach ich nun mit den ganzen Bäumen

Der gängige Ansatz wäre, sie alle zu nutzen, Dann taucht ein Link mit 4 Tags eben 24 Mal in der Linkliste auf, aber es gibt eben auch 24 Wege ihn zu finden. Grob Überschlagen würde das bei meinen 450 Links etwa 3000 Links in der Ausgabedatei ergeben. Und das ist mir zu viel. Eine Menge der Pfade ergeben dabei nicht wirklich einen Sinn. Mal angenommen ich verlinke den Ort, an dem ich mein Auto zuletzt geparkt habe:

* Auto :germany:munic:mainstreet:

Dann denke ich ja nicht "Hmm ich weiss noch, das ich in der Mainstreet geparkt habe, also zeig mir mal alle Länder in denen es Städte mit einer Mainstreet gibt. damit ich mir daraus die passende aussuchen kann"

Also muss ich diejengen Bäume abholzen die keinen Sinn ergeben. Hier kommt das zweite entscheidende Wort hinzu. Es soll eine logische Baumstruktur werden. Aber nicht erst seit Trump sollte klar sein. das es die seltsamsten Varianten von Logik gibt. und da ist alternative Logik noch nicht mal berücksichtigt. Und bei der Suche noch etwas sinnvollen sind Computer nicht wirklich gut. Also behelfe ich mir mit einem anderen Kriterium, der Häufigkeit. Zählen können Computer nämlich recht gut.

Wenn ich in meiner Datei 200 mal das Tag emacs habe aber nur 100 mal das Tag orgmode, Dann sieht der Baum so aus

└── emacs
    └── orgmode
        └── Link

Das klappt dann schon ganz gut, Aber hin und wieder gibt es noch ein paar seltsame Hierarchien, besonders wenn es sich um Tags handelt die insgesamt selten genutzt werden. da kommt es dan auf eine Nutzung mehr oder weniger schon an, wenn es um die Sortierung geht

Und nun mogle ich auch noch

In den meisten Fällen kommt es bei den seltenen Tags sowieso nicht darauf an. Aber wenn mir das mit großen (häufigen) Tags passiert ist dass schon ärgerlich. Und deshalb mogle ich ein wenig. Um mal be dem Auto Beispiel zu bleiben - das würde ich in Wirklichkeit so schreiben:

* Auto :Germany:Munic:mainstreet:

Siehst du den Unterschied? Die ersten beiden Tags sind nun gross geschrieben. Für mein Tool ist das der Hinweis, dass Land und Ort hierarchisch wichtiger sind als die Straße. Es gibt damit immer noch 2 mögliche Bäume, aber 4 Bäume sind damit sicher verhindert. Ich kann damit nur ein zwingende Hierarchiestufe bestimmen, aber damit die Zweifelsfälle, die Auftreten könnten, ganz brauchbar abfangen.

Warum ist das gemogelt? Nun Tags tragen laut Lehrbuch nun mal keine hierarchische Information, und mein Pogrammiererherz fühlt sich auch ein wenig schmutzig an. Nun aber zum technischen Teil, falls das jemand in einer anderen Sprache nachbauen möchte:

Der Algorithmus

Als allerstes sammle ich alle Links ein. die ich verarbeiten möchte und werfe sie in ein Dictionary. Der Key ist dabei ein Hashwert des eigentlichen Links. Damit elimimiere ich bereits versehentliche doppelte Links.
Dann werden alle Permutationen der Tags gebildet. Dabei werden alle Permutationen. die laut meiner gemogelter Tag-Hierarchie verboten sind ausgelassen.
Die Liste aller Links werfe ich nun in die eigentlich Funktion. die den Baum aufbaut. Weil es bei Bäumen einfach unglaublich praktisch ist, ist diese Funktion rekursiv. Das bedeutet sie erledigt die Aufgaben für ihre Ebene der Baumstruktur, und ruft sich dann für die tieferliegende Hierarchieebene einfach sebst auf. Jede Rekursion braucht eine Abbruchbedingung. Hier ist das "Es gibt keine weiteren Links die noch nicht an einem Tag hängen".

Was passiert in dieser Funktion nun?

Der eigentlich Tag wird als Knoten in den Baum eingefügt.
Zunächst einmal werden alle Links in den Baum gehängt, deren Tags exakt an diese Stelle im Baum passen, An Ebene 2 z.B also nur Links mit exakt 2 Tags die genau den Tags aus Ebene 1 und 2 entsprechen müssen
Wenn das erledigt ist, und noch Links übrig sind geht es ins Voting.
- Hier geben alle Links Stimmen dafür ab welchen Tag sie in dieser Ebene des (Teil-)baums noch gebrauchen können.
- Dar Tag mit den meisten Stimmen gewinnt
- Es wird eine Liste aller Links erstellt. die für diesen Tag gevoted haben
- Mit dieser Liste und den Namen des Gewinner-Tags ruft sich die Funktion selbst auf, und baut somit den kompletten Baum unterhalb auf.
- Die Liste wird von den ursprüglichen Links abgezogen, und sollten dann noch Links übrig sein, geht es in eine weitere Abstimmungsrunde. Andernfalls ist die Ebene fertig und die Funktion wird beendet

Am Ende wird der ganze Baum als Orgmode Struktur wieder in die Datei geschrieben und fertig ist die Laube.

Das Ergebnis

In der Ausgabedatei sind die Tags nun hierarchisch und sortiert

Die häufigsten Tags kommen zuerst
Bei gleicher Häufigkeit alphabetisch
Alle Links sind im Baum
kein Link ist doppelt

Und ich habe damit bereits einen Link-Baum mit dem ich gut arbeiten kann. Natürlich entsteht damit niemals der ideala Baum der mit dem übereinstimmt. wie ich das per Han sortieren würde aber ich bin schon recht nah dran. Vor allem gibt es in dem Algoritmus noch reichlich Potential für Optimierungen.

Das Voting tweaken

Wer sich für Wahlrecht interresiert wird festgesteiit haben, dass es dutzende, wenn nicht hunderte verschiedene Wahlverfahren gibt. die alle zu leicht unterschiedlichen Ergebnissen führen,und auf verschiedene Ziele (feste Sitzanzahl, Gewichtung nach Aktienanteil, Minimierung der zu reitenden Tage bis zur Hauptstadt) optimiert sind.

Das gilt auch für das Voting in diesem Algorithmus. Aktuell voted bei mir jeder Link für jeden Tag der ihm irgendwie nutzt mit einer Stimme. Ebenso wären aber auch andere Varianten denkbar:

Wenn ein Link 3 mögliche Bäume für Tag A sieht und 2 mögliche für Tag B, könnte er mit 3 bzw. 2 Stimmen für die jeweiligen Tags stimmen.
Die Votes könnten danach gewichtet werden ob ein Tag unmittelbar in dieser Ebene nötig ist, oder möglicherweise erst tiefer im Baum.
etc.

Alles in allem bin ich mit dem Ergebniss aber schon sehr zufrieden. Mein Repo mit dem aktuellen Stand des Tools befindet sich hier

Lisp Code schreiben mit ChatGPT

Andy Drop — Thu, 09 May 2024 08:00:00 GMT

Ich bin gerade dabei, den Besuch eines großen Festivals zu organisieren, mehr als 175 Bands spielen an 4 Tagen und etwa einem Dutzend verschiedener Orte, die quer über die Stadt verteilt sind. Das ganze ist eine logistische Herausforderung. Welche Bands möchte ich sehen und spielen die mit ausreichend zeitlichem Abstand um von Location A in Halle B zu kommen?

Also habe ich mir von der Seite des Veranstalters alle Daten in ein Org Dokument kopiert und mir eine Übersicht generieren lassen. in Org sieht das so aus:

* Bands  
   :PROPERTIES:
   :COLUMNS: %ITEM %Ort %Datum %Uhrzeit %Link1 %Link2 %Genre
   :END:

#+BEGIN: columnview :id local :skip-empty-rows t
| ITEM             | Ort                     |      Datum | Uhrzeit | Link1 | Link2 | Genre |
|------------------+-------------------------+------------+---------+-------+-------+-------|
| 12 Illusions (D) | Moritzbastei            | 17.05.2024 |   21.00 | [[https://www.youtube.com/watch?v=MOPkUBQbCzA][Song1]] | [[https://www.youtube.com/watch?v=_CUVz7neaRM][Song2]] | o     |
| A Projection (S) | Volkspalast Kuppelhalle | 19.05.2024 |   17.40 | [[https://www.youtube.com/watch?v=W7CndC-CQrw][Song1]] | [[https://www.youtube.com/watch?v=D1C5KpP3Hic][Song2]] | o     |
#+END:   

** 12 Illusions (D)
   :PROPERTIES:
   :Datum: 17.05.2024
   :Uhrzeit: 21.00
   :Ort: Moritzbastei
   :Adresse: Universitätsstraße 9
   :Strassenbahn: 9 (Roßplatz)
   :Strassenbahn+: 8, 9, 11, 14, 16, 32 (Wilhelm-Leuschner-Platz)
   :Bus: 412 (Roßplatz)
   :Bus+: N8 (Roßplatz)
   :S-Bahn: S1, S2, S3, S4, S5, S5X, S6 (Wilhelm-Leuscher-Platz)
   :Link1: [[https://www.youtube.com/watch?v=MOPkUBQbCzA][Song1]]
   :Link2: [[https://www.youtube.com/watch?v=_CUVz7neaRM][Song2]]
   :Genre: o 
   :END:

12 ILLUSIONS is a newly-launched German dark electro pop band.

** A Projection (S)
   :PROPERTIES:
   :Datum: 19.05.2024
   :Uhrzeit: 17.40
   :Ort: Volkspalast Kuppelhalle
   :Adresse: Messehalle 16 / Puschstraße 10
   :Strassenbahn: 16 (An den Tierkliniken)
   :Link1: [[https://www.youtube.com/watch?v=W7CndC-CQrw][Song1]]
   :Link2: [[https://www.youtube.com/watch?v=D1C5KpP3Hic][Song2]]
   :Genre: o 
   :END:

Die Tabelle oben ist meine Übersicht, und da dort mittlerweile knapp 200 Zeilen drin sind ist es mühsam, wenn man zu einer dieser Bands in den Teil mit den Details scrollen möchte. Wenn der Veranstalter die nicht schon alphabetisch aufgelistet hätte wäre es kaum machbar.

Die Übersichtstabelle generiert sich, dank Org Magie, immer neu wenn ich C-c C-c auf der Kopfzeile drücke. Die erste Spalte ist also buchstäblich identisch mit der Überschrift der einzelnen Bands, Wenn diese Überschrift einen Link auf sich selbst enthalten würde, dann wären in der ersten Spalte lauter Links auf die Details zu den Bands.

Um diese Links zu erzeugen muss ich mehrere Funktionen aufrufen:

Erzeugen einer Custom ID für die Überschrift
Kopieren dieser ID ins Clipboard
Markieren der Überschrift
Einfügen des Links

und das knapp 200 mal

Da wäre es zumindest schön, eine Funktion zu haben, die diese Schritte durchführt, und die ich dann an eine Taste binden kann.

Eine Nachfrage via Social Medie ergab, das zwar ähnliche Dinge schon erstellt wurden, aber alle hatten dann doch etwas leicht anderes zum Ziel. Und dann dachte ich mir,ich schaue mal ob ChatGPT mir das Problem lösen kann.

Der erste Versuch

Ich: Can you write a emacs lisp function, to link an orgmode Heading at point with its own id, creating one if it does not already exist?

ChatGPT: Certainly! Below is a simple Emacs Lisp function that links an Org mode heading at point with its own ID, creating one if it does not already exist:

(defun link-heading-with-id ()
  "Link an Org mode heading at point with its own ID, creating one if it does not already exist."
  (interactive)
  (org-back-to-heading)
  (let* ((heading (nth 4 (org-heading-components)))
         (id (org-entry-get nil "CUSTOM_ID")))
    (if (not id)
        (progn
          (setq id (concat "id-" (md5 heading)))
          (org-set-property "CUSTOM_ID" id)))
    (insert (format "[[#%s][%s]]" id heading))))

Nicht schlecht für den ersten Versuch. Die Funktion bewegt zuerst den Cursor an den Anfang der aktuellen Überschrift, ruft dann den Text der Überschrift und deren vorhandene ID ab, falls eine vorhanden ist. Falls die Überschrift keine ID hat, generiert sie eine mittels des md5-Hashes des Überschriftentextes. Schließlich fügt sie einen Link zur Überschrift mit ihrer ID ein.

Leider wird der Cursor an den Anfang der Überschrift bewegt, wodurch der neue Link vor der '** Überschrift' eingefügt wird, und sie somit keine Überschrift mehr ist. Aber vielleicht kann ChatGPF das korrigieren.

Can you alter it, so it replaces the original Heading?

ChatGPT: Certainly! Here's the modified function that replaces the original heading with the linked version:

(defun link-heading-with-id ()
  "Replace an Org mode heading at point with a linked version using its own ID, creating one if it does not already exist."
  (interactive)
  (org-back-to-heading)
  (let* ((heading-start (point))
         (heading-end (line-end-position))
         (heading (nth 4 (org-heading-components)))
         (id (org-entry-get nil "CUSTOM_ID")))
    (if (not id)
        (progn
          (setq id (concat "id-" (md5 heading)))
          (org-set-property "CUSTOM_ID" id)))
    (delete-region heading-start heading-end)
    (insert (format "* [[#%s][%s]]" id heading))))

Diese Version der Funktion löscht die originale Überschrift und fügt die verlinkte Version an ihrer Stelle ein. Aber sie hat immer noch ein Problem, das man in der letzten Zeile sehen kann. Es fügt immer eine Überschrift der Ebene 1 ein (es fügt ein Sternchen voran, immer nur eines). Mach das weg, ChatGPT!

Alter it, so that it preserves the Heading-Level

ChatGPT: Sure! Here's the modified function that preserves the heading level while replacing the original heading with the linked version:

(defun link-heading-with-id ()
  "Replace an Org mode heading at point
   with a linked version using its own ID,
   preserving the heading level
   and creating one if it does not already exist."
          (interactive)
          (org-back-to-heading)
          (let* ((heading-level (org-outline-level))
                 (heading-start (point))
                 (heading-end (line-end-position))
                 (heading (nth 4 (org-heading-components)))
                 (id (org-entry-get nil "CUSTOM_ID")))
            (if (not id)
                (progn
                  (setq id (concat "id-" (md5 heading)))
                  (org-set-property "CUSTOM_ID" id)))
            (delete-region heading-start heading-end)
            (insert (format "%s [[#%s][%s]]"
                            (make-string heading-level ?*)
                            id heading))))

Diese Version der Funktion ruft zunächst die Überschriftsebene mit org-outline-level ab. Dann löscht sie die ursprüngliche Überschrift und fügt die verlinkte Version mit derselben Überschriftsebene ein. Ich habe es ausprobiert, und es hat wie beabsichtigt funktioniert.

* Bands  
   :PROPERTIES:
   :COLUMNS: %ITEM %Ort %Datum %Uhrzeit %Link1 %Link2 %Genre
   :END:

#+BEGIN: columnview :id local :skip-empty-rows t
| ITEM                                                       | Ort          |      Datum | Uhrzeit | Link1 | Link2 | Genre |
|------------------------------------------------------------+--------------+------------+---------+-------+-------+-------|
| [[#id-e9884ccd6b1210ce39f04bc2eb7f108a][12 Illusions (D)]] | Moritzbastei | 17.05.2024 |   21.00 | Song1 | Song2 | o     |
#+END:   

** [[#id-e9884ccd6b1210ce39f04bc2eb7f108a][12 Illusions (D)]]
   :PROPERTIES:
   :Datum: 17.05.2024
   :Uhrzeit: 21.00
   :Ort: Moritzbastei
   :Adresse: Universitätsstraße 9
   :Strassenbahn: 9 (Roßplatz)
   :Strassenbahn+: 8, 9, 11, 14, 16, 32 (Wilhelm-Leuschner-Platz)
   :Bus: 412 (Roßplatz)
   :Bus+: N8 (Roßplatz)
   :S-Bahn: S1, S2, S3, S4, S5, S5X, S6 (Wilhelm-Leuscher-Platz)
   :Link1: [[https://www.youtube.com/watch?v=MOPkUBQbCzA][Song1]]
   :Link2: [[https://www.youtube.com/watch?v=_CUVz7neaRM][Song2]]
   :Genre: o
   :CUSTOM_ID: id-e9884ccd6b1210ce39f04bc2eb7f108a
   :END:

12 ILLUSIONS is a newly-launched German dark electro pop band.

Es funktioniert

Das Einzige, was noch zu tun ist, ist das Kopieren in die Konfiguration und das Binden an eine Taste. Ach ja, und ChatGPT kann das auch erledigen.

Ich: Please make a keybinding that binds M-. to this function

ChatGPT: Sure! You can bind the link-heading-with-id function to a keybinding of your choice, such as M-. . Here's how you can do it:

(global-set-key (kbd "M-.") 'link-heading-with-id)

Projekt Medusa: Denote

Andy Drop — Fri, 03 May 2024 08:00:00 GMT

Wer schon mal durch meine Projekte geschaut hat wird feststellen, dass es dort ein Projekt Medusa gibt, dass ich für mich angelegt habe. In Emacs gibt es immer wieder Funktionen die ich nur sehr selten brauche, und dann komme ich oft nicht direkt auf den notwendigen Befehl. Da ist es dann ganz hilfreich eine Hydra für diese Situation zu haben, und das Projekt unter dem ich all diese Hydras zusammenfasse, heißt bei mir Medusa. Neulich wollte ich für Denote eine Hydra anlegen, und habe festgestellt, dass es da ein paar Probleme gibt.

Generell halte ich es mit den Hydras so: Ich habe zwei Daumentasten über die ich auf meiner Tastatur die Hydras ansteuere. Auf dem linken Daumen liegt eine eher generelle Hydra die für alle Funktionen gedacht ist die nicht nur in einem speziellen Mode gebraucht werden. Hier kann man es sich etwa so vorstellen, dass dort die Funktion liegen die man normalerweise mit dem Präfix CTRL-x erreicht

Auf dem rechten Daumen liegt eine Art Kontextmenü, also die Hydra, die zu dem jeweiligen Mode gehört, in dem ich mich gerade befinde. Das kann man sich etwa so vorstellen, als wären dort alle Funktionen die über CRTL-c als Prefix zu erreichen sind. Dass ich das ganze wie ein Kontextmenü behandle, sieht man auch daran, dass ich diese Hydras gleichzeitig auf der rechten Maustaste liegen habe.

Modelose Kunst

Und hier beginnt auch schon das Problem. Denote ist eine Anwendung, die viele Befehle zur Verfügung stellt, um lose geschriebene Notizen miteinander zu verknüpfen. Da diese Notizen jedoch in allen möglichen Formaten geschrieben sein können, gilt natürlich immer der jeweilige Major Mode des Formats. Ich schreibe dieses Blog z.B im Org-Mode das heißt der Major Mode ist in dem Moment nicht Denote sondern Org-Mode. Das Package Major Mode Hydra, funktioniert deswegen schon mal nicht

Denote ist aber auch kein Minor Mode, den man beliebig bei allen möglichen Dokumenten ein- oder ausschalten kann. Ein Dokument ist genau dann ein Denote Dokument wenn es sich in einem bestimmten Verzeichnis (Silo) befindet und einer Namenskonvention folgt. Und da Denote kein Minor Mode ist, hat es auch keine eigene Keymap. Aber Emacs wäre nicht Emacs, wenn man da nicht etwas machen könnte.

Wir bauen uns einen Minor-Mode

Es wäre gut, wenn Denote ein Minor Mode hätte, der immer dann aktiv wäre, wenn sich das aktive Dokument in einem Denote-Silo befindet. Da ein Silo immer auch ein Verzeichnis ist, hat Emacs ein Werkzeug an Bord: Verzeichnisspezifische Variablen

Das Handbuch sagt

Der übliche Weg, verzeichnisspezifische Variablen zu definieren, besteht darin, eine Datei mit dem Namen .dir-locals.el in einem Verzeichnis zu platzieren. Wenn Emacs eine Datei in diesem Verzeichnis oder einem seiner Unterverzeichnisse öffnet, werden die verzeichnisspezifischen Variablen, die in .dir-locals.el angegeben sind, angewendet, als ob sie als dateispezifische Variablen für diese Datei definiert worden wären. Emacs sucht nach .dir-locals.el, beginnend im Verzeichnis der geöffneten Datei, und bewegt sich dabei aufwärts im Verzeichnisbaum.

Meine Datei .dir-locals.el liegt im obersten Verzeichnis meines Silos, und sieht so aus

((nil . ((denote-mode . t))))

Diese Zeile sorgt dafür, das bei allen Dateien in diesem Verzeichnis der denote-mode eingeschaltet wird. Das ist ein Minor Mode, den Denote nicht von Hause aus mitbringt, sondern den wir zuvor selbst erzeugen müssen. Das passiert im entsprechenden Teil meiner Emacs Konfiguration.

(define-minor-mode denote-mode
  "Denote is a simple note-taking tool for Emacs."
  :lighter " Note"
  :keymap (let ((map
                   (make-sparse-keymap)))
              (define-key map (kbd "C-l") 'denote-link-or-create)
              (define-key map (kbd "C-n") 'denote-link-after-creating)
              (define-key map (kbd "<f6>")(lambda () (interactive) (find-file "~/wiki")))
              map))

:lighter gibt an, was in die Mode-Line geschrieben wrd, wenn der Minor-Mode aktiv ist, und :keymap gibt an welche Keymap genutzt werden soll. In diesem Fall wird über make-sparse-keymap eine leere Keymap erzeugt, und mit den gängigsten Befehlen die ich so brauche gefüllt. Vermutlich könnte ich diese Erstbefüllung auch weglassen, da ich die endgültigen Keybindings sowieso später mache, aber ich habe kein Beispiel gefunden in dem eine leere Keymap angelegt wurde.

Die eigentliche Hydra

Ich bestücke meine frisch erzeugte Keymap dann noch mit den einzig entscheidenden Tasten. <menu> ist der KeyCode den meine rechte Daumentaste sendet.

(define-key denote-mode-map (kbd "<menu>") #'medusa/denote/body)
(define-key denote-mode-map (kbd "<mouse-3>") #'medusa/denote/body)

Wenn ich dann in einem Denote Silo die rechte Maustaste click erscheint folgende Hydra

Erzeugt wird das Ganze durch folgenden Code. ich nutze dabei die etwas kürzere und hübschere Syntax die mir das Package Pretty Hydra zur Verfügung stellt.

(pretty-hydra-define medusa/denote
  (:color blue :quit-key "<escape>" :title "Denote")
  ("Create" (
    ("n" denote "_n_ew note" )
    ("t" denote-type "other _t_ype" )
    ("d" denote-date  "other _d_ate" )
    ("s" denote-subdirectory  "other _s_ubdir" )
    ("T" denote-template  "with _T_emplate" )
    ("S" denote-signature  "with _S_ignature" ))
   "Link" (
    ("l" denote-link-or-create "_l_ink" )
    ("L" denote-link-or-create-with-command "_L_ink with command" )
    ("h" denote-org-extras-link-to-heading  "specific _h_eader" )
    ("r" denote-add-links "by _r_egexp" )
    ("d" denote-add-links "by _d_ired" )
    ("b" denote-backlinks "_b_acklinks" ))
   "Rename" (
    ("RF" denote-rename-file "Rename File")
    ("FT" denote-change-file-type-and-front-matter  "only FileType")
    ("UF" denote-rename-file-using-front-matter "use Frontmatter"))
   "Dyn. Block" (
    ("DL" denote-org-extras-dblock-insert-links "dyn. Links" )
    ("DB" denote-org-extras-dblock-insert-backlinks "dyn. Backlinks" ))
   "Convert links" (
    ("CF" denote-org-extras-convert-links-to-file-type "to File Type" )
    ("CD" denote-org-extras-convert-links-to-denote-type "to Denote Type" ))
  "Other" (
     ("?" (info "denote") "Help")
     ("<menu>" major-mode-hydra "Major Mode Hydra"))))

Keymacs, ein Programm um Emacs Keybindings zu erzeugen

Andy Drop — Tue, 23 Apr 2024 08:00:00 GMT

Offensichtlich gibt es ein Menge Emacs-Puristen in der Welt, die im Laufe der Jahre gelernt haben so komplizerte Tastenfolgen wie C-x r t M-. C-c C-p fliessend zu tippen Ich gehöre nicht dazu. Und als ich versucht habe heraus zu finden wie ich das für mich anpassen kann, waren die Webforen voll von Kommentaren, dass das keine gute Idee sei.

Im wesentlichen aus folgenden Gründen:

Portabilität: Wenn man seine Emacs-Tastenbelegung stark anpasst, könntest man Schwierigkeiten haben, Emacs auf einem anderen System zu verwenden, auf dem seine Anpassungen nicht verfügbar sind. Das könnte problematisch sein, wenn man häufig zwischen verschiedenen Rechnern wechselt oder wenn man Emacs auf einem entfernten Server verwenden muss.
Lernkurve: Emacs hat bereits eine steile Lernkurve für Anfänger, und wenn man die Tastenbelegung stark anpasst, kann das die Sache für andere noch schwieriger machen, seine Konfiguration zu verstehen. Das könnte ein Problem sein, wenn man mit anderen zusammenarbeitet oder wenn man seine Konfiguration mit jemand anderem teilen muss.
Konflikte: Wenn man nicht vorsichtig ist, können stark angepasste Tastenbelegungen zu Konflikten zwischen verschiedenen Paketen oder Modi in Emacs führen. Dies kann zu unerwartetem Verhalten führen und es schwieriger machen, Probleme zu diagnostizieren und zu beheben.
Abhängigkeit von Anpassungen: Wenn man zu sehr auf seine individuellen Tastenbelegungen angewiesen ist, könnte man feststellen, dass es schwierig ist, Emacs ohne sie zu verwenden. Das könnte ein Problem sein, wenn man einmal auf einem System arbeiten muss, auf dem man seine individuelle Konfiguration nicht nutzen kann.

Ich muss allerdings nie meine Emacs Konfiguration mit anden Menschen teilen, oder Emacs woanders benutzen, als auf meinen beiden Rechnern. Daher fallen die Punkte 1 und 4 schon mal weg. Was die Lernkurve angeht, habe ich ja nicht vor mir noch kompliziertere Tastenkombinationen auszudenken. Ich möchte einfach mit dem weiterarbeiten können, das sich seit Jahrzehnten in mein Gedächtnis gebrannt hat. Punkt 2 hat sich damit auch erledigt.

Bleibt noch Punkt 3, und es stimmt: Wenn man nicht vorsichtig ist, können stark angepasste Tastenbelegungen zu Konflikten zwischen verschiedenen Paketen oder Modi in Emacs führen.

Ich bin dem bisher aus dem Weg gegangen, indem ich in hübschen Tabellen (Org-Mode sei Dank) Buch darüber geführt habe, welche Anpassung ich vorgenommen habe, um zu erkennen wo es evtl. zu Konflikten kommen kann. Dieses Vorgehen ist natürlich recht anfällig für Fehler. Die Tabellen müssen immer konsistent sein zu den Keybindings an dutzenden von Stellen in der Config. Da braucht man schon sehr viel Disziplin, und es wird schwierig, mal eben etwas auszuprobieren.

Etwas besser wurde es, als ich begonnen habe, alle Keybindings in einer Datei zusammenzufassen. Diese Datei wird am Ende der init.el geladen, und nigrgendwo anders werden Keybindings gemacht. Damit hat es lange funktioniert. Keine Tabellen mehr. Im Code steckt die Wahrheit. Leider war es nicht so einfach im Code nach potentiellen Konflikten zu suchen. Man kann nicht mal eben die Sortierung im Code von "Keymap Name" auf "verwendete Taste" ändern. Da waren Tabellen schon besser.

Also habe ich mich hingesetzt, und mir ein Tool in Python geschrieben, bei dem ich meine gewünschten Keybindings wieder in Org-Tabellen verwalten kann, und das Tool erzeugt mir daraus automatisch die gewünschten Keybindings. Es heisst

Keymacs

Das Programm ist ganz simpel. Es geht über eine Datei (default: keymap.org im aktuellen Verzeichnis), sucht sich alle Tabellenzeilen zusammen, und geht davon aus, dass es sich dann dabei um Beschreibungen von Keybindings handelt. Dabei werden Headerzeilen und Trennzeilen ignoriert, sowie fast aller anderer umgebender Text auch. Man kann in der Datei also auch beschreiben, was man sich bei den einzelnen Bindings gedacht hat.

Es gibt zwei leicht unterschiedliche Tabellen

Die explizite Tabelle

Key	Mode	Ctrl	Super	Function
c	treemacs-mode			'treemacs-copy-file
c	treemacs-node-visit			'treemacs-visit-node-close-treemacs
c	treemacs-toggle			'treemacs-indicate-top-scroll-mode
d	treemacs-copy			'treemacs-paste-dir-at-point-to-minibuffer
l	treemacs-mode			treemacs-copy-map
p	treemacs-copy			'treemacs-copy-project-path-at-point
r	treemacs-copy			'treemacs-copy-relative-path-at-point
n	treemacs-mode	X	X	'treemacs-create-dir
n	treemacs-mode	X		'treemacs-create-file

Ich habe hier mal mit Treemacs ein Beispiel herausgesucht, and dem sich einige Dinge gut zeigen lassen. Treemacs hat die Besonderheit, dass ich im Fenster keine Eingaben machen musss. Es gibt also keinen Grund nicht einfach Buchstaben zu benutzen, ohne den kleinen Finger ständig auf der Ctrl Taste zu haben. Zunächst mal die ersten 3 Zeilen

Key	Mode	Function
c	treemacs-mode	'treemacs-copy-file
c	treemacs-node-visit	'treemacs-visit-node-close-treemacs
c	treemacs-toggle	'treemacs-indicate-top-scroll-mode

Es gibt 3 verschiedene Stellen. an denen ich einfach c drücken kann, die jedoch nicht im Konflikt miteinander sind, weil sie sich in verschiedenen Keymaps befinden. Um den namen der keymap zu erhalten, hängt das Programm einfach -map an den Mode.

Aber moment mal, es gibt doch keinen treemacs-toggle Mode? Stimmt, aber es gibt eine Keymap dazu und ein Prefix, an das diese gebunden ist. Ich zeige das mal and der treemacs-copy-map:

Key	Mode	Function
l	treemacs-mode	treemacs-copy-map
d	treemacs-copy	'treemacs-paste-dir-at-point-to-minibuffer
p	treemacs-copy	'treemacs-copy-project-path-at-point
r	treemacs-copy	'treemacs-copy-relative-path-at-point
a	treemacs-copy	'treemacs-copy-absolute-path-at-point

Diese Map heist originellerweise treemacs-copy-map obwohl ursprünglich nur eine Funktion darin die aktuelle Datei kopiert (und die habe ich mir kürzer auf c gelegt. Alle anderen legen mir nur diverse Links ins Clipboard, daher habe ich als Taste auch l gewählt um in die treemacs-copy-map zu gelangen, dia nachfolgende Taste wählt dann welch Art Link ich haben möchte (absolut, relativ oder doch zum Project-Root?) l a gibt mir also den Link als absoluten Pfad.

Und natürlich kann ich auch, wenn ich will, trotzdem Ctrl Kombinationen verwenden. Zum Beispiel verwenden viele Programme Ctrl-n um eine Neue Datei, ein neues Object, oder sonst etwas neues zu erzeugen. Warum sollte ich das ignorieren? Also:

Key	Mode	Ctrl	Super	Meta	Shift	Function	Remark
n	treemacs-mode	X				'treemacs-create-file
n	treemacs-mode	X	X			'treemacs-create-dir

So kann ich mit Ctrl-n eine neue Datei anlegen und mit Ctrl-Super-n auch ein neues Verzeichnis.

Gerade die gängigen Ctrl Kombinationen sind aber natürlich in vielen verschiedenen Modi sinnvoll, und man muss ein wenig aufpassen, das sich die Keybindings nicht gegenseitig stören, Vor allem wenn minor-modes ins Spiel kommen. Dazu benutzt man dann besser:

Die implizite Tabelle

Auf Anhieb sieht die Tabelle gleich aus, es fehlt jedoch die Key Spalte links

Mode	Ctrl	Super	Shift	Function
Global	X			'org-insert-link-global
org-mode	X			'org-insert-link
org-mode	X	X		'org-super-links-insert-link
org-mode	X		X	'org-super-links-link

Doch woher weiss keymacs nun an welche Taste es binden soll? Ich hatte zu Beginn geschrieben, dass keymacs Headerzeilen und Trennzeilen ignoriert, sowie fast allen anderen umgebenden Text auch. Nun hier ist der Grund für das "fast", und duzu müssen wir in den Org-mode schauen

** N New
 | Mode       | Ctrl | Super | Meta | Shift | Function                 | Remark |
 |------------+------+-------+------+-------+--------------------------+--------|
 | Global     | X    |       |      |       | 'find-file               |        |
 | org-mode   | X    |       |      |       | 'find-file               |        |
 | dired-mode | X    |       |      |       | 'dired-create-empty-file |        |
 | dired-mode | X    | X     |      |       | 'dired-create-directory  |        |

Keymacs liest nämlich von allen Org Header Zeilen das erste Wort (hier 'N') und verwendet es für die darauf folgenden impliziten Tabellen. Ein neuer Header setzt wieder eine andere Taste z.B.

** F9 Treemacs - a tree layout file explorer for Emacs
 | Mode   | Ctrl | Super | Meta | Shift | Function                | Remark |
 |--------+------+-------+------+-------+-------------------------+--------|
 | Global |      |       |      |       | 'treemacs-select-window |        |
 | Global |      |       |      | X     | 'treemacs-find-file     |        |
 | Global | X    |       |      |       | 'treemacs-find-tag      |        |
 |        |      |       |      |       |                         |        |

Ausser für das erste Wort interessiert sich keymacs für nichts. Nebenbei sieht man hier auch, das die global-map mit Global gefüllt wird (mit großem G). Bei den Spalten muss die Reihenfolge passen, die Überschriften sind nur für den Leser und werden ignoriert.

Das Programm

Geschrieben habe ich das ganze ursprünglich um mein Problem zu lösen, und später dann auch um den kompletten Enwicklungsprozess mittels Hatch zu testen. Daher gibt es das ganze auch auf (Test-)PyPi zum Download. Da ich diesen ganzen Python Workflow gerne verinnerlichen möchte, werde ich auch weiter an diesem Tool arbeiten, auch wenn es bisher schon alle meine Probleme löst. Aber der Code ist hässlich und hat bisher nur einen "happy Path" ohne Error Handling.

Der Sourcecode liegt hier

Wenn man es nur installieren möchte empfehle ich pipx zu nutzen. Dann geht das einfach so:

pipx install -i https://test.pypi.org/simple/ keymacs

Das Programm liest die keymap.org Datei nur, und schreibt dann eine keymap.el die man dann am Ende seiner init.el einbindet

(load (concat user-emacs-directory "config.el"))
;;(load (concat user-emacs-directory "sanekeys.el"))
(load (concat user-emacs-directory "medusa.el"))
(org-babel-load-file (concat user-emacs-directory "elgato.org"))
(org-babel-load-file (concat user-emacs-directory "skeletons.org"))
(load (concat user-emacs-directory "keymap.el"))

(setq custom-file (concat user-emacs-directory "custom.el"))
;; (load (concat user-emacs-directory "custom.el"))

Mal eben schnell drucken in Emacs

Andy Drop — Fri, 19 Apr 2024 08:00:00 GMT

In Emacs gibt es eine ganze Reihe von Wegen, hübsche Ausdrucke zu erzeugen. Die meisten erzeugen am Ende PDFs. Aber wenn man einfach mal schnell einen Ausdruck des Buffers haben will, um darin mit Bleistift und Textmarker zu arbeiten, dann kann das schon mal ein Problem werden. Ich hab einen Abend lang versucht, das zu lösen, und es schliesslich auch geschafft. Damit ich mich daran erinnere gibt es diesen Blogeintrag.

Im Prinzip gibt es den befehl print-buffer, der bei mir aus Gewohnheit mit CTRL-p aufgerufen wird. Ich erwarte dann, dass aus dem Drucker Papier kommt, das unformatiert einfach das enthält, was ich im Buffer auf dem Bildschirm sehe.

Leider funktionierte das bei mir überhaupt nicht. Emacs benutzt für diese Art Ausdrucke den Linux Kommandozeilenbefehl lpr, und schnell war klar, das mit dem auch auf der Kommanduzeile kein Blumentopf zu gewinnen ist. Jeder Versuch irgendetwas damit zu drucken endete mit der Meldung, dass der lpr Daemon nicht laufen würde. Jeder Versuch diesen zu starten schlug fehl. Irgenwann dämmerte es mir, das lpr als Tool zum drucken vielleicht einfach zu alt ist.

Zurück in die Zukunft

lpr ist nämlich ein älterer Befehl, der aus den Zeiten stammt, als Drucker häufig direkt an Unix-Systeme angeschlossen waren. Inzwischen begab es sich aber, das das "Common Unix Printing System" (CUPS) entwickelt wurde, das eine moderne Druckverwaltung auf Unix-Systemen bietet. Und ein wenig Websuche ergab, dass es seinen eigenen Kommandozeilenbefehl mitbringt lp.

Die Syntax der beiden Befehle kann leicht variieren. lpr akzeptiert normalerweise einfach den Dateinamen, den ich drucken möchte, während lp eine Reihe von Optionen akzeptiert, die es mir ermöglichen, verschiedene Aspekte des Druckauftrags zu steuern, wie z.B. die Anzahl der Kopien, den Drucker, das Papierformat usw.

In Emacs gibt es dafür netterweise die Möglichkeit den Befehl, den es unter der Decke nutzt zu konfigurieren. Wir sagen also, das wir statt lpr lieber lp vervenden wollen

 (setq lpr-command "lp")

Da lp und lpr unterschiedliche Parameter auf der Kommandozeile mitgeben, macht es auch keinen Sinn, für lp weiterhin die lpr Standard Switches zu nutzen. Die schalten wir also ab

(setq lpr-add-switches nil)

Und Zack funktionierte alles wie erwartet, also habe ich es in meiner Config verewigt

Fazit

Wenn man nicht gerade ein antikes Linux System nutzt macht lpr keinen Sinn mehr, und sollte durch lp ersetzt werden. IMHO wäre das mittlerweile auch ein guter Default.

In der Konfiguration kann man übrigens auch eigene Parameter einstellen, die an lp übergeben werden, ich denke damit bekomme ich dann auch den doppelseitigen Druck hin.

Mein Tastaturlayout Edwin

Andy Drop — Thu, 07 Dec 2023 23:00:00 GMT

Irgendwann Anfang des Jahres habe ich mir nach langem Zögern eine Moonlander MK1 Tastatur angeschafft. Ich hatte mir einige Vorteile davon versprochen, aber auch leider einen entscheidenden Nachteil gesehen…

Die Vorteile sind:

Dadurch, dass die Tastatur in 2 Hälften geteilt ist, kann ich mir die beiden Seiten passend zu meinem Schulterabstand hinstellen, und habe eine entspanntere Sitzhaltung
Jede Hälfte ist nach außen geneigt, dadurch ist auch jeder Arm nicht mehr so in sich gedreht, wie an einer "normalen" Tastatur
Die einzelnen Tasten sind in Spalten angeordnet, bei denen der Finger nur auf und ab greifen muss, und sich dabei nicht noch zur Seite bewegt, wenn es nicht nötig ist. Das kommt mir beim Schreiben besonders entgegen, weil mein Hirn anscheinend in Tabellen und Bäumen denkt. Meine Hirnzellen scheinen rechtwinklig zueinander angeordnet zu sein. Mit den versetzten Tasten bin ich beim Versuch, Tastschreiben zu lernen, nicht wirklich klargekommen. Der Versatz zwischen den Tasten kommt ja daher, die Typenhebel bei mechanischen Schreibmaschinen zu bedienen, und ist eigentlich schon seit der Zeit der Kugelkopf- oder Typenrad-Schreibmaschinen überflüssig.
Dafür sind die einzelnen Spalten in der Höhe gegeneinander versetzt, um dem Umstand Rechnung zu tragen, dass die einzelnen Finger auch verschieden lang sind.

Der leider wichtige Nachteil:

Die Tastatur zwingt einen dazu, mit zehn Fingern zu schreiben, was ich zu diesem Zeitpunkt leider nicht beherrscht hatte.

Dieser Umstand wiegt besonders schwer, weil ich die selbe Tastatur für meinen privaten und für meinen Dienstrechner benutze. Aber, da ich dort im Wesentlichen Bugs aus Legacy Software entferne, und an vielen Tagen keine 10 Zeilen neuen Code schreibe, schien mir das Risiko vertretbar.

Ein riesiger Vorteil ist, dass die Tastatur vollständig frei programmierbar ist, in mehreren Ebenen und unterscheidbar in kurzen, langen, doppelten und gehaltenen Tasten.

Das Layout

Ich hab mir gedacht, wenn ich sowieso ganz neu mit dem Tastschreiben anfange, dann erspare ich mir auch das leidige QWERTZ-Layout, das so auch wieder nur existiert, damit sich die Typenhebel bei mechanischen Schreibmaschinen möglichst wenig verklemmen.

Für heutiges Schreiben am PC gibt es deutlich besser geeignete Layouts, die die Hände besser entspannen. Dvorak, Colemak, oder Neo zum Beispiel. Ich habe mich für Letzteres entschieden, weil es für die deutsche Sprache optimiert ist, und ich es leicht zu merken finde, alle Vokale in Ruhestellung unter den Fingern der linken Hand zu haben.

Und so habe ich mich bei der Belegung auch im Wesentlichen an Neo 2 orientiert.

Layer 0

Die Beschriftung der Tasten liest sich so, dass die obere Hälfte angibt, was die Tastatur ausgibt, wenn ich die Taste drücke, die untere Hälfte zeigt, was beim kurzen Halten der Taste (200 ms, konfigurierbar) der Taste passiert. Wenn ich z.B, die Taste für das "c" kurz halte, wird daraus ein Strg-C.

Wie man sieht habe ich nicht besonders viele Änderungen gegenüber dem normalen Neo-Layout vorgenommen. Die Änderungen sind:

Punkt und Komma haben im Original zwei verschiedene Tasten, aber da ich noch unbedingt Platz für Cursortasten unter der rechten Hand haben wollte, musste der Punkt weichen und ist nun ein kurz gehaltenes Komma.
Die Zahlenreihe oben ist für mich ohnehin schwer erreichbar, und daher für die vielen Zahlen, die ich ständig tippe, unpraktisch. Ich habe sie also dort komplett entfallen lassen, und in einen Zehnerblock in Ebene 3 verschoben. Stattdessen gibt es in der oberen Reihe nun 20 Funktionstasten F1-F20. Die ersten 10 durch normales Tippen. Durch kurzes Halten wird aus F2 dann F12 etc..
Die Tasten, um in die anderen Ebenen umzuschalten, sind allesamt auf die unteren Daumentasten gewandert. Dort sind sie besonders einfach zu erreichen.
Für die Shift-Taste, die normalerweise vom schwachen kleinen Finger gehalten wird, habe ich diverse Stellen ausprobiert. Bewährt hat sich am Ende, die Leertaste - wenn sie gehalten wird - als Shift-Taste zu verwenden.
sämtliche Sonderzeichen sind beim Neo Layout normalerweise im 2. Layer vergraben, aber da ich den Bindestrich im normalen Schreibfluss immer mal wieder brauche, habe ich mir den auf das gehaltene "j" gelegt.

Layer 1

Hier finden sich normalerweise alle Sonderzeichen gut verteilt auf beide Hände. Aber mein Kopf hat es einfach nicht hinbekommen, sich deren Anordnung zu merken, also habe ich mir für diese Ebene eine komplett neue Anordnung ausgedacht, die sich an meinen persönlichen Schreibgewohnheiten ausrichtet und passenderweise auch noch sehr einfache Eselsbrücken bereitstellt.

]]

Die linke Hälfte der Tastatur ist auf Layer 1 quasi unbelegt. Lediglich die Tasten F21-F24 finden sich hier, wo sich in Ebene 0 F1-F4 finden. Ansonsten benutze ich die Tasten für Textblöcke, die ich beruflich häufig verwende, daher habe ich sie hier auch nicht dargestellt. Stattdessen spielt sich alles unter der rechten Hand ab.

Hier finden sich die PgUp und PgDn Tasten, die beim kurzen Halten den Cursor nicht nur eine Seite nach oben oder unten befördern, sondern gleich bis ganz an den Anfang oder das Ende des Textes. Dazu geht meine Hand wegen der Entfernung ein kleines bisschen aus der Ruheposition heraus.

Die blöde obere Reihe ist nur mit sehr selten benutzten Währungs- und Akzentzeichen belegt.

Zeige- und Mittelfinger sind mit Klammern beschäftigt. In der Ruhestellung mit den normalen und eckigen Klammern, die ich als Programmierer häufig brauche. Wenn ich die Finger nach oben strecke, dann mit den spitzen und geschweiften Klammern. Bei allen Klammern ist es so, dass ich durch Drücken die Klammer öffne, und durch kurzes Halten wieder schliesse. Halten muss ich allerdings sehr selten, da ich mir meinen Editor so eingestellt habe, dass ich beim Öffnen einer Klammer immer auch schon die schließende Klammer automagisch eingefügt bekomme.

Zufällig ergaben sich die Eselsbrücken:

N - normale Klammern
R - rechteckige Klammern
H - HTML Klammern
G - geschweifte Klammern

Außerdem bilden sie ein hübsches Quadrat

Rechts daneben liegt ein weiteres Quadrat, das ich beruflich benötige, weil ich viele Oracle-SQL-Abfragen schreibe.

Es enthält die einfachen Anführungsstriche, um Strings zu begrenzen, das Semikolon, um Statements zu beenden, das Prozentzeichen, für Wildcards und das Gleichheitszeichen für viele Vergleiche.

Wenn ich die beiden stärksten Finger nach unten bewege finden sich dort alle Zeichen, die ich auf der Kommandozeile benötige, um Pfade einzugeben ( ~ / . ) schön einfach zu erreichen.

Die seltener benötigten Zeichen sind hübsch in die verbleibenden Lücken gestreut.

Layer 2

Die Ebene 2 ist dann für den Zehnerblock reserviert. Das ist für mich einfach die intuitivere Art Ziffern zu erfassen, und als eigene Ebene ist es damit noch nicht einmal nötig, die rechte Hand zur Seite zu bewegen. Der linke Daumen wechselt in die Ebene und sofort liegt die 5 unter meinem rechten Mittelfinger und alle wichtigen Rechenzeichen sind rundherum angeordnet. Punktrechnung rechts, Strichrechnung links.

Fazit

Das Layout, wie es heute ist, hat sich mittlerweile sehr bewährt, und was das korrekte Tastschreiben angeht, schreibe ich mittlerweile weitgehend blind in nahezu der alten in 40 Jahren angewöhnten 6-Finger-Geschwindigkeit. In den letzten 2 Wochen habe ich allerdings schon mehrfach bemerkt, wie das Muskelgedächtnis mehr und mehr die Steuerung übernimmt. Häufig bennutzte Buchstabenfolgen tippen meine Finger mittlerweile selbstständig, noch bevor mein Kopf dazu kommt, sie in einzelne Buchstaben zu zerlegen. Da wird sich im nächsten Jahr bestimmt noch viel tun.

Der befürchtete Effekt, dass ich das Standard QWERTZ-Layout verlerne, ist ausgeblieben. Ich muss mich zwar immer erst 1-2 Minuten eingewöhnen, aber dann ist alles wieder da. In QWERTZ kann ich sowieso nicht blind schreiben und möchte es mir dort auch nicht angewöhnen. Ich bin aber immer noch schnell genug, um z.B. diesen Blogeintrag auf QWERTZ zu schreiben, weil er auf meinem alten Laptop unterwegs entstanden ist.

Die Tastaturen fühlen sich so deutlich unterschiedlich an (auch weil ich die Standard-Neigung von knapp 20° mit Hilfe eines Keils von Thingiverse auf knapp 30° Neigung gebracht habe), dass mein Kopf automatisch umschaltet.

Alles in allem wundere ich mich mittlerweile darüber, wie einfach Tastschreiben ist, wenn nur die Umgebung dafür stimmt, und warum immer noch ein System gelehrt wird, und verbreitet ist, das auf Geräte optimiert ist, die es mittlerweile nur noch auf Flohmärkten zu Ramschpreisen zu finden gibt.

Austauschen einer defekten PGP Karte durch das Backup

Andy Drop — Fri, 02 Dec 2022 15:00:00 GMT

Ich hatte es geschafft, die PGP-Karte zu ruinieren, auf der sich der PGP-Key befindet den ich zum Lesen meiner eMails und zum Entschlüsseln meines Passwort-Stores benötige. Ein Backup besaß ich, in Form eines zweiten Hardware Schlüssels. Nun, leider stellte es sich als nicht so einfach heraus, diesen auszutauschen.

ich hätte natürlich die Sicherungskopien des Schlüssels, die ich mir beim Erstellen auf der Festplatte abgelegt hatte, einfach wieder auf den alten Key zurückspielen können, aber ich dachte mir: "Was wäre, wenn ich diesen Schlüssel komplett verloren hätte? Probier doch einmal aus, komplett auf den Reserve-Schlüssel zu wechseln".

Während es dutzende Anleitungen gibt, wie man einen Schlüssel von der Festplatte auf seinen Hardwaretoken spielt, wird es hier sehr dünn. Ich musste mehrere Stunden googeln, um da zu einer Lösung zu finden. Daher habe ich die hier einmal zusammengeschrieben, auch weil ich sie in Zukunft vieleicht selber wieder benötigen könnte.

Das Problem

Ich schaue mir den privaten Schlüssel an meinem Schlüsselbund an:

$ gpg  --list-secret-keys

gpg: verwende Vertrauensmodell pgp
/home/andy//.gnupg/pubring.kbx
-----------------------------
.
.
.

sec>  rsa4096 2021-04-19 [SC]
      3E572D5964195D5FEABC3284405D44C9EE5427D5
      Kartenseriennr. = 0006 15889829
uid        [ ultimativ ] Andy Drop (internal use only) 
ssb>  rsa4096 2021-04-19 [A]
ssb>  rsa4096 2021-04-19 [E]

Die '>' Zeichen hinter sec und ssb sagen mir, das sich in meinem Schlüsselbund nur sogenannte Stubs befinden, also nur Platzhalter, und sich die eigentlichen Schlüssel auf einer Hardware-Karte befinden. Welche Karte das ist steht in der dritten Zeile:

Kartenseriennr. = 0006 15889829

Wann immer ich also etwas mit diesem Schlüssel entschlüsseln möchte, fordert gnupg mich auf, genau diese Karte einzustecken. Keine andere Karte wird akzeptiert, auch nicht, wenn sie ebenfalls die passenden Schlüssel enthält.

Nun habe ich aber diese Karte verloren, und möchte gnupg beibringen meine Backupkarte zu akzeptieren.

Die Lösung

Alte Karte entfernen

Zunächst brauche ich dazu die sogenannten Keygrips der betroffenen Schlüssel

andy@drops:~$ gpg --edit-key 3E572D5964195D5FEABC3284405D44C9EE5427D5
gpg (GnuPG) 2.2.27; Copyright (C) 2021 Free Software Foundation, Inc.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.

Geheimer Schlüssel ist vorhanden.

sec  rsa4096/405D44C9EE5427D5
     erzeugt: 2021-04-19  verfällt: niemals     Nutzung: SC  
     Kartennummer:0006 15889829
     Vertrauen: ultimativ     Gültigkeit: ultimativ
ssb  rsa4096/9CE3093DEDB0EFA7
     erzeugt: 2021-04-19  verfällt: niemals     Nutzung: A   
     Kartennummer:0006 15889829
ssb  rsa4096/BFB3A95BEE2789E0
     erzeugt: 2021-04-19  verfällt: niemals     Nutzung: E   
     Kartennummer:0006 15889829
[ ultimativ ] (1). Andy Drop (internal use only) 

gpg> grip
pub   rsa4096/405D44C9EE5427D5 2021-04-19 [SC]
      Keygrip: 952111DC39E0687E154045F1B54BA5BFC6242DBC
sub   rsa4096/9CE3093DEDB0EFA7 2021-04-19 [A]
      Keygrip: 95B287025E371F29E4FD871A87558B1680B99130
sub   rsa4096/BFB3A95BEE2789E0 2021-04-19 [E]
      Keygrip: F0F87AFE74FEF37BA47A414979685B063D319EC2

gpg>

Diese Keygrips finde ich als Dateien im Verzeichnis ~/.gnupg/private-keys-v1.d wieder

/home/andy/.gnupg/private-keys-v1.d:
insgesamt 64K
-rw------- 1 andy andy 1,2K 30. Nov 15:43 952111DC39E0687E154045F1B54BA5BFC6242DBC.key
-rw------- 1 andy andy 1,2K 30. Nov 15:43 95B287025E371F29E4FD871A87558B1680B99130.key
-rw------- 1 andy andy 1,2K 30. Nov 16:04 F0F87AFE74FEF37BA47A414979685B063D319EC2.key

In diesen Dateien ist der Verweis auf meine Schlüsselkarte hinterlegt. Da die Karte weg ist, müssen die Dateien nun auch gelöscht werden, Danach verlangt gnupg nicht mehr nach der alten Karte, weiss aber auch mit der Backup-Karte noch nichts anzufangen

Neue Karte verknüpfen

Dies ist dann wiederum sehr einfach. Ich stoppe zunächst den gpg-agent, da der mir sonst mit seinen gecachten Informationen das Leben zur Hölle macht.

gpgconf --kill gpg-agent

Danach stecke ich die neue Karte ein, und mache gnupg mit der neuen Karte bekannt

gpg --card-status

Danach hat gnupg neue Dateien für die Keygrips der neuen Karte angelegt, und nach einem herzhaften Neustart der User-Session verlangt er ab nun nach der Backup-Karte

Ziel erreicht!

Mein Tastaturlayout

Andy Drop — Sun, 27 Nov 2022 07:00:00 GMT

Die Vorteile sind:

Dadurch, dass die Tastatur in 2 Hälften geteilt ist, kann ich mir die beiden Seiten passend zu meinem Schulterabstand hinstellen, und habe eine entspanntere Sitzhaltung
Jede Hälfte ist nach außen geneigt, dadurch ist auch jeder Arm nicht mehr so in sich gedreht, wie an einer "normalen" Tastatur
Die einzelnen Tasten sind in Spalten angeordnet, bei denen der Finger nur auf und ab greifen muss, und sich dabei nicht noch zur Seite bewegt, wenn es nicht nötig ist. Das kommt mir beim Schreiben besonders entgegen, weil mein Hirn anscheinend in Tabellen und Bäumen denkt. Meine Hirnzellen scheinen rechtwinklig zueinander angeordnet zu sein. Mit den versetzten Tasten bin ich beim Versuch, Tastschreiben zu lernen, nicht wirklich klargekommen. Der Versatz zwischen den Tasten kommt ja daher, die Typenhebel bei mechanischen Schreibmaschinen zu bedienen, und ist eigentlich schon seit der Zeit der Kugelkopf- oder Typenrad-Schreibmaschinen überflüssig.
Dafür sind die einzelnen Spalten in der Höhe gegeneinander versetzt, um dem Umstand Rechnung zu tragen, dass die einzelnen Finger auch verschieden lang sind.

Der leider wichtige Nachteil:

Die Tastatur zwingt einen dazu, mit zehn Fingern zu schreiben, was ich zu diesem Zeitpunkt leider nicht beherrscht hatte.

Ein riesiger Vorteil ist, dass die Tastatur vollständig frei programmierbar ist, in mehreren Ebenen und unterscheidbar in kurzen, langen, doppelten und gehaltenen Tasten.

Das Layout

Und so habe ich mich bei der Belegung auch im Wesentlichen an Neo 2 orientiert.

Layer 0

Wie man sieht habe ich nicht besonders viele Änderungen gegenüber dem normalen Neo-Layout vorgenommen. Die Änderungen sind:

Punkt und Komma haben im Original zwei verschiedene Tasten, aber da ich noch unbedingt Platz für Cursortasten unter der rechten Hand haben wollte, musste der Punkt weichen und ist nun ein kurz gehaltenes Komma.
Die Zahlenreihe oben ist für mich ohnehin schwer erreichbar, und daher für die vielen Zahlen, die ich ständig tippe, unpraktisch. Ich habe sie also dort komplett entfallen lassen, und in einen Zehnerblock in Ebene 3 verschoben. Stattdessen gibt es in der oberen Reihe nun 20 Funktionstasten F1-F20. Die ersten 10 durch normales Tippen. Durch kurzes Halten wird aus F2 dann F12 etc..
Die Tasten, um in die anderen Ebenen umzuschalten, sind allesamt auf die unteren Daumentasten gewandert. Dort sind sie besonders einfach zu erreichen.
Für die Shift-Taste, die normalerweise vom schwachen kleinen Finger gehalten wird, habe ich diverse Stellen ausprobiert. Bewährt hat sich am Ende, die Leertaste - wenn sie gehalten wird - als Shift-Taste zu verwenden.
sämtliche Sonderzeichen sind beim Neo Layout normalerweise im 2. Layer vergraben, aber da ich den Bindestrich im normalen Schreibfluss immer mal wieder brauche, habe ich mir den auf das gehaltene "j" gelegt.

Layer 1

]]

Die blöde obere Reihe ist nur mit sehr selten benutzten Währungs- und Akzentzeichen belegt.

Zufällig ergaben sich die Eselsbrücken:

N - normale Klammern
R - rechteckige Klammern
H - HTML Klammern
G - geschweifte Klammern

Außerdem bilden sie ein hübsches Quadrat

Rechts daneben liegt ein weiteres Quadrat, das ich beruflich benötige, weil ich viele Oracle-SQL-Abfragen schreibe.

Es enthält die einfachen Anführungsstriche, um Strings zu begrenzen, das Semikolon, um Statements zu beenden, das Prozentzeichen, für Wildcards und das Gleichheitszeichen für viele Vergleiche.

Wenn ich die beiden stärksten Finger nach unten bewege finden sich dort alle Zeichen, die ich auf der Kommandozeile benötige, um Pfade einzugeben ( ~ / . ) schön einfach zu erreichen.

Die seltener benötigten Zeichen sind hübsch in die verbleibenden Lücken gestreut.

Layer 2

Fazit

Einsparpotentiale ermitteln (Gas)

Andy Drop — Thu, 29 Sep 2022 15:00:00 GMT

Nachdem ich in der letzten Folge von Operation Wintermute mit dem Energiemessgerät von Steckdose zu Steckdose gelaufen bin, um herauszufinden wo ich Energie sparen kann, war das beim Gas doch deutlich entspannter. Ich habe nur eine handvoll Warmwasser-Zapfstellen und eine Heizung. Vor dieser Heizung habe ich dann auch etwa eine Stunde auf einem Stuhl sitzend verbracht, bis ich verstanden habe, wie sie für meinen Modell genau funktioniert. Und da die ganze Wärme nicht für zwei dutzend Geräte sondern nur für mich da ist, menschelt es in diesem Blogeintrag besonders

Auch wenn ich mich beim Strom um deutlich mehr Verbraucher kümmern musste, ist es dort doch viel einfacher jederzeit festzustellen, ob man mit seinem aktuellen Verbrauch gut liegt oder nicht. Das liegt daran dass der Verbrauch über das Jahr weitgehend gleichmäßig ist.

Beim Gas ist das komplett anders. In den Sommermonaten ist die Heizung abgestellt, das heißt das einzige was zu der Zeit verbraucht wird, ist warmes Wasser zum waschen und duschen, Im Winter wird die Dusche weiterhin benutzt, jetzt wird jedoch zusätzlich die Heizung eingeschaltet, und die Heizung verbraucht ein vielfaches der Energie die wir beim duschen benötigen.

Wir können also nicht davon ausgehen dass wir nach einem Drittel des Jahres auch ein Drittel der Energie benötigt haben, und nach zwei Dritteln des Jahres zwei Drittel. Zu Beginn des Frühjahrs haben wir fast die Hälfte der Energie verbraucht, und zu Beginn des Herbstes noch nicht viel mehr da wir im Sommer lediglich geduscht haben.

Um diesem Problem zu begegnen, gibt es etwas das sich Lastprofil nennt. Im Prinzip gibt ein Lastprofil an wieviel Energie ich an welchem Tag im Jahr üblicherweise verbrauche.

Ich bin zunächst ganz naiv davon ausgegangen, dass man so ein Profil einfach so im Internet findet, aber dem war nicht so. Eine entsprechende Frage im Fediverse brachte auch kein Ergebnis. Also habe ich eine halbe Nacht rumgegoogelt und bin schließlich auf die Seite Musterhaushalt.de gestoßen, auf der es die nette Funktion gibt, dass man seinen üblichen Jahresverbrauch eingeben kann und dann eine Tabelle zurückbekommt, wieviel davon man in welchem Monat üblicherweise verbraucht.

Das ganze ist leider nur monatlich aufgelöst. Da ich aber gerne wöchentliche Ergebnisse hätte, hab ich angefangen mir das ganze in eine Excel-Tabelle zu übertragen und aus den Monatswerden Wochenwerte zu machen.

Das ganze sah dann so aus:

Die blauen Balken sind das Modell, und die grünen Balken sind mein tatsächlicher Verbrauch. Wie man sieht liege ich also schon sehr gut und fast permanent unter dem Musterverbrauch. L laut dem Diagramm müsste ich pro Jahr ungefähr 500 kWh sparen. Daraufhin hab ich mal in meine Vorjahresabrechnungen geschaut, und gesehen, dass hier entgegen meiner ursprünglichen Zielsetzung von 10.000 kWh in den letzten Jahren circa 9500 kWh verbraucht habe. Für ein dermaßen grobes Modell passte das Ergebnis also überraschend genau. Für die kommenden Jahre werde ich also doch eher 9000 kWh statt der angenommenen 10.000 kWh ins Auge fassen.

Wie kann ich dieses Ziel nun erreichen?

Der Kessel

Nun, dazu müssen wir uns erstmal ansehen, wie die Wärmeversorgung in meinem Haus so funktioniert.

Ich habe ein Heizkessel, der im Prinzip ein großer isolierter Wasserbehälter ist. Dieser Wasserbehälter ist über Rohre mit den Heizkörpern verbunden und eine Pumpe bewegt das Wasser im Kreis immer vom Heizkessel zur Heizung und zurück. Dabei kühlt sich das Wasser nach und nach ab.

Das Wasser in diesem Kessel hat eine Soll-Temperatur, und die Heizung versucht den Kessel auf dieser Temperatur zu halten. Das tut sie allerdings nicht, indem sie sofort Energie aufwendet wenn sich die Temperatur auch nur ein bisschen abkühlt, sondern der Kessel oszilliert um den eingestellten Sollwert herum. In meinem fall geht es dabei um plus minus fünfzehn Grad. Das heißt wenn mein Heizkessel, so wie ich ihn vorgefunden habe, auf 55 Grad eingestellt ist, dann nun kühlt sich das Wasser nach und nach ab bis 40 Grad erreicht sind. Daraufhin springt die Heizung an und erhitzt das Wasser wieder auf 70 Grad. Dann kühlt sich das Wasser wieder langsam auf 40 Grad ab, und das Spiel beginnt von vorne.

ich habe also ständig Wasser mit einer Temperatur zwischen 40 und 70 Grad im Kessel, Die Mitte stellt genau die Solltemperatur dar.

Es gibt genau 3 Gründe warum die Kessel Temperatur sinkt

ist die Isolierung des Kessels nicht perfekt. Das heißt, die Temperatur im Kessel sinkt nach und nach auf die Raumtemperatur ab. Je wärmer es im Kessel ist. desto schneller sinkt der Wert ab. Wenn die Kesseltemperatur selbst nur knapp über der Raumtemperatur liegt, dann schreitet das Abkühlen langsamer voran.
Ich dreh die Heizkörper auf. Wenn das Wasser zu den Heizkörpern gepumpt wird, wird die Wärme dort, wie ist die Aufgabe eines Heizkörpers ist, an den Raum abgegeben, und abgekühltes Wasser strömt zurück in den Kessel. Dadurch kühlt sich der Kessel natürlich deutlich schneller ab, als durch einfaches rumstehen.
ich benutze Brauchwasser, also ich dusche oder wasche mir die Hände mit warmem Wasser. Die Wasserleitung, die mir das Brauchwasser im Haus liefert, läuft nämlich auch durch den Kessel. In meinem Kopf ist sie dort eine lange schmale Leitung die in vielen Windungen durch den Kessel geht und vom umgebenden Warmwasser erwärmt wird. Das reicht mir als Modellannahme. Wenn ich nun den Wasserhahn aufdrehe, strömt kaltes Wasser vom Hauptanschluss nach, und kühlt damit auch den Kessel ab.

Es gibt also keinen unmittelbaren Zusammenhang zwischen der Energie die ich beim Duschen verbrauche, und der Energie die meine Heizung verbraucht. Es kann sein, dass ich nur kurz dusche, und sich die Kessel Temperatur dabei lediglich von siebzig auf fünfundsechzig Grad absenkt. Da die Marke von 40 Grad noch nicht erreicht ist, springt die Heizung nicht an, und es wird auch kein Gas verbraucht. Im Gegensatz dazu kann es auch sein, dass ich überhaupt nichts vom Wasser verbrauche, nun aber der Kessel durch einfaches rumstehen von 43 auf 40 Grad abgekühlt. Nun springt natürlich die Heizung an, und heizt den Kessel wieder auf 70 Grad auf, ohne dass ich in diesem Moment wirklich Energie verbraucht habe.

Die Menge die ein Aaufheizvorgang an Energie benötigt ist dabei weitgehend gleich. Es kommt also im wesentlichen darauf an wie häufig der Kessel aufheizen muss. Je mehr Energie ich verbrauche, desto öfter muss die Heizung den Kessel aufheizen.

Was habe ich also für Handlungsoptionen?

Beim Duschen

Als erstes habe ich mir mal das Bedienungshandbuch unserer Heizung vorgenommen, denn kein Mensch braucht 70 Grad heißes Wasser, und selbst 40 Grad sind zum duschen noch sehr großzügig bemessen. Ich habe beschlossen dass mir als Solltemperatur 45 Grad reichen, das heißt der Kessel oszilliert zwischen 30 und 60 Grad. 30 Grad sind zum duschen zwar recht wenig, aber dafür liege ich im mittel bei 45 Grad, und sollte ich wirklichen nah an der 30 Grad Grenze sein, dann sorgt der Temperaturabfall durch das Duschen sehr schnell dafür, dass der Kessel neu aufgeheizt. Ich habe das ganze jetzt eine Woche ausprobiert, und komme mit dieser Temperatureinstellung auch beim Duschen hervorragend und ohne Komfortverlust klar.

Dann kann ich beim Duschen noch dafür sorgen, dass ich dem Kessel möglichst wenig abkühle. Das geht zum einen dadurch, dass ich möglichst kurz dusche, das heißt beim einseifen zum Beispiel das Wasser abstelle, und zum anderen, wenn das Wasser eingeschaltet ist, möglichst wenig davon verbrauche. Das kann man zum Beispiel dadurch erreichen, dass man einen Durchflussminderer in seinen Schlauch einsetzt, im Prinzip eine Art kleine Unterlegscheibe, die ein Loch hat, das kleiner ist als der Schlauchdurchmesser.

Und zu guter Letzt gibt es natürlich noch die Option seltener zu duschen. Wenn ich zum Beispiel weiß, dass ich einen Tag HomeOffices vor mir habe, und auch ansonsten das Haus nicht verlassen und anderen Menschen treffen möchte, spricht überhaupt nichts dagegen auch mal das Duschen zu überspringen.

Bei der Heizung

Der effektivste Ansatz ist natürlich auch hier, einfach nicht zu heizen. Da das aber im tiefsten Winter nicht wirklich Sinn macht, geht es hier nicht darum seine Heizung komplett abzustellen. Natürlich kann man das machen, denn beim heizen geht es ja eigentlich darum, mich als Menschen warm zu halten, und nicht die Räume in meinem Haus. Ich könnte also im Extremfall komplett auf die Heizung meines Hauses verzichten, und einfach nur mich warm halten, indem ich warme Kleidung trage, oder direkt -zum Beispiel durch eine Wärmflasche- meinem Körper heize. Wer einen interessanten Artikel dazu lesen möchte, dem sei dieser Artikel im LOW-TECH MAGAZINE empfohlen.

Soweit möchte ich nicht gehen, aber es ist überhaupt kein Problem, erst etwas später mit dem heizen anzufangen, oder, wenn es Frühling wird, schon etwas früher damit aufzuhören, und sich mit einer schönen warmen Decke aufs Sofa zu setzen.

Räume in denen ich mich kaum, oder gar nicht, aufhalte, muss ich auch überhaupt nicht heizen,

In der Küche mache ich es zum Beispiel so, dass ich die Abwärme des Herdes und des Ofens nutze. Das reicht mir da an Wärme in der Küche, und ich brauche die Heizung dort gar nicht, obwohl ich mich dort öfters aufhalte.

Im Arbeitszimmer machen der Computer oder der Laptops eine Menge Abwärme, so dass mir dort eine kleine Kerze ausreicht um ebenfalls auf eine angenehme Arbeitstemperatur zu kommen, solange ich die Tür dort geschlossen halte.

Im Schlafzimmer mochte ich es früher immer ungewöhnlich warm, da ich Problem mit meinen Nebenhöhlen bekomme, wenn diese nachts sehr auskühlen. Dieses Problem habe ich mittlerweile dadurch gelöst, dass ich wärmere Bettwäsche für den Winter habe, und man glaubt es oder nicht, Opas gute alte Nachtmütze wirkt Wunder gegen verkühlte Nebenhöhlen.

Ich wurde geNerdSniped

Für mein relativ grob aufgelöstes Lastprofil habe ich übrigens in der Zwischenzeit eine sehr viel bessere Lösung gefunden. Ich bin auf TUM und SigLinDe gestoßen, die beiden Modelle mit denen die Energiewirtschaft in Deutschland tatsächlich arbeitet, und es gibt sogar ein Dokument darüber, dass leider 166 Seiten umfasst, wie diese Modelle im Detail arbeiten. Nachdem ich nun einige Stunden darüber gebrütet habe, glaube ich, dass ich die Modelle komplett verstanden habe, was ich nachher mal überprüfen werde, indem ich sie in eine Excel-tabelle überführe. In diese Modelle stecke ich die Tagesmitteltemperaturen eines Jahres und erhalte dann eine Prognose für den tagesgenauen Energieverbrauch für mein Gas.

Mit diesem Modell werde ich definitiv noch sehr intensiv rumspielen, und nachdem der nächste Blogeintrag aus der reihe Wintermute nun um das Benzin gehen soll, würde ich sagen geht der übernächste um SigLinDe.

Einsparpotentiale ermitteln (Strom)

Andy Drop — Tue, 20 Sep 2022 11:00:00 GMT

In der letzten Folge von Operation Wintermute hatte ich ja versucht, ein Ziel festzulegen um das Energiesparen ein bisschen zu gamifizieren. es geht nun also um 2.000 kWh Stromverbrauch, 10.000 kWh Gasverbrauch und unter 150 Euro pro Monat für Benzin als Zielmarke. Um herauszufinden wo ich zum Beispiel Strom sparen kann bin ich die letzten 24 Stunden durchs Haus gelaufen und habe den Verbrauch aller möglichen elektrischen Geräte nachgemessen, und habe dabei ein paar nette Stellen zum sparen gefunden,

Nachdem ich mir eine Tabelle erstellt hatte, in der ich alle Räume, und dann alle darin befindlichen elektrischen Verbraucher eingetragen habe, bin ich losgezogen. Bereits im Wohnzimmer erwarteten mich die ersten Überraschungen. In der Lampe über der Couch hatte ich eigentlich Energiesparbirnen erwartet bei näherer Betrachtung fanden sich dort allerdings Halogenbirnchen vier Stück zu je 20 Watt. Also verbraucht diese Lampe um die achtzig Watt. Und sie ist, wenn ich auf dem Sofa sitze, die Lampe die am häufigsten und längsten benutzt wird im Raum.

Raum	Verbraucher	Strom	Bemerkung
Wohnzimmer	Lampe Couch	80 Watt	Fuuuuck!
	Lampe Raum	12 Watt
	Lampe Esstisch	11,5 Watt	evtl Kriechstrom
	Stehlampe	11 Watt
	Fernseher	10/90 Watt
	XBox	22/62 Watt
	Lautsprecher	10 Watt

Die zweite Lampe, die über am Esstisch, konnte auch mit einer Überraschung aufwarten. Zwar waren hier bereits Energiesparbirnchen verbaut, aber im Dunkeln konnte ich feststellen, dass diese auch bei abgeschalteter Lampe ganz sachte vor sich hin glimmen. Lustigerweise lässt sich die Helligkeit des Glimmens dadurch verändern dass ich die Stehlampe ein- und ausschalte. Es sieht also so aus, als wenn in der Verteilerdose irgendwie Strom vom Anschluss der Stehlampe zur Lampe überm Esstisch fließt. Mal schauen wie viel das ist, oder ob ich das abschalten kann.

Bei den AV-Komponeten also Fernseher und die Boxen hat mich nicht wirklich überrascht dass sie Stand-By Strom ziehen, allerdings war ich über die Höhe überrascht. Der Fernseher tut sich im Standbybetrieb 10 Watt weg, die XBox habe ich mit 22 Watt gemessen und die Lautsprecher haben zwar im abgeschalteten Zustand keinen Stromverbrauch, jedoch sind sie ständig eingeschaltet damit ich nur den Fernseher einschalten muss, und direkt Ton habe. Alles zusammen waren das schicke 42 Watt die 24 Stunden am Tag verbraucht werden. Das Telefon, das daneben auf dem Tisch stand, spielte dagegen überhaupt keine Rolle. Sein Stromverbrauch liegt unter einem Watt, war allerdings der Grund warum ich bisher davon abgesehen habe, einen Schalter dort einzubauen, da das Telefon ja ständig geladen werden muss, und nicht vom Strom genommen werden kann.

Nach kurzem Nachdenken habe ich aber festgestellt, dass, seit meine Tochter aus dem Haus ist, ich mich sowieso am meisten in meinem Arbeitszimmer aufhalte, und das Telefon dort unten eigentlich nutzlos ist. Ich könnte es viel besser oben im Arbeitszimmer gebrauchen. Also habe ich das Telefon nach oben befördert, und alle Audio-Video Geräte zusammen an einer Mehrfachsteckdose mit einem Schalter angeschlossen. Damit wurden aus 42 Watt Dauerleistung 0 Watt.

ich gehe Moment davon aus, dass beim zukünftigen Strompreis 1 Watt Dauerverbrauch circa 6 Euro pro Jahr kosten wird. Hier ließen sich also bereits 240.- Euro einsparen

Raum	Verbraucher	Strom	Bemerkung
Küche	Lampe Tisch	20 Watt
	Lampe Raum	19,5 Watt
	Lampe Arbeitsfläche
	Herd
	Abzugshaube
	Kühlschrank
	Geschirrspüler	7/ Watt
	Wasserkocher	7/1850 Watt	0,05 kWh pro Kaffee. Oh. Standby
	Mikrowelle	800 Watt

In der Küche entpuppte sich dann die Lampe über dem Esstisch zwar als Energiesparlampe, aber eine aus der allerersten Generationen. Ihr erinnert euch bestimmt noch daran, dass Energiesparlampen damals eine Weile brauchten, bis sie die volle Helligkeit erreicht haben. Und für den Spaß tut sich das Exemplar über meinem Esstisch in der Küche auch noch 20 Watt rein. Die Putzbeleuchtung im Raum ist dagegen mit 19,5 Watt deutlich heller, und wird auch nur selten gebraucht. Die lappen über der Arbeitsfläche sind kleine Halogenstrahler, die ich bisher noch nicht ausgebaut bekommen habe, aber ich vermute, dass dort dreimal circa 15 Watt verbaut sind.

Geschirrspüler und Wasserkocher haben mich durch ihren Standby Strom überrascht. Sie nehmen jeweils 7 Watt, sodass dort 14 Watt mal 6 Euro, also 84 Euro pro Jahr den Kamin rausgehen, Die Mikrowelle die sogar ein hintergrundbeleuchtetes Display hat, hält sich dabei mit einem Standbyverbrauch von unter einem Watt nett zurück.

Raum	Verbraucher	Strom	Bemerkung
Hauswirtschaft	Waschmaschine	16/425 Watt	0,75 kWh pro Ladung. Oh. Standby
	Trockner	10/300 Watt	0,78 kWh pro Ladung. Oh. Standby
	Gefrierschrank	18.5 Watt
	Router	10 Watt
	Heizung	10 Watt
	Lampe Raum	–58– Watt
	Raspi Home Assistant	2.5 Watt

Im Hauswirtschaftsraum stehen erwartungsgemäß die Großverbraucher des Hauses. Waschmaschine, Trockner und Gefrierschrank. Letzteren habe ich noch nicht gemessen da ich dazu hinter den Schränken rumkrabbeln müsste, aber es handelt sich dabei um einen modernen Gefrierschrank mit brauchbaren Verbrauchswerten. Auch Waschmaschine und Trockner haben ansprechende Werte, wenn sie eingeschaltet sind. Erstaunt war ich hier über 26 Watt, die sich Waschmaschine und Trockner reintun, wenn sie nicht eingeschaltet sind. Hier war also der erste Einsatzort für meine Wunderwaffe: Schaltbare Steckdosen. Die sollten mich pro Jahr circa 150 Euro sparen, bei nur vier Euro Anschaffungskosten pro Stück

Raum	Verbraucher	Strom	Bemerkung
WC	Lampe Raum	5 Watt

Die Lampe im Gäste WC ist gut dimensioniert und wird sowieso nur sehr selten gebraucht.

Raum	Verbraucher	Strom	Bemerkung
Flur	Lampe unten	9,5 Watt
	Lampe oben	3,6 Watt

Im Flur ist alles im grünen Bereich.

Raum	Verbraucher	Strom
Arbeitszimmer	Lampe Raum	15 Watt
	Schreibtischlampe	6 Watt
	Computer	7/35 Watt
	Laptop	11/40 Watt
	Monitor	5/23 Watt
	Moodlight
	Mischpult	10 Watt
	Globus	20 Watt
	Video Licht	1-2 Watt
	Drucker	8/30 Watt
	3D-Drucker	0/X Watt
	Laderegal	6/X Watt
	Telefon	<1 Watt

Im Arbeitszimmer geht es im wesentlichen um Verhaltensänderung. Die Geräte haben alle ungefähr die Werte, die ich erwartet hatte. Ich hab mir leider im Laufe der letzten Jahre angewöhnt, dass mein Rechner, und oft auch der Firmenrechner permanent eingeschaltet sind. Zusammen mit dem Standby vom Drucker sind das quasi permanente 70-80 Watt. Das sind pro Jahr dann knapp 500 Euro.

Hier wird es also in Zukunft darum gehen die Geräte nach Gebrauch wirklich abzuschalten, und damit auch die Standby-Last verschwindet, sie alle an eine schaltbare Steckdose zu hängen. Positiv überrascht hat mich das Videolicht, dass ich für Livestreams nutze. Obwohl meine Schreibtischlampe nur 6 Watt hat, verbraucht das Videolicht mit seinen zwei sehr hellen Scheinwerfern im Normalfall nicht einmal die Hälfte der Schreibtischlampe, und erreicht sie so eben, wenn ich die Leistung voll aufdrehe. Dann werde ich allerdings blind.

Raum	Verbraucher	Strom
Schlafzimmer	Lampe Raum	10,5 Watt
	Lampe Bett	7 Watt
	Wecker	2 Watt

Im Schlafzimmer ist alles im grünen Bereich.

Raum	Verbraucher	Strom	Bemerkung
Kinderzimmer	Lampe Raum	5,3 Watt	unbewohnt

Das Kinderzimmer ist aktuell unbewohnt, unbeheizt und unbeleuchtet.

Raum	Verbraucher	Strom
Bad	Lampe Raum
	Lampe Spiegel	3.5 Watt
	Rasierer	<1 Watt
	Zahnstation	<1 Watt
	Föhn	800 Watt

Die Deckenlampe im Bad habe ich mir noch nicht genauer angeguckt, da das Glas der Lampe dort gesprungen ist, und ich mich nicht traue sie von der Decke zu nehmen, weil ich nicht weiß ob ich sie wieder aufgehängt bekomme. Ich weiß allerdings, dass sich darin eine Energiesparbirne befindet die eher knapp bemessen ist, und gerade genug Licht macht. Spiegel, Lampe, Rasierer und die Zahnstation verbrauchen vorbildlich wenig Strom. Lediglich der Föhn mit seinen 800 Watt wäre zu nennen, aber mit meinen spärlichen Haaren brauche ich den nicht, und er ist überhaupt nur dort falls ich Bersuch mit längeren Haaren habe.

Raum	Verbraucher	Strom	Bemerkung
Garten	Rasenmäher
	Wasserpumpe
	Trimmer
	Springbrunnen
	Schuppenbeleuchtung
	Aussenbeleuchtung
	Kriechstrom?

Den Strom im Garten konnte ich bisher noch nicht genau ermitteln, da ich den Garten bereits winterfest gemacht habe. Das werde ich mir dann also im nächsten Frühjahr vornehmen

Insgesamt freue ich mich dass ich mir so ein Einsparpotenzial von etwa 800 Euro erschließen kann. Endgültig reich werde ich dann, wenn mir jeder einen Euro zahlt, der mir nun erklären möchte dass meine Glühbirnen eigentlich Leuchtmittel heißen.

Im nächsten Beitrag nehme ich mir dann das Gas vor.

Operation Wintermute

Andy Drop — Mon, 19 Sep 2022 07:00:00 GMT

in den Nachrichten ist es aktuell überall Thema: Die steigenden Kosten für Gas und Strom und andere Energieträger. Dabei hatte ich bisher sogar noch Glück. Ich hatte relativ langfristige Verträge, die erst in den kommenden Wochen auslaufen. Im Moment treffen bei mir die ersten Briefe ein, die mich darauf vorbereiten sollen. Also bereite ich mich darauf vor, indem ich schaue wo ich in diesem Winter Energie sparen kann.

Da die Verbrauchswerte messbar sind, bietet es sich an, das ganze zu gameifizieren. Das erhöht die Motivation, und wenn es da noch einen coolen Projektnamen wie "Operation Wintermute" kriegt, hoffe ich, dass ich dran bleibe. Die Chancen stehen gut, da ich ja auch in den vergangenen Jahren schon regelmäßig meine Zählerstände abgelesen habe, und immer wieder beim Verbrauch nachgesteuert.

Der IST-Zustand

Ich lebe in einem kleinen Einfamilienhaus mit 117qm Wohnfläche. Bis Herbst letzten Jahres wohnten wir hier noch zu zweit doch seit meine Tochter zum studieren weggezogen ist, habe ich das Haus für mich alleine. Mein Arbeitsplatz und meine Freundin sind beide in der selben, etwa fünfzig Kilometer entfernten Stadt, welche leider nicht vernünftig mit öffentlichen Verkehrsmitteln an meinen Wohnort angebunden ist.

Strom

Beim Strom habe ich aktuell einem Grundpreis von 11 Euro im Monat und einen Verbrauchspreis pro Kilowattstunde von 29,91 Cent. Das bedeutet, ich habe aktuell noch keine Putin Erhöhung erhalten

Der Verbrauch hat sich in den letzten Jahren so enwickelt:

Jahr	kWh
2018	2381
2019	2390
2020	2731
2021	2788
2022	ca 2400

Die Zahl für 2022 kann ich bisher nur schätzen, da die Abrechnung etwa Mitte Dezember erfolgen wird. Da mein Verbrauch über das Jahr allerdings weitgehend linear erfolgt habe ich ihn anhand der bisherigen Zählerablesung extrapoliert. Die knapp 400 Kilowattstunden mehr die in den Jahren 2020/21 in der Liste stehen schiebe ich auf das Homeoffice. Ich habe seither hier natürlich öfter die Beleuchtung im Arbeitszimmer laufen, und auch der Laptop trägt seinen Teil dazu bei. Damit läge ich für das Jahr 2022 bei 850 € Gesamtkosten, und einem Abschlag von etwa 71 €.

Gas

Beim Gas habe ich aktuell einem Grundpreis von 4,33 € im Monat und einen Verbrauchspreis pro Kilowattstunde von 6,3 Cent. Ab dem 1. November kommen die Gasbeschaffungs- und die Gasspeicher-Umlage dazu, sodass mein Verbrauchspreis auf 10,2 Cent/kWh steigt. Die gestiegenen Beschaffungskosten hat mein Versorger bisher noch nicht weitergegeben. Ich denke er wird damit bis kurz vor Ende meines derzeitigen Vertrages warten, um einen möglichst genauen Stand weitergeben zu können.

Der Verbrauch hat sich in den letzten Jahren so enwickelt:

Jahr	kWh
2018	9840
2019	10689
2020	12723
2021	10447
2022	noch keine Schätzung

Die Zahl für 2022 kann ich bisher noch nicht schätzen, da mein Verbrauch über das Jahr leider nicht linear erfolgt. Die Aufstellung einer entsprechend gewichteten Verbrauchskurve ist einer der nächsten Schritte die ich vorhabe. Bei einem Verbrauch vergleichbar zum Vorjahr, läge ich für das Jahr 2022 bei 775 € Gesamtkosten, und einem Abschlag von etwa 65 €.

Durch die Verbrauchspreiserhöhung für die letzten beiden Monate des Jahres, werde ich vermutlich eine Nachzahlung haben. Da ich aber im letzten Jahr eine kleine Rückzahlung hatte und schon abzusehen war, dass sich die Preise erhöhen werden, habe ich diese Rückzahlung in meinem Gas-Budget belassen, Ich gehe davon aus, dass diese Rückzahlung die Nachzahlung etwa ausgleicht.

Benzin

Den Benzinverbrauch für mein Auto beobachte ich derzeit von allen Verbräuchen am ungenauesten. Was ich weiß, ist, dass mein Auto im Mischbetrieb mit einer Strecke die etwa zur Hälfte aus Autobahn besteht circa 4,2 l/100km verbraucht, wenn ich es extrem sparsam fahre ich etwa auf 3,8 l/100km komme. Im Moment mache ich es so, dass ich ein Benzin Budget von 180€ im Monat habe, von dem am Ende des Monats immer noch etwas übrig ist. Das übrige Geld buche ich derzeit auf das Budget für Wartung und Reparaturen um. Ich tanke also für weniger als 180€ im Monat. Ich würde schätzen dass es aktuell etwa 130€-140€ sind. In der nächsten Zeit werde ich vermutlich einmal pro Woche zur Arbeit und zweimal pro Woche zu meiner Freundin fahren. Es besteht allerdings die Möglichkeit die Fahrt zur Arbeit mit einer Fahrt zu meiner Freundin zu kombinieren, da beide im gleichen Ort sind.

Der SOLL-Zustand

Schön wäre es, wenn ich durch die Energieeinsparungen so viel Geld einsparen könnte, dass sich die Preiserhöhung damit auffangen ließe, davon gehe ich allerdings noch nicht wirklich aus. Beim Strom würde ich es gerne schaffen auf 2000 kWh zu kommen beim Gas etwa 10.000 kWh und beim Auto wäre ich gerne mittelfristig bei 150€ im Monat für Benzin.

Browser Lesezeichen in Org-Mode speichern

Andy Drop — Tue, 02 Nov 2021 02:00:00 GMT

Das Problem begann eigentlich schon vor knapp 30 Jahren. Es war sehr einfach im Browser ein Lesezeichen zu einer Seite zu speichern, und genau so einfach war es auch die Seiten danach wieder damit aufzurufen. So sammelten sich im Laufe der Zeit mehr und mehr Lesezeichen an, und wenn dann eine neue Version des Browsers erschien, war es eine mühsame Arbeit die Datei mit den Lesezeichen in das passende Verzeichnis des neuen Browsers zu kopieren.

Immerhin hatten die Hersteller schnell begriffen, dass dies ein Problem war, und boten bald dann eine Möglichkeit an die Lesezeichen automatisiert von einer Vorgängerversion zu übernehmen. Nun arbeiten Menschen aber durchaus mit mehr als einem Browser, und es wurde immer klarer, das es sehr praktisch ist wenn man sowohl auf dem Rechner zu Hause, als auch auf dem Laptop, oder dem Firmen-Rechner die gleichen Lesezeichen zur Verfügung hat.

Damit begann zu erst die Zeit der Online- Lesezeichen Speicherdienste, die über ein Browser-Plugin die Favoriten in ihre Verzeichnisse aufnahmen, später bauten auch alle großen Browserhersteller eine Funktion ein um die Lesezeichen zwischen verschiedenen Browsern zu synchronisieren, was wiederum den Niedergang der Online-Speicherdienste einläutete.

Ich habe damals auch so einen Dienst benutzt, auch weil es praktisch war, seine eigenen Lesezeichen für andere Personen freizugeben. Dennoch sind mir immer wieder Lesezeichen abhanden gekommen, wenn mal das Plugin nicht richtig funktionierte, und Unmengen von Dubletten waren an der Tagesordnung.

So kam es, das ich mich entschied meine Lesezeichen ab jetzt an einem zentralen Ort zu sammeln, der unabhängig von Browser und Internet sein sollte. Seit damals, bis heute ist das eine reine Textdatei, und das Format ist auch nur wenig geändert wurden. Ich habe schon immer den Link gespeichert, und zu Anfang einfach noch ein paar Stichworte dazu geschrieben. Seit einigen Jahren bin ich beim jetzigen Format einem Org-Mode Link inklusive dem Seitentitel, plus einem Zeitstempel, wann ich das Lesezeichen erzeugt habe, angekommen.

Dadurch ist das aufrufen von Seiten ein Kinderspiel. Im Org-Mode von Emacs sind Links einfach anklickbar, und rufen das konfigurierte Programm, also am besten einen Browser, auf.

Das Abspeichern der Links war schon immer eine eigene Baustelle und läuft bei mir mittlerweile in der dritten Fassung

Die Emacs Seite

Auf der Empfängerseite, also in Emacs war die Lösung von Anfang an sehr einfach. Hier gibt es einen Mechanismus der sich Org-Capture nennt. Dieser ist eigentlich dazu gedacht, um neben der normalen Arbeit an einem Text mal eben eine Information zu einem Anruf, oder einem Gespräch mit dem Kollegen, der gerade ins Büro kam festzuhalten. Neben dem normalen Fenster geht ein weiteres Fenster auf, in das man seine Notiz eintragen kann, und diese wird dann an einem festgelegten Ort gespeichert. Dabei lassen sich Templates nutzen, die z.B. bereits Datum und Uhrzeit des Eintrags hinzugefügt haben, noch bevor man los tippt.

Passend zu diesem Mechanismus gibt es das Capture-Protocol. Dadurch wird es möglich Emacs von aussen her aufzurufen, und als Aufrufparameter Informationen mitzugeben, die dann in ein solches Template eingetragen werden, und in die entsprechende Datei eingetragen.

Wer dieses Protokoll nutzen möchte stößt allerdings schnell auf zwei Probleme, die sich allerdings beide lösen lassen:

Da es sich um ein neues Protokoll handelt wird dieses vom Betriebssystem behandelt, und muss diesem zunächst mal bekannt gemacht werden. Das bedeutet unter Windows das anlegen von Registry Einträgen, und unter Linux das schreiben (wenn auch sehr kleiner) Konfigurationsdateien. Ohne diese Bekanntgabe passiert absolut nichts. Das Betriebssystem muss wissen, das es jedes mal den Emacsclient aufruft, wenn jemand das org-capture-protocol verwendet.

Die Syntax des Aufrufs hat sich im Verlauf der Emacs Versionen einmal geändert, so das es quasi zwei verschiedene Versionen gibt, wie es richtig funktioniert, und auch wenn mittlerweile wohl nur noch Emacs Versionen mit der neuen Syntax in Gebrauch sein sollten, stammen sehr viele Erklärungen im Internet noch aus der Zeit der alten Syntax, die umständlicher, und dazu noch weniger flexibel war. Leider wird fast nirgendwo darauf hingewiesen, dass es mittlerweile eine neuere, bessere Syntax gibt. Selbst Anleitungen, die die neue Syntax zeigen, erwähnen selten, dass es auch mal eine alte Syntax gab, und so geraten Anfänger schnell in die Falle beide Versionen für die Wahrheit zu halten, und sie munter zu mixen, was dann dazu führt, das es überhaupt nicht mehr funktioniert.

Hat man diese beidem Probleme aber einmal erkannt, lässt sich das ganze schnell korrekt konfigurieren (und so schwer ist das dann auch nicht mehr). Ein Tipp: Die aktuelle Syntax findet sich in der Dokumentation, die man sowohl online, als auch innerhalb von in der Hilfe findet.

Die Browser-Seite

Um in Emacs ein Lesezeichen abzuspeichern reicht also ein Aufruf von

emacsclient "org-protocol://capture?template=L&url=%%TAB-URL%%&title=%%TAB-TITLE%%"

Der Browser muss also einfach nur diesen Aufruf hinbekommen, und der Drops ist gelutscht. Leider ist der Aufruf von ausführbaren Programmen von der Platte des Benutzers auch eine riesige Sicherheitslücke, denn wenn ein Angreifer das von einer Internetseite aus tun kann, kann er auch Schadcode dort ausführen. Entsprechend haten die Browser Hersteller keinen einfachen Weg dafür in ihre Browser eingebaut.

Iteration 1

Mein erster Weg damit umzugehen, war es mir einen anderen Browser zuzulegen. Ich hab mir damals Qutebrowser ausgesucht, weil er eine Funktion bot, jede Funktion des Browsers mit einer Tastenkombination zu verbinden. Dazu war noch eine sehr wichtige Funktion eingebaut, mit der man beliebige Programme aufrufen konnte, und der Browser konnte dazu die URL, den Namen der Seite, oder den markierten Text als Aufrufparameter einsteuern. Der Ansatz war also trivial: einfach Ctrl-D mit dem Aufruf eines kleinen Python-Scripts verbunden, das die URL passend formatiert, und dann den Emacsclient aufruft.

Es war ein Traum. … bis zu Debian 10. Dann stellte sich heraus, dass die Versionen von Python, und die von Debian installierten Qt-Bibliotheken für Python unterschiedliche Abhängigkeiten hatten, die sich widersprachen, kurz es knallte an allen Ecken und Enden, und die Lösung wäre es gewesen eine isolierte Python umgebung zu schaffen, mit gepinten Versionen der einzelnen Pakete, und das wollte ich mir dann doch nicht antun.

Es wurde also Zeit für

Iteration 2

Wenn ich den Qutebrowser sowieso nicht mehr nutzen konnte bin ich also wieder zurück zu einem der Standardbrowser gewechselt - Firefox

Hier gab es also wieder das bekannte Problem, dass Firefox nicht besonders gewillt ist externe Programme aufzurufen, und ich habe ein wenig gegrübelt, wie sich das am besten umgehen lässt, ohne die Sicherheit von Firefox auszuhebeln. Die Lösung lieferte dann meine Freundin quasi frei Haus. Wir unterhielten uns eines Tages darüber, das Ihr Arbeitskollege unter Windows sehr virtuos Standard-eMails schreibt, indem er alle wichtigen Textbausteine in einer Software namens Klavier hat, und auf Knopfdruck abrufen kann, verbunden mit der Frage, ob sie das nicht auch irgendwie installieren kann. Nun, für die Software hatte ihr Kollege wohl eine Lizenz gekauft, und das Geld wollte sie nicht ausgeben, aber ich hab eine Software namens AutoHotKey gefunden, die quasi das gleiche kann, und mit der sie seither arbeitet.

Neugierig geworden wollte ich sehen, ob es so etwas auch für Linux gibt (ich hab es nie gebraucht, da Emacs ein paar eingebaute Wege hat mit Textbausteinen zu arbeiten).

Und ich fand ein Programm namens Autokey, und schon die ersten Beispiele, die ich sah zeigten auch, das es auch mit dem Clipboard umgehen kann, und auch externe Programme aufrufen. BINGO!

Von da an ging es ganz schnell. Ich hab Autokey installiert, und CTRL-D mit einen Script belegt das den Cursor in die URL-Zeile setzt, alles markiert, und die URL ins Clipboard kopiert. Mit dieser URL wurde dann mein altes Python-Script aus Iteration 1 aufgerufen, und Voila, die URL landete wieder in meinem Emacs, und damit in der Link-Datei.

Es waren wieder friedliche Zeiten. So einigermaßen.

Denn leider konnte ich so den Seitentitel nicht übernehmen, und musste im Nachgang nochmal ein Skript über meine Links laufen lassen, welches zu jedem Link den Seitetntitel holte, und den Org-Link entsprechend anpasste. Es funktionierte, aber meine Nerd-Seele litt. Ich wollte EINEN EINZIGEN SCHRITT mit EINEM Tastendruck.

Ich begann also die Suche nach

Iteration 3

Ich hab dann angefangen die Firefox AddOns nach Erweiterungen zu durchsuchen, die es irgendwie doch ermöglichen ein externes Skript aus dem Browser zu starten. Die ersten Ergebnisse trieben mir eine Gänsehaut nach der anderen über den Rücken, viele davon verlangten, einen nicht näher beschriebenen Code aus dem Internet zu laden, bei dem der Autor versprach, das er das Problem löst, aber nicht wie, oder ob damit die Browser Sicherheit ausgehebelt wird. Viele dieser Erweiterungen sind mittlerweile aus den AddOns verschwunden, und ich habe mich auch nie getraut, eine davon zu installieren.

Bis ich auf RunWith stieß. Auch hier muss man zwei weitere Dateien auf seinem System installieren, und eventuell war das auch genau der gleiche Mechanismus, wie die anderen AddOns die ich so ignoriert hatte, allerdings machte der Autor zwei entscheidende Dinge anders, als die Pakete, die mir so dubios erschienen. Er zeigte die beiden Dateien ganz offen, und erklärte ihre Funktion Stück für Stück, so dass ich nachvollziehen konnte, wozu ich diese brauche und er stellte ihre Funktion dar, in einen Framework, das sich Native Messaging nennt, und das die von den Browserherstellern bevorzugte sichere Methode ist externe Programme aus einem Browser aufzurufen, und mit Parametern zu versehen. Also exakt das, wonach ich gesucht habe.

URL, Seitentitel und markierter Text gehören auch hier zu den Standard Parametern, die übergeben werden können, aber darüber hinauch auch Bild-URLs oder die Art der Objekts von wo das Skript aufgerufen wurde, denn im Standard enthalten ist auch, das ich beim Klick nur Scripte angezeigt bekomme, die in der jeweiligen Situation sinnvoll sind. Wenn ich also einfach irgendwo auf der Seite dieses AddOn aufrufe bietet es mir an ein Script für ein Lesezeichen auszuführen. Habe ich hingegen einen Teil der Seite markiert, wird zusätzlich ein Script angeboten, das mir den markierten Text als Zitat speichert, und die URL als Quelle darunter schreibt.

Die zentrale Datei der Native Messaging Host ist hier in Python geschrieben, und damit schon mal auf seinen Inhalt überprüfbar. Darüber hinaus beschreibt der Autor auf der Homepage noch sehr schön wie die Schnittstelle aussieht, die ein Skript zur Verfügung stellen muss, um als NM Host fungieren zu können, und welche Aufgaben die einzelnen Teile des Skripts dabei übernehmen. Das ist nicht nur genug um mein Vertrauen zu gewinnen, sondern geradezu vorbildlich.

Ich hoffe daher, dass Iteration 3 damit die letzte Station auf der Reise zur perfekten Bookmark Lösung für mich war. Dabei bleibt wieder einmal eine Erkenntnis zurück. Obwohl alle 3 Iterationen technologisch vollständig unterschiedliche Ansätze waren, konnten alle perfekt mit einer Textdatei arbeiten, und ich möchte mir nicht ausmalen wie es gelaufen wäre, wenn diese auch noch in einem proprietären Dateiformat abgelegt wären.

Dazu kommt noch, das ich diese Textdatei einfach in HTML exportieren kann, und das Ergebnis ist dann unmittelbar die LINKS Seite dieses Blogs, bei der einfach alle privaten Links nicht exportiert wurden.

Mein Hardware Setup

Andy Drop — Sun, 04 Jul 2021 14:00:00 GMT

Karl Voit bat darum, von den Hardware-Setups anderer Leute zu hören, also beschloss ich, meines ebenfalls mal aufzuschreiben, auch als Erinnerung für mich. Manchmal fragen mich Leute, was ich zu Hause benutze und ich weiß es nicht, weil ich meine Hardware immer dann kaufe, wenn alte Geräte sterben, was selten passiert, und oft genug ist es nur das, was mein lokaler Computerhändler zu dieser Zeit auf Lager hat, falls es gut geeignet ist. Es ist also einigermassen schwierig festzustellen, was sich zu dieser Zeit auf meinem Schreibtisch befindet

Zu Hause

Zu Hause arbeite ich an einem Acer Aspire XC-885 (Intel i3-8100 (4) @ 3.600GHz) mit einer 500 GB SSD für System- und tägliche Arbeitsdateien und einer 1 TB HDD, auf der Debian GNU/Linux Buster mit einem qtile-Desktop-Manager läuft.

Meine Tastatur ist eine WASD-Tastatur V2 mit blauen Cherry MX-Schaltern und einem leicht angepassten US-Layout (sie hat Super-, Hyper- und Meta-Tasten sowie Pinguine auf den Windows Tasten). Wie man anhand dieser Tasten erraten kann, bin ich ein Emacs-Benutzer. Es ist also keine Überraschung, dass mehr Tasten immer besser sind, und ich verwende auch ein Elgato Streamdeck XL für alle möglichen Aufgaben, hauptsächlich für Gimp, Emacs und Blender.

18 Tasten mehr befinden sich auf meiner Maus, einer Lioncast LM30, ach und die Samsung SSD T5 auf dem Bild ist mein alltägliches Backup-Gerät.

Als Monitor habe ich einen Samsung 4K UHD Monitor (3840x2160) gewählt, hauptsächlich weil ich so beim Streamen von Videos nur ein Viertel meines Bildschirms streamen kann und eine exakte HD-Auflösung habe, ohne skalieren zu müssen, und ich drei Viertel meines Monitors für drei verschiedene Szenen im Stream nutzen kann.

Er hat eine recht ungewöhnliche Halterung, wie auf dem Bild zu sehen, da er zu breit ist, um die Türen an meinem Schreibtisch im Sekretärstil zu öffnen, und ich habe mich entschieden, ihn horizontal beweglich zu montieren, um ihn von der gewünschten Tür wegbewegen zu können. Oben drauf sitzt eine Ausdom HD-Webcam.

Mein Sound wird über eine externe Behringer U-Control UCA202 Soundkarte verarbeitet. Daran angeschlossen ist mein Soundequipment und ein alter Radioempfänger als Hauptlautsprecher. Das Soundequipment besteht aus zwei t.bone SC400 Kondensatormikrofonen, einer Boss RC-505 Loop Station, einem VOX Mini 5 Rhythm Gitarrenverstärker für meinen Klampfinator und einem AKAI MPK miniplay als Keyboard, alle über ein Yamaha MG82cx an den Soundkarteneingang angeschlossen Mixer.

Zum Drucken und Scannen von Dokumenten verwende ich einen HP Photosmart Premium m309g.

Mein Hauptrouter ist eine FritzBox, die direkt mit dem Glasfaser-Endpunkt verbunden ist. Sie versorgt uns sowohl mit WLAN als auch dem LAN für den Computer meiner und meiner Tochter sowie für die D-LINK SAN Box, die eine weitere Kopie der Langzeitdaten in unserem Haushalt enthält.

Zum Fotografieren verwende ich mein Fairphone 3 mit e als Betriebssystem. Und dann ist da noch eine Canon DSLR in diesem Haushalt, aber die wird meistens von meiner Tochter verwendet.

Zum Surfen & Lesen auf der Couch nutze ich meistens entweder mein Lenovo Yoga Tablet mit LineageOS oder den Kindle 4 Reader, der nun in den ewigen Flugmodus übergegangen ist, da ich kein Amazon-Konto mehr habe. Also benutze ich ihn, um alle ePubs zu lesen, die ich in meinem lokalen Buchladen kaufe, da ich versuche, nach Möglichkeit papierlos zu lesen. Ich mag ihn für seinen "Nur-Lesegerät"-Ansatz. Keine Hintergrundbeleuchtung, kein Musikplayer, keine Gadgets, viel Akkulaufzeit.

Unterwegs

Wenn ich nicht zu Hause bin, habe ich mein Lenovo ThinkPad L560-Notebook, ebenfalls mit Debian X. Ich versuche, den größten Teil der Konfiguration und des Verzeichnislayouts zwischen diesem und meinem Hauptcomputer identisch zu halten. Beide synchronisieren sich über mein Telefon als zentralen Hub, was den Vorteil hat, dass ich den Laptop nicht einschalten muss, wenn ich nach Hause komme, nur um meine Arbeit wieder mit dem Computer auf meinem Schreibtisch zu synchronisieren. Alle Daten, an denen ich gearbeitet habe, sind bereits mit meinem Telefon synchronisiert, wenn ich weg bin, und das Telefon gibt sie an meinen Hauptcomputer weiter, sobald ich wieder in meinem Heim-WLAN-Bereich bin.

In der Firma

Mein Firmen-Notebook ist ein Dell Latitude 5511 mit 32 GB RAM und 500 GB HDD mit Windows 10, aber die meiste Zeit des Tages verbringe ich in einer virtuellen Windows8 32-Bit-Maschine, da ich mich mit einer ziemlich alten IDE auseinandersetzen darf. Momentan benutze ich es mit einer DREVO Calibur Tastatur, aber das bedeutet, dass ich 4 Tastaturen auf meinem Schreibtisch habe, wenn ich arbeite. Also habe ich beschlossen, Maus und Tastatur in Zukunft über einen KVM-Switch zu teilen.

Die erwähnte 4. Tastatur ist eine ActiveKey UVB/35 POS Tastatur, die einst der Vorgänger meines Streamdecks war. Seitdem benutze ich es für die Arbeitsaufgabe, die ich täglich mache: Debuggen von Visual Basic Code. Es hat alle häufig verwendeten Tastenkombinationen in seinen 35 Tasten codiert, wie Start, Step into, Step Over, Set Breakpoint, Goto Definition usw. Es debuggt sich traumhaft damit.

Emacs mit dem Elgato Streamdeck(r)

Andy Drop — Thu, 27 May 2021 13:00:00 GMT

In seinem Blog-Beitrag A Draft Workflow for Advanced Project Management Using Org Mode and Org Edna schrieb Karl Voit über seinen Traum von einem Workflow, der es ihm ermöglichen würde, ein komplexes Projektmanagement im Org-mode durchzuführen. Wenn du es nicht gelesen hast, tue dies bitte. Wie immer ist es ein toller Text über gut durchdachter Prozesse, und ich kann die meisten hier nicht wiederholen.

Der größte Teil des Arbeitsablaufs wird bereits vom Org mode abgedeckt, und ein weiterer wichtiger Teil der Behandlung von Abhängigkeiten zwischen den Schritten wird vom Paket org-edna geleistet. Um sein Ziel zu erreichen, benötigte er nur zwei Patches für einige von ihm verwendete Emacs-Packeges.

Und so begann meine Reise

Ich habe noch nie einen längeren Code in Emacs Lisp geschrieben, aber ich dachte, "halt' mal meine Teetasse" und fing an. Um fair zu sein, am Ende hat der Code seinen Job gemacht, aber was noch wichtiger war, ich habe einige mal ernsthaft über meinen eigenen Workflow nachgedacht und festgestellt, dass ich Projekte etwas anders als Karl mache.

Das wurde mir klar, als ich an seinem Garagenbeispiel arbeitete (eine Garage neu streichen). Nachdem der Lack gekauft wurde, müssen das Auto, das Fahrrad und die Regale entfernt werden. Um letzteres zu tun, müssen diese erst ausgeräumt werden. Nun entwickelten sich folgende Gedanken:

Beim Durchsuchen des Codes von org-edna, um die Stelle zu finden, an der ich eine Abhängigkeitsbehandlung einfügen konnte, die gruppierte Abhängigkeiten zulässt, stellte ich fest, dass der Beispielworkflow vollständig flach war und dass diese Abhängigkeiten im Org mode behandelt werden konnten wenn ich nur die Hierarchie als Baum verwende
Danach wurde klar, dass ich nie mehr als höchstens drei Aufgaben als nächste Aufgabe planen würde. Mit GTD wäre die reine Lehre, nur eine aktive nächste Aufgabe pro Kontext zu haben, aber in Wirklichkeit verliere ich den Überblick, wenn sie zu viele werden.
Und die Reihenfolge ist mir wichtig. Was ist, wenn ich 5 Minuten brauche, um das Auto zum nächsten öffentlichen Parkplatz zu bringen, und 3 Tage, um die Regale zu leeren und zu entfernen? Ich müsste die ganzen Tage zum Parkplatz gehen, während ich die Garage ausräume. Also würde ich diese Schritte sowieso in der besten Reihenfolge planen.
Wenn es jetzt wieder eine flache Liste ist, aber mit einer bestimmten Reihenfolge, warum nicht die Eigenschaft ORDERED verwenden?

** proj [1/4] Brille richten                    :Brille:project:
         :PROPERTIES:
         :COOKIE_DATA: todo recursive
         :ORDERED: t
         :TRIGGER: next-sibling todo!(NEXT)
         :END:
*** done Zum Optiker fahren
          CLOSED: [2020-08-22 Sa 15:22]
*** NEXT Warten ob es ein neues Mittelteil gibt
*** todo Bestellen 
*** todo Gläser einsetzen

Wenn wir diese Eigenschaft verwenden und auf "t" setzen, wird erzwungen, dass jede Aufgabe nur ausgeführt werden kann, wenn alle vorherigen Aufgaben abgeschlossen sind. Wenn mir dabei etwas in den Weg kommt, möchte ich zuerst die nächste Aufgabe erledigen. Ich bin immer noch frei, sie nur einen Schritt nach vorne zu bewegen und dann zuerst daran zu arbeiten. Zumindest muss ich manuell zugewiesene Abhängigkeiten nicht neu zuweisen. Ich denke, ohne einen Graphen, muss sowas in der Dependency Hölle enden.

Aber was kommt als nächstes?

Nachdem sichergestellt ist, dass ich so nah wie möglich am Plan arbeite, wie wäre es mit der nächsten Aktion. Wenn ich eine Aufgabe beendet habe, sollte der nächste Task die nächste Aktion sein, an der gearbeitet werden soll. Dafür benutze ich die Hilfe von org-edna. Die TRIGGER-Eigenschaft im obigen Beispiel setzt den ToDo-Status des nächsten Tasks auf NEXT, wenn eine Aufgabe auf einen fertigen Status gesetzt wird. Dies muss als Eigenschaft in jeder Aufgabe festgelegt werden, in der sie benötigt wird, oder im Fall einer einfachen flachen Aufgabenliste kann dies nur im Header erfolgen, indem die Variable org-edna-use-inheritance auf 't' gesetzt wird.

Es gibt also immer eine neue, als NEXT umsetzbare Aufgabe, wenn ich die vorherige abgeschlossen habe. Aber was ist, wenn ich mich entscheide, mit dieser Aufgabe zu warten und das Projekt zum Stillstand zu bringen? Dafür habe ich eine Agenda-Ansicht eingerichtet, die mir alle Projekte zeigt (sie werden durch einen TODO-Status von 'proj' definiert), die keine nächste umsetzbare Aufgabe haben. Diese Projekte werden in der Agenda für feststeckende Projekte angezeigt, die in den Org-Modus integriert ist.

Was wäre ein Projekt ohne eine DEADLINE?

Bisher konnten alle Probleme mit meinem Workflow nur mit dem Org-Modus oder org-edna gelöst werden, ohne den Code zu manipulieren. Aber eines blieb. Wie soll ich SCHEDULED oder DEADLINE Daten setzen, abhängig vom Enddatum der vorherigen Aufgabe? Karls Idee war es, es an die Fertigstellung der Aufgabe oder einer Gruppe von Aufgaben vorher zu binden, aber da ich das Konzept von Aufgaben aufgegeben habe, die durch statische Verknüpfungen explizit miteinander verbunden sind, ist dies auch nicht möglich.

Ich musste es vom empfangenden Ende aus angehen. Immer wenn eine Aufgabe zum ersten Mal auf NEXT gesetzt wird, berechne ich das Datum SCHEDULED und DEADLINE. Ich habe eine Funktion geschrieben, die an den hook org-after-todo-state-change-hook gebunden ist, die nach einer Eigenschaft mit dem Namen PLANNED sucht und deren Wert zur Berechnung eines Datums verwendet.

(add-hook 'org-after-todo-state-change-hook 'gtd/planning-trigger)

Nehmen wir an, ich möchte die Aufgabe 'Geschirrspüler leeren' 3 Stunden nach Abschluss der Aufgabe 'Geschirrspüler laden' ausführen. Also gebe ich ihm einen Eigenschaftswert von + 3h für PLANNED wie folgt:

** proj [0/2] Wash dishes         :dishes:project:
                 :PROPERTIES:
                 :COOKIE_DATA: todo recursive
                 :ORDERED: t
                 :TRIGGER: next-sibling todo!(NEXT)
                 :END:
*** NEXT Load dishwasher
*** todo Empty dishwasher
                 :PROPERTIES:
                 :PLANNED:: +3h
                 :END:

Nachdem die erste Aufgabe auf done gesetzt wurde, wird die zweite Aufgabe durch : TRIGGER: next-sibling todo! (NEXT) auf NEXT gesetzt. Bei erfolgreicher Änderung in NEXT zieht der Hook meine Funktion und voila:

** proj [1/2] Wash dishes                       :dishes:project:
                 :PROPERTIES:
                 :COOKIE_DATA: todo recursive
                 :ORDERED: t
                 :TRIGGER: next-sibling todo!(NEXT)
                 :END:
*** done Load dishwasher
          CLOSED: [2020-08-24 Mo 17:18]
*** NEXT Empty dishwasher
          SCHEDULED: <2020-08-24 Mo 20:18>

Der Code dafür ist ziemlich einfach, und ich muss ihn noch auf DEADLINE erweitern und gegen Fehler sichern, aber es funktioniert bisher.

(defun gtd/planning-trigger ()
  "Automatically insert chain-find-next trigger when entry becomes NEXT"
  (when (equal org-state "NEXT")
    (message "das war next")
    (setq planned (car (org-map-entries (lambda () (
      org-entry-get nil  "PLANNED")) "PLANNED<>\"\"" 'tree)))
    (if planned (
      (message "Geplant ist %s" planned)
      (org-entry-put nil "SCHEDULED" planned)
      (org-entry-delete nil "PLANNED")
  ) nil) ))

Abschliessend

Während der letzten zehn Tage habe ich viel über meinen eigenen Workflow gelernt, indem ich versucht habe, den Gedanken eines anderen über seinen eigenen Workflow zu folgen. Genau dafür wurde das Internet gemacht, und es hat mich glücklich gemacht. Und ich habe noch viel mehr gelernt.

Elisp in den Griff bekommen
gelernt, wie man in Emacs debuggt
und vor allem habe ich gelernt, wie sehr ich meinem Workflow vertraue, wenn er eine vollständige Agenda erstellt.

Aber das wird eine andere Geschichte sein …

Ein einfacher GTD Ansatz mit Org mode und Org Edna

Andy Drop — Mon, 24 Aug 2020 13:00:00 GMT

Und so begann meine Reise

Beim Durchsuchen des Codes von org-edna, um die Stelle zu finden, an der ich eine Abhängigkeitsbehandlung einfügen konnte, die gruppierte Abhängigkeiten zulässt, stellte ich fest, dass der Beispielworkflow vollständig flach war und dass diese Abhängigkeiten im Org mode behandelt werden konnten wenn ich nur die Hierarchie als Baum verwende
Danach wurde klar, dass ich nie mehr als höchstens drei Aufgaben als nächste Aufgabe planen würde. Mit GTD wäre die reine Lehre, nur eine aktive nächste Aufgabe pro Kontext zu haben, aber in Wirklichkeit verliere ich den Überblick, wenn sie zu viele werden.
Und die Reihenfolge ist mir wichtig. Was ist, wenn ich 5 Minuten brauche, um das Auto zum nächsten öffentlichen Parkplatz zu bringen, und 3 Tage, um die Regale zu leeren und zu entfernen? Ich müsste die ganzen Tage zum Parkplatz gehen, während ich die Garage ausräume. Also würde ich diese Schritte sowieso in der besten Reihenfolge planen.
Wenn es jetzt wieder eine flache Liste ist, aber mit einer bestimmten Reihenfolge, warum nicht die Eigenschaft ORDERED verwenden?

** proj [1/4] Brille richten                    :Brille:project:
         :PROPERTIES:
         :COOKIE_DATA: todo recursive
         :ORDERED: t
         :TRIGGER: next-sibling todo!(NEXT)
         :END:
*** done Zum Optiker fahren
          CLOSED: [2020-08-22 Sa 15:22]
*** NEXT Warten ob es ein neues Mittelteil gibt
*** todo Bestellen 
*** todo Gläser einsetzen

Aber was kommt als nächstes?

Was wäre ein Projekt ohne eine DEADLINE?

(add-hook 'org-after-todo-state-change-hook 'gtd/planning-trigger)

** proj [0/2] Wash dishes         :dishes:project:
                 :PROPERTIES:
                 :COOKIE_DATA: todo recursive
                 :ORDERED: t
                 :TRIGGER: next-sibling todo!(NEXT)
                 :END:
*** NEXT Load dishwasher
*** todo Empty dishwasher
                 :PROPERTIES:
                 :PLANNED:: +3h
                 :END:

** proj [1/2] Wash dishes                       :dishes:project:
                 :PROPERTIES:
                 :COOKIE_DATA: todo recursive
                 :ORDERED: t
                 :TRIGGER: next-sibling todo!(NEXT)
                 :END:
*** done Load dishwasher
          CLOSED: [2020-08-24 Mo 17:18]
*** NEXT Empty dishwasher
          SCHEDULED: <2020-08-24 Mo 20:18>

Der Code dafür ist ziemlich einfach, und ich muss ihn noch auf DEADLINE erweitern und gegen Fehler sichern, aber es funktioniert bisher.

(defun gtd/planning-trigger ()
  "Automatically insert chain-find-next trigger when entry becomes NEXT"
  (when (equal org-state "NEXT")
    (message "das war next")
    (setq planned (car (org-map-entries (lambda () (
      org-entry-get nil  "PLANNED")) "PLANNED<>\"\"" 'tree)))
    (if planned (
      (message "Geplant ist %s" planned)
      (org-entry-put nil "SCHEDULED" planned)
      (org-entry-delete nil "PLANNED")
  ) nil) ))

Abschliessend

Elisp in den Griff bekommen
gelernt, wie man in Emacs debuggt
und vor allem habe ich gelernt, wie sehr ich meinem Workflow vertraue, wenn er eine vollständige Agenda erstellt.

Aber das wird eine andere Geschichte sein …

Mein virtuelles Bücherregal

Andy Drop — Mon, 13 Apr 2020 13:16:35 GMT

Ich habe vor einigen Jahren beschlossen, mir wenn es irgendwie geht, keine Bücher mehr anzuschaffen. Dabei geht es mir nicht darum, das ich nichts mehr lesen möchte, im Gegenteil, sondern um diese riesige raumverschlingende Menge an Papier in den Regalen, die man bei jedem Umzug einmal ein- und dann auch wieder auspacken muss. EBooks sind also OK und seither meine bevorzugte Art Bücher zu lesen.

So hat sich im Laufe der Zeit so einiges an Lesestoff angesammelt. Ich habe mir das ein oder andere Humble Bundle gekauft, mir die Klassiker aus der Gutenberg Sammlung in meine Sammlung geladen, jede Menge verbilligte Altauflagen von Grundlagenwissen gehortet, und neben der Sammlung aller verfügbaren Datenschleudern habe ich auch noch jede Menge Scans von interessanten Artikeln aufgehoben, als ich diese entsorgt habe. Im Laufe der Zeit sind so gut 1000 "Werke" zusammengekommen.

Wer wie ich mit Linux arbeitet wir zur Verwaltung wahrscheinlich ganz natürlich zu Calibre greifen., Damit kann ich die Bücher zwischen meinem PC und den Readern hin und her kopieren, Metadaten hinzufügen und auch direkt die Bücher lesen. Dabei bewege ich mich im Wesentlichen die ganze Zeit in einer langen Liste von Büchern. Und ich verliere ständig den Überblick.

Wie viel einfacher wäre jetzt ein Bücherregal

Oft hatte ich beim suchen in dieser Liste den Gedanken, wie viel intuitiver dieses Suchen ging als ich früher vor meinem Bücherregal stand. Ich wusste genau, das meine Fantasy Ecke dort begann, wo die neongrüne Ausgabe des Herrn der Ringe im Regal leuchtete, und die Programmierbücher standen auf Hüfthöhe und gruppierten sich rund um den dicken "C von A bis Z" Wälzer. Optisch markante Bücher bildeten eine Art mentales Gerüst in dem sich das Hirn sehr schnell orientieren kann. Das Auge ist immer noch der breitbandigste Eingangskanal des Menschen. Lange Listen nutzen diese Eigenschaft nur sehr unzureichend aus.

Also habe ich nach einem Plugin für Calibre gesucht um mir meine Sammlung als eine Art Bücherregal darstellen zu lassen, und zu meinem eigenen Erstaunen nicht gefunden.

Als sich kurz drauf meine Partnerin für ein Wochenende zu Hause verbarrikadierte, um letzte Hand an ihre Masterarbeit zu legen, hab ich das auch für einen kleinen Coders-Retreat getan, um an einer Umsetzung zu arbeiten. Das Ergebnis war dann kurz darauf schon sehr zufriedenstellend:

SVG als Mittel der Wahl

SVG also Scalable Vector Graphics, hatte für mich als Mittel der Wahl einige Vorteile

Es kann mit jedem Browser angezeigt werden, was bedeutet ich brauche die grafische Darstellung nur erzeugen, und muss mich nicht selbst um die Anzeige kümmern
Ich kann direkt in die Grafik Links einbauen, die dann vom Browser verarbeitet werden. Dadurch wird für jede Art von eBook (epub, mobi, pdf) genau der Betrachter aufgerufen, den das Betriebssystem dafür vorsieht. Auch darum muss ich mich nicht kümmern. Ich klicke auf das Buch, und es öffnet sich im Reader.
Die Grafik ist, wie der Name schon nahelegt skalierbar, ich kann also näher an das Regal zoomen, und sehe dann auch tatsächlich mehr Details.

Interessante Probleme bei der Umsetzung

Umgesetzt habe ich das ganze mit Python, der komplette Code liegt auf meinem Codeberg.

Unterschiedliche Grössen und Farben

Wenn ich in mein Bücherregal schaue (ich habe noch ca 1,5 Meter davon) dann fällt mir zum Beispiel direkt die Death Note Serie auf. Die Bücher sind alle kleiner als die anderen, und sie haben den gleichen Buchrücken. Etwas ähnliches wollte ich für meine virtuellen Bücher auch tun.

Gelöst habe ich das vorerst dadurch, dass ich je nach Verlag den Büchern eine einheitliche Farbe und Größe gebe. Das mache ich auf die simpelste Weise, die mir einfiel:

hex = hashlib.md5(self.publisher.encode('utf-8')).hexdigest()
h = int(int("0x" + str(hex)[-2:], 16)/2)
col = "#" + str(hex)[-6:]
pubcol = "#" + str(hex)[-8:-2]
hex = hashlib.md5(self.series.encode('utf-8')).hexdigest()
sercol = "#" + str(hex)[-8:-2]

link = SVG.SubElement(svg, "a",
                      href=self.formats[0],
                      type="application/epub+zip")

linktitle = SVG.SubElement(link, "title")
linktitle.text = self.title

book = SVG.SubElement(link, "rect",
                      fill=col,
                      stroke="black",
                      x=str(position),
                      y=str(bottom-192-h),
                      width=str(self.shelfspace()),
                      height=str(192+h))
book.set("stroke-width", "0.5")

publisher = SVG.SubElement(link, "rect",
                           fill=pubcol,
                           stroke="black",
                           x=str(position),
                           y=str(bottom-16),
                           width=str(self.shelfspace()),
                           height=str(16))
publisher.set("stroke-width", "0.5")

Ich generiere mir einfach aus dem Verlagsnamen einen md5 Hash (hier kommt es nicht auf cryptographische Sicherheit an) und benutze z.B. das letzte Byte davon um die Höhe zu berechnen, oder nehme die letzten 3 Bytes als Farbwert für den Buchrücken. Ähnliches mache ich dann mit einem kleinen Viereck am oberen Buchrand, um Serien unterscheiden zu können

Unterschiedliche Buchdicke

Eine weitere optische Besonderheit, die einem das auffinden von Büchern im Regal leicht machen ist die unterschiedliche Dicke der Bücher. Mein erster naiver Ansatz war zu sagen, dass mein dickstes Buch im Regal einfach 10 cm dick sein soll, und alle anderen entsprechend der Seitenzahl proportional dünner. Das ging jedoch ziemlich schief. Mein dickstes Buch hat etwa 4100 Seiten, meine dünnsten Bücher haben nur 2 - 5 Seiten. abgesehen davon das diese Scans von Artikeln dann im Regal kaum sichtbar wären, wäre es außerdem noch unmöglich ihren Rücken zu beschriften.

Dazu muss ein Buch bei mir mindestens 10mm dick sein. Ich habe den Büchern also quasi einen Einband verpasst der diese Mindestdicke hat, und nach einer Methode gesucht, wie die Dicke bei dünnen Büchern sehr schnell ansteigt, mit zunehmender Seitenanzahl dann aber immer langsamer wächst, bis schließlich 90mm erreicht sind. Plus Einband liege ich dann wieder bei 10cm heraus kam folgendes:

def shelfspace(self):
    return sqrt(1-(1-(self.seiten / Book.maxPages) ** 2)) * 90 + 10

Da sich das nicht auf Anhieb erschließt ist hier meine Skizze dazu:

Wie man unten rechts sieht hatte ich kurz darüber nachgedacht das über Sinus und Kosinus zu machen, aber als ich den Radius eingezeichnet hatte, wurde deutlich, dass ich es hier mit einem rechtwinkligen Dreieck zu tun habe, und da geht immer a²+b²=c². Wenn man sich den Kreisbogen ansieht, und die Seitenanzahl von links nach rechts stetig steigt, dann sieht man wie die Dicke anfangs nahezu senkrecht zunimmt um dann immer langsamer auf die maximale Dicke zu klettern. Während es einen großen Unterschied macht, ob ein Buch 50 oder 150 Seiten hat, so ist es nahezu belanglos, ob es 1900 oder 2000 Seiten hat. Am Ende liegt es bei 90 Millimetern plus 10 Millimetern für den Einband.

Was ich noch tun möchte

Derzeit in Arbeit ist es die Bücher thematisch zu sortieren. Dazu brauche ich zunächst mal eine thematische Reihenfolge, und dazu müssen alle Bücher verschlagwortet werden. Bei 1000 Büchern nimmt das eine ganze Zeit in Anspruch, dann werde ich die Schlagworte inhaltlich gruppieren, und beim füllen darauf achten das in der passenden Reihenfolge zu tun. An die Regale kommen dann kleine Schildchen auf denen Steht welche Themen wo beginnen. Grosse Themen bekommen auch ein Schild an den Kopf des Regals ähnlich wie in einer Buchhandlung.

Die Buchrücken sollen realistischer werden, in dem Sinne, das sie das Cover ein wenig nachahmen. Ich möchte aus dem linken Rand des Covers (ein paar Pixel breit) einen Streifen erzeugen, der dann als Rücken genutzt wird.

Ein paar grafische Gimmicks, wie schräg angelehnte Bücher oder kleine Bücherstapel verschaffen bestimmt auch mehr Orientierung.

Finanzen im Griff mit Ledger (2) - Der Emacs Ledger-Mode

Andy Drop — Fri, 21 Feb 2020 12:00:00 GMT

Im letzten Teil hatte ich darüber geschrieben, wie Buchungen in Ledger funktionieren, und wie sie geschrieben werden. Dadurch, dass es sich um einfache Textdateien handelt, braucht man dazu nicht mehr als einen beliebigen Texteditor. Wählt man dazu Emacs macht die Arbeit allerdings schon deutlich mehr Spass.

Naja zugegeben Spass ist was anderes, aber wenn man seine Finanzen mal im Griff hat, und nicht mehr jeden Januar von der Welle der "unerwartbaren" Buchung überrascht wird hinterlässt das schon ein sehr gutes Gefühl. Und Emacs macht es mit dem Ledger Mode schon recht einfach schnell einwandfreie Buchungssätze zu schreiben

Automatische Namensergänzung

Eine grosse Fehlerquelle besteht darin, dass die Kontonamen (die ja in der Regel auch noch innerhalb von Kategorien liegen) schnell sehr lang werden können. Ausgaben:Wohnen:Nebenkosten:GasWasser ist durchaus ein ganz gewöhnlicher Kontenname. Der Ledger Mode liest beim laden der Datei alle Konten ein und es reicht ab dann die einzelnen Teile der Bezeichnung zu beginnen, und dann einfach per Tab-Completion automatisch ergänzen zu lassen. Neben der eingesparten Zeit beim Tippen können so auch keine Tippfehler mehr entstehen.

Apropos Tippfehler in Kontennamen. Ledger bietet die Möglichkeit bei unbekannten Konten in einer Buchung, dieses Konto einfach nebenbei zu erzeugen. So verführerisch diese Option auch ist sollte davon Abstand genommen werden, und stattdessen lieber die gegenteilige Einstellung zur Norm werden.

Dann weigert sich Ledger zu arbeiten sobald ein Konto bebucht werden soll, dass vorher nicht explizit eingerichtet wurde. Diese Weigerung mag anfangs lästig erscheinen, aber wenigstens gibt Ledger dann genau an welches Konto falsch geschrieben wurde, wenn man sich doch mal vertippt. Ohne dies Meldung staht man ansonsten vor der Herausforderung einfach nur falsche Werte in seinen Konten zu haben, und die Ursache aus hunderten Buchungen herauslesen zu müssen.

Unterstützter Realitätsabgleich.

Eine weitere Hilfe, damit die Buchführung nicht von der Realität abweicht, ist ein regelmmässiger Kontenabgleich ich mache das für mein Girokonto, und die Kreditkarte anhand der Kontoauszüge und für das Bargeld indem ich einfach den Inhalt meines Portemonaies auf den Schreibtisch entleere.

In jedem Fall erhalte ich so den Kontostand, den auch meine Buchführung aufweisen sollte. Die Reconcile Funktion des Ledger Modes fragt mich beim Aufruf nach diesem Wert, und gibt mir anschliessend eine Auflisteung aller Buchungen, die ich noch nicht abgeglichen habe. Nun kann ich mich mit meinem Kontoauszug in der Hand hinsetzen und alle Buchungen markieren, die ich in Ledger ebenfalls sehe. Dabei bekomme ich ständig die Differenz meiner bestätigten Buchungen zur Realität angezeigt. Sobald diese Differenz 0 beträgt ist der Abgleich erledigt, und aus den temporären markierungen werden endgültige. Um diese so markierten Buchungen muss ich mich danach nie wieder kümmern.

Automatische Reportupdates

Gerade beim Bargeld ist so ein Realitätsabgleich manchmal schwierig, denn er setzt voraus, dass man jeden Cent den man irgendwo für einen Schkoriegel ausgegeben hat, irgendwie in die Buchführung bekommt. Aus diesem Grund empfehle ich für den Anfang die BArgeldums"tze einfach zu minimieren und vieles mit der Karte zu bezahlen. Das Geld was man dann noch am Geldautomaten abholt kann man dann entweder einem allgemeinen Konto zuordnen, oder nach Gefühl aufteilen. Nur wer es hier genauer wissen will und entsprechen diszipliniert bucht wird Spass damit haben.

Ich nutze sowieso für kleine Notizen ein USB Diktiergerät und so klappt auch die Bargeldbuchführung recht gut. Falls ich mal ein wenig mehr Arbeit damit habe meine Ausgaben nachzuvollziehen, ist es sehr hilfreich das Emacs mir in einem zweiten Fenster den Verlauf meiner Ausgaben und Einnahmen (wenn ich am Geldautomaten war) im Portmonai zu zeigen, und sofort zu aktualisieren, wenn ich Buchungen hinzufüge.

Angenommen ich dachte, das ich vor zwei Wochen mal 15 Euro beim Chinamann ausgegeben habe, sehe ich beim eintragen so sofort, dass da irgendetwas nicht stimmen kann, weil zwar die Endsumme meines Bargeldkontos dem entspricht, was ich im Portemonaie habe (und somit die 15 Euro tatsächlich ausgegeben wurden) aber der Zeitpunkt nicht stimmen kann, weil mein Portemonaie ansonsten zwischenzeitlich im Minus gewesen wäre, was bei Bargeld einfach nicht möglich ist.

Offensichtlich war es also nicht vor 2 sondern vor einer Woche, nachdem ich zwischendurch am Geldautomaten war. Ich kann meine Buchung durch die Zeit schieben, und sehe im Report sofort live, ob eine Buchung evtl so nicht möglich gewesen sein kann.

Automatisches Grossreinemachen

Auch wenn dies Funktion eigentlich nichts umwerfendes ist, ist es doch ungeheuer praktisch wenn man bei der Erfassung von Buchungen nicht darauf achten muss wohin in der Datei man seine Buchng schreibt, oder ob man auch alle Dezimalpunkte untereinander schreibt. Der Ledger Mode hat sowohl für die lesbare Formatierung, wie auch die zeitliche Sortierung von Buchungen Funktionen. Ich habe es mir besonders einfach gemacht und rufe dieses "hübsch machen" einfach per Hook bei jedem Speichern meiner Ledger Datei auf. So sind immer alle Daten lesefreundlich formatiert

Warum ich Plaintext mag

Andy Drop — Fri, 14 Feb 2020 14:16:35 GMT

Ich sass sehr gespannt vor meinem Homebanking Programm. Es war das einzige, mit dem ich unter Linux direkt mit meiner Bank kommunizieren konnte. Leider waren die Möglichkeiten der Auswertung sehr begrenzt, aber das ist ja kein Problem. Linux stellt eine Menge Software zur Verfügung um aus tristen Zahlen schöne Grafiken zu machen. Allerdings speicherte die Banking Software ihre Daten nur in einem antiken und scheinbar auch verschlüsselten Datenbanksystem.

Also hatte ich nochmal gutes Geld für die PRO Version gezahlt weil die laut Hersteller in der Lage sein sollte Daten im XLM Austauschformat ex- und importieren zu können. Da XML in der Regel einfach zu lesen ist, fand ich das eine gute Idee, um meine eigenen Grafikausgaben mit den Daten zu füttern.

Der ein oder andere wird schon bemerkt haben, was ich damals auch für einen Schreibfehler gehalten habe. Da stand XLM und nicht XML, und genau so meinte der Hersteller das auch. XLM war ein Format, das komplett kryptisch war, nicht dokumentiert, und ausser von diesem Hersteller vermutlich von niemandem gelesen oder geschrieben werden konnte. Für mich war das für nichts anderes gut, um als Ausrede für die oft geäusserten Beschwerden gegen fehlende Schnittstellen nach aussen zu dienen.

Sowas macht mich halsig

Wenn ich mich schon aus Not an einen Hersteller binde, dann will ich nicht auch noch so über den Tisch gezogen werden. Zu meiner Erleichterung hatte damals das aqbanking Projekt seine Software so weit entwickelt, dass es möglich wurde auch mit meiner Bank zu kommunizieren. Und das beste war, es legte seine Daten einfach im Klartext auf meine Festplatte. Die konnte ich dann mit anderen Programmen lesen, verarbeiten, grafisch darstellen, und all die Dinge machen, die niemand zusammen in ein einziges Programm packen würde.

Queryologie

Und hier kommt auch schon der Große Vorteil davon, alle meine Daten in Plaintext zu haben. Ich weiss selbst heute noch nicht, was ich eines Tages alles mit diesen Daten anfangen möchte. Oder wie Michael Seemann es formuliert: Welche Query ich später mal auf diese Daten anwende.

"Nicht mehr der Sender soll definieren, was der Empfänger für Signal und was er für Rauschen zu halten habe, sondern der Empfänger soll dies in Zukunft selbst entscheiden, ohne den Sender überhaupt zu fragen."

Michael Seeman: Das Neue Spiel, Kap2, Die Emanzipation der Query

Im konkreten Beispiel kann weder die Bank, noch mein Softwarehersteller wissen, dass ich mein Girokonte in meinem privaten Kassenbuch noch in eine handvoll virtueller Briefumschläge aufteile, in die ich jeweils am Anfang des Monats ein bisschen Geld stecke um damit z.B. in jedem Halbjahr die Autoversicherung zu bezahlen.

Jetzt wo ich einfach meine Umsätze und den Kontostand als Plaintext-Datei bekomme kann ich das leicht in meiner Buchfühung abbilden und auch grafisch anzeigen lassen.

Vendor Lock-In

Und so geht es mir an vielen Stellen, wenn ich mit Software arbeite. Sei es die Fotoverwaltung, in der ich zwar alle Bilder wunderbar mit Personennamen, Orten und Ereignissen markieren kann, oder die Ahnenforschung, bei der ich meine 200 Vorfahren mühelos mit anderen Ahnenforschern am gleichen Stammbaum abgleichen kann, aber sie nicht an meine Tochter weitergeben, wenn ich keine Lust habe bis zu meinem Lebensende horrende Mitgliedsbeitrage für die Aufbewahrung zu zahlen.

Mein aktuellstes Beispiel ist meine Buchsammlung von knapp 100 eBooks, die ich im Laufe der Jahre bei Amazon erstanden (es geht um hunderte Euro) habe, und die ich seit einer Kündigung meines Benutzerkontos planmässig nicht mehr lesen kann. Immer geht es um den Effekt der Herstellerbindung.

Darunter versteht man etwa folgendes

"Unter Lock-in-Effekt (englisch lock in, „einschließen“ oder „einsperren“) versteht man generell in den Wirtschaftswissenschaften und speziell im Marketing die enge Kundenbindung an Produkte/Dienstleistungen oder einen Anbieter, die es dem Kunden wegen entstehender Wechselkosten und sonstiger Wechselbarrieren erschwert, das Produkt oder den Anbieter zu wechseln."

Wikipedia: Lock-In-Effekt

Ausbruch

Plaintext erlaubt es mir aus diesem, und noch einigen anderen Gefängnissen auszubrechen. Ich werde dadurch unabhängig, dass ich mich von Datenformaten löse, die nur von Maschinen, und im schlimmsten Falle nur von den Maschinen oder Programmen einzelner Hersteller, gelesen werden können. Ich werde unabhängig davon dass

Hersteller die Funktionen anbieten die ich möchte
Hersteller in 10 Jahren noch existieren
Hersteller in 50 Jahren noch ihre Server betreiben
Hersteller ihre eigenen Datenformate weiterhin unterstützen
Software auch mit den Produkten der Konkurrenz zusammenarbeiten möchte
- Auch wenn diese Konkurrenzfirma erst in 3 jahren gegründet wird
Es überhaupt noch Software zur Verarbeitung gibt. Zur Not kann ich all diese Daten auch einfach ausdrucken und mit dem blossen Auge lesen.

In der Praxis kann dank Plaintext mein Kochrezept-Programm seine Daten einfach gut lesbar auf der Festplatte ablegen, und ich kann mir ein kleines Programm schreiben, dass mir ein Rezept auswahlt und die Zutaten dafür als Einkaufszettel in meine ToDo-Liste schiebt, und an mein Handy schickt.

Vermutlich ist das auch der Grund warum Linux so gut zu mir und meinem Arbeitsstil passt. Statt mir ein komplette Arbeitsweise vorgeben zu wollen, bietet es mir viele kleine Programme die kleine Aufgaben lösen, und alle mit den selben Daten arbeiten können, und dadurch in Summe ein sehr mächtiges Team darstellen. Und dieses Team habe ich lieber an meiner Seite, als die Firma, die mir mit Absicht einen Druckfehler unterjubelt um mir das Geld aus der Tasche zu ziehen.