Plain DrOps (Einträge über emacs)

Was ich von einem Editor als Programmierer erwarte

Andy Drop — Mon, 06 Jul 2026 16:00:00 GMT

Ich habe in den letzten Jahren beruflich eigentlich nur mit einem Programm-Editor gearbeitet, nämlich dem VB6-Editor, aber meine Reise begann schon viel früher - in den frühen 90ern. Damals war alles noch ein bisschen einfacher - oder zumindest übersichtlicher.

Anfangs war es nämlich einfach ein normaler Text-Editor. Die erste Umgebung, die man so bezeichnen konnte, war das PDS 7.1, Microsofts Professional Development System, das - obwohl unter DOS lauffähig - bereits mit der Fensteraufteilung daherkam, die man bis heute aus den Microsoft-Umgebungen von VB bis Visual Studio kennt und die weithin übernommen wurden. In dieser Umgebung habe ich mich pudelwohl gefühlt.

Und genau das versuche ich in diesem Artikel zu analysieren: Was war es eigentlich, das dazu geführt hat? Was erwarte ich von meinem Programmiereditor? Und wie richte ich mir Emacs so ein, dass es all diese Aufgaben nahtlos übernehmen kann?

Fenster Handling

In der Regel arbeite ich mit nur einem oder maximal zwei Fenstern für den Code - und das auch nur, wenn ich mehrere Code-Stellen parallel sehen muss. Dazu brauche ich ein Fenster, in dem ich den Projektbaum sehe und auf- und zuklappen kann. Ideal wäre noch ein Fenster, das mir einen Überblick über die einzelnen Funktionen und Klassen in der aktuell angezeigten Datei gibt, um schnell innerhalb der Datei navigieren zu können. Eine flexible Fensterverwaltung ist für mich essenziell, ohne dass ich mich in zu vielen Fenstern verliere.

Navigation

Unter Navigation verstehe ich alles, was dafür sorgt, dass ich schnell an den Punkt im Code komme, an den ich gerade möchte, und dass ich keinen Code sehe, der mich gerade nicht interessiert. Daher betrachte ich auch Code-Folding für mich als Teil der Navigation.

Ich möchte im Codebaum auf und ab springen können, sowie ebenenweise navigieren. Wenn ich in einer Funktion bin, möchte ich mit einem Tastendruck am Klassenkopf sein und diese Klasse einklappen können, wenn ich mich um eine andere Klasse kümmern möchte. Sprünge an Dateianfang und Dateiende sollten selbstverständlich sein. Schön wären Sprünge an die Stelle, an der eine Variable deklariert wird. Oder im Falle von Programmiersprachen mit Header-Dateien ein Hin- und Herspringen zwischen der Datei und ihrer Header-Datei oder auch zwischen der Datei und der dazugehörigen Testdatei - weil man ja doch ab und zu an Code arbeitet und parallel an den dazugehörigen Tests.

Zusätzlich möchte ich im Dateibaum navigieren können, entweder indem ich mir die Datei direkt aufrufe oder durch sinnvolle Abkürzungen in passende Ordner springe.

Editieren

Beim Editieren geht es mir um Kleinigkeiten, die den Arbeitsfluss erleichtern: Beim Schreiben einer öffnenden Klammer soll automatisch eine schließende gesetzt werden. Verschiedene Klammer-Ebenen sollten farblich unterschiedlich angezeigt werden, damit ich sie sofort optisch unterscheiden kann. Ich bin der Typ, der Tabs beim Editieren nutzt - aber Tabs im Code sind für andere einfach hässlich. Daher ist es wichtig, dass ich Tabs beim Editieren verwenden kann, diese aber beim Speichern automatisch in Leerzeichen umgewandelt werden. Besonders in Sprachen wie Python, wo die Einrückung eine semantische Bedeutung hat, muss das sauber funktionieren.

Autocompletion / Intelligente Unterstützung

Autocompletion ist ein weiteres spannendes Thema. Was ich bisher immer benutzt habe, ist so etwas wie IntelliSense: Sobald ich den Beginn einer bereits benutzten Variable oder Funktion tippe, wird mir die vollständige Bezeichnung vorgeschlagen. Wichtig ist dabei, weder zu viele Möglichkeiten zur Auswahl zu haben, noch wichtige Dinge nicht auswählen zu können. Eine präzise und kontextbezogene Autocompletion unterstützt mich, ohne mich zu überfordern.

Snippets

Hier lebe ich immer noch den Traum von einer universellen Snippet-Sprache. Ich möchte Textblöcke einfügen können, in denen ich Variablen einsetze, ähnlich wie es Cookie Cutter erlaubt. Außerdem möchte ich beim Schreiben durch eine zwei- oder dreibuchstabenkombination kurze Textschnipsel wie einen If-Block oder einen Select-Case-Block in Visual Basic oder vergleichbare Strukturen in anderen Sprachen erstellen können. Am liebsten hätten all diese Blöcke, die das Gleiche in verschiedenen Sprachen tun, die gleiche Abkürzung. Deswegen nenne ich das Universal Snippets . Diese Flexibilität würde mir helfen, meine Arbeit zu beschleunigen, ohne mich um Sprachspezifika kümmern zu müssen.

Probelauf

Der Probelauf ist eigentlich ganz simpel: Ich möchte das Programm aus meinem Editor heraus kompilieren und starten können - und damit herumspielen. Je nach Programmiersprache sind dazu noch einige Zwischenschritte nötig. Diese sollen unter der Haube automatisch erfolgen, damit ich mich auf das Wesentliche konzentrieren kann: das Testen und Ausprobieren meines Codes.

Debugging

Beim Debugging habe ich schon so ziemlich alles erlebt. Die allerspartanischste Art zu debuggen ist es wohl, irgendwo im Programmcode ein Beep einzufügen und zu schauen, ob es beim Programmlauf irgendwo piept. Konsolenausgaben, die ich direkt in den Code schreibe, sind nur ein wenig komfortabler. Aber was ich eigentlich möchte, ist es, sinnvoll im Code steppen zu können: Step In, Step Over, Step Out . Dabei möchte ich mir den Status diverser Variablen anzeigen lassen können.

Breakpoints zu setzen ist für mich essenziell - und zwar nicht nur an festen Stellen im Code, sondern auch abhängig von Ausdrücken. Zum Beispiel: Ein Breakpoint, wenn ein Ausdruck wahr ist, oder ein Breakpoint, wenn sich der Wert einer Variablen ändert. Ich möchte also nicht stoppen, wenn der Wert der Variablen a gleich 7 ist, sondern immer dann, wenn er sich vom aktuellen Wert in irgendeinen anderen Wert verändert. Das ist etwas, das mein uraltes Visual Basic 6 konnte, aber in vielen modernen Entwicklungsumgebungen fehlt.

Ebenso wichtig ist für mich, dass ich Fehlermeldungen des Compilers oder Parsers direkt sehe und durch einen Klick in die entsprechende Datei und Zeile springen kann.

Testen

Beim Testen kommen ja mittlerweile fast alle modernen Programmiersprachen mit einem integrierten Testframework daher. Und ich finde, das sollte auch genutzt werden. Ich möchte diese Testframeworks direkt aus dem Editor heraus nutzen können, damit ich meine Tests schnell und effizient ausführen kann. Dabei wäre es schön, wenn ich nicht jedes Mal die gesamte Testsuite durchlaufen muss, sondern auch nur die aktuelle Datei und die dazugehörigen Tests ausführen könnte. So kann ich gezielt und ohne unnötigen Zeitverlust arbeiten.

Git Integration

Für die Git-Integration gibt es Magit - muss ich mehr sagen? Das Ding funktioniert einfach und ist rund. Einzig beim Diffing bin ich noch ein bisschen verwöhnt: Da nutze ich, egal auf welcher Maschine, die Software Beyond Compare von Scooter Software. Für mich das ultimative Diffing-Tool. Wenn ich etwas Vergleichbares in Emacs herstellen könnte, wäre das super. Das ist mir bisher aber noch nicht gelungen.

Eine coole Funktion der Git-Integration wäre, wenn ich jedes Mal beim Speichern einen internen Git-Commit im Entwicklungsbranch erzeuge, in dem ich gerade arbeite. Wenn ich dann 27 Mal gesichert habe und der Tag zu Ende ist, und ich beschließe, diesen Stand zu behalten, kann ich diese Commits squashen und habe dann einen einzigen sauberen Commit.

Deployment

Beim Deployment ist es ja so: Manchmal ist es Teil der Git-Integration durch irgendwelche Hooks wie bei GitHub. Oder es muss manuell gemacht werden. Wenn ich es manuell machen sollte, dann würde ich gerne Targets auswählen können. Und das Ganze sollte eng mit Git verzahnt sein.

Refactoring

Refactoring habe ich hier nochmal getrennt aufgeführt. Obwohl ich es manchmal bereits direkt während des Code-Editierens mache, ist es sinnvoller, sich in regelmäßigen Abständen hinzusetzen und nichts anderes als Refactoring zu machen. Wenn ich dabei strukturell etwas umbauen möchte, dann ist das meiste Cut, Paste und Neuschreiben. Was mir dabei aber schon ungeheuer helfen würde, ist, wenn ich mir sicher sein könnte, dass ich Variablen- oder Klassennamen projektübergreifend suchen und ersetzen könnte - ohne dass mir das Projekt dabei um die Ohren fliegt.

Mein Fazit

Am Ende geht es nicht darum, den "perfekten" Editor zu finden - den gibt es nicht. Aber es geht darum, einen Editor zu haben, der mich unterstützt, statt mich zu behindern. Ein Tool, das mir hilft, schneller und effizienter zu arbeiten, ohne dass ich mich ständig mit ihm herumschlagen muss. Mit Emacs habe ich die Möglichkeit, mir genau diese Umgebung zu schaffen.

Und ja, ich weiß, dass ich anspruchsvoll bin. Aber wenn ich schon acht Stunden am Tag vor einem Bildschirm verbringe, dann will ich wenigstens ein Werkzeug, das mich nicht in den Wahnsinn treibt.

In weiteren Artikeln möchte ich mich mit jedem dieser Abschnitte einzeln befassen und konkret schauen, welche Lösungen Emacs dabei bietet, welche kleinen Funktionen ich mir vielleicht selbst schreiben kann oder wo sich noch tricksen lässt.

EmacsWiki Blog Karneval "Programmieren"

Andy Drop — Sun, 28 Jun 2026 12:00:00 GMT

Emacs ist nicht nur ein Texteditor - es ist eine vollwertige Programmierumgebung, die sich perfekt an deine Bedürfnisse anpassen lässt. Ob Python, C++, Lisp, Rust oder JavaScript: Mit der richtigen Konfiguration wird Emacs zur mächtigen IDE, die dir alles bietet, was du für effizientes Coden brauchst: Syntax-Highlighting, Debugging, Version Control, REPL-Integration und vieles mehr.

Doch wie nutzt du Emacs als Programmierwerkzeug? Welche Pakete, Einstellungen oder Workflows machen deinen Code-Alltag produktiver?

Mögliche Themen – oder bringe deine eigenen Ideen ein:

Sprach-spezifische Einrichtungen: Wie konfigurierst du Emacs für deine Lieblingssprache? Welche Pakete (z. B. lsp-mode, flycheck, company) sind für dich unverzichtbar?

Debugging & Testing: Wie integrierst du Debugger (z. B. realgud, dap-mode) oder Test-Frameworks direkt in Emacs?

Projektmanagement: Wie organisierst du große Codebasen in Emacs? Nutze du Tools wie projectile, magit oder forge für Git-Workflows?

REPLs & Interaktive Entwicklung: Wie arbeitest du mit REPLs (z. B. für Python, Clojure oder Haskell) direkt in Emacs?

Performance & Skalierbarkeit: Wie hältst du Emacs auch bei großen Projekten schnell und responsiv? Welche Optimierungen hast du vorgenommen?

Was ist eigentlich ein Blog-Karneval?

(Kopiert aus Christian Tietzes Einführungspost)

Dies ist schon unser zweiter Emacs-Karneval, aber möglicherweise daher kennst du das Format 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 „Carnival“-Seite an.

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. August (Mitteleuropäische Zeit), damit jede Zeitzone die Chance hatte, die Frist am 31. Juli einzuhalten :)

Folgende Beiträge sind eingegangen:

Was ich von einem Editor als Programmierer erwarte (Andy Drop)
Emacs Carnival July 2026 – Programming (Raymond Zeitler)
How Emacs Uses Nix (Mike Hostetler)
Emacs Carnival (Jason Bonthron)
A Tree and a Server Walk Into a Core… (Charlie Holland)
Mon flux de travail de programmation (Sacha Chua)
Comfy text editing with line spacing™ (Winston Weinert)
Guix shell now inside Emacs! (tusharhero)
Yes, I am hooked to Metaprogramming in Emacs (Dibyashanu Pati)

Vielen Dank für eure Teilnahme

Im August wird Charlie Holland unser Gastgebersein, mit dem Thema "The Search for Knowledge". Auch du kannst Gastgeber eines zukünftigen Karnevals werden – keine Scheu :)

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.

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.

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

Finanzen im Griff mit Ledger (1) - Grundlagen

Andy Drop — Fri, 12 Jul 2019 05:00:00 GMT

Wer von uns kennt das nicht. Am Ende des Geldes ist noch eine ganze Menge Monat übrig, und die Zeit nutzen dann das Gaswerk und der Goldfischzüchterverein, Ihren Jahresbeitrag (inklusive der Preiserhöhung) vom Konto einzuziehen.

Ich hatte auch mal eine Zeit, in der ich nur mit einer Menge Finanzjonglage von Monat zu Monat kam, obwohl ich genau so viel Geld zur Verfügung hatte wie heute. Ich hatte es nur nicht so gut unter Kontrolle. Das Kernproblem war eigentlich, das ich fast nie wusste, wie viel von dem Geld, das auf meinem Konto war nun wirklich zu meiner freien Verfügung stand, und welche Rechnungen in der nächsten Zeit auf mich zu kommen sollten.

Und dann habe ich mich irgendwann hingesetzt und beschlossen das zu ändern. Zunächst mit Bleistift und Papier, später dann mit Unterstützung des PCs. Dabei habe ich diverse Systeme versucht, Hängengeblieben bin ich schlussendlich bei Ledger. Im vergangenen Jahr habe ich immer mal wieder kleine Tests gemacht, wie ich meinen Umgang mit Geld damit abbilden kann, und da es dabei keine größeren Schwierigkeiten gab, habe ich zum Jahresbeginn 2019 komplett auf Ledger umgestellt.

Was kann Ledger (Buchungen & Transaktionen))

Eigentlich kann ledger nur sehr wenige Dinge, aber bei denen ist es sehr flexibel, so dass sich eine Menge Anwendungsfälle damit abdecken lassen.

Es liest eine oder mehrere Textdateien mit Buchungen
Es summiert diese Buchungen (und unterscheidet dabei die Konten auf denen gebucht wird)
Es gibt entweder den Buchungsverlauf, oder die Summen auf dem Bildschirm aus

Vor allem fällt auf, das Ledger auf keinen Fall in den Buchungen in meinen Dateien rumschreibt. Ich schreibe meine Buchungen, und Ledger wertet sie lediglich aus. Darin ist es sehr schnell und präzise.

Mal ein Beispiel:

2019-03-10  Tankstelle
   Benzin        50.00 
   Girokonto   -50.00

Was wir hier sehen, ist eine Transaktion. Das ist der Baustein, mit dem wir in Ledger am häufigsten zu tun haben. Er besteht aus dem Kopf, der angibt, wann die Transaktion stattgefunden hat und wer der Partner dabei war (hier die Tankstelle), sowie aus einer Anzahl Buchungen (diese sind jeweils etwas eingerückt). Buchungen sind der kleinste Baustein, mit dem wir in Ledger zu tun haben. Eine Buchung nennt ein Konto, und einen Betrag, der dem Konto hinzugefügt (oder abgezogen falls der Betrag negativ ist) wird . Mehrere dieser Buchungen bilden eine Transaktion.

Das wesentliche Merkmal einer Transaktion ist, dass sich die Buchungen IMMER auf 0 aufsummieren müssen. Andernfalls ist die Transaktion nicht gültig, und erzeugt einen Abbruch mit einem Fehler in Ledger.

In der Konsequenz bedeutet dass, dass es zu jeder Buchung mindestens eine Gegenbuchung geben muss. Eine Transaktion besteht also aus immer mindestens zwei Buchungen, und wird daher landläufig auch "doppelte Buchführung " genannt. Jeder Euro, der von einem Konto kommt, muss auf einem anderen Konto landen.

Wenn ich Ledger das obige Beispiel auswerte und mir die Summen anzeigen lasse sagt es mir beipielsweise, das sich auf dem Konto Benzin nun 50.00 befinden, und mein Girokonto nun mit 50.00 in den Miesen ist.

Konten

"Ist doch super", wirst du nun sagen, "wenn ich die 50.00 Euro noch mal brauche, dann buche ich sie einfach vom Benzinkonto wieder ab, und…". Aber so funktioniert das offensichtlich nicht. Die Tankstelle wird es nicht mögen wenn du bei Ihr wieder abbuchst. Auch wenn du das von der reinen Buchhaltung her einfach machen könntest.

In der Realitat benutzt man daher ein paar Kategorien von Konten, die man dann im Verlauf nur für bestimmte Arten von Buchungen benutzt. Das nennt sich dann Kontenrahmen, und kann theoretisch von jedem so gemacht werden, wie er Lust und Laune hat. In der Praxis haben sich aber eine Handvoll Kontenrahmen bewährt, die sogar teilweise soweit standardisiert wurden, das unterschiedliche Firmen mit gleichen Kontenrahmen arbeiten.

Fur mich als Privatanwender hat sich ein Kontenrahmen bewährt, der aus 6 Kategorien besteht

Einnahmen

Irgendwoher muss das Geld ja kommen, und hier finden sich alle Konten wieder, auf denen das Geld quasi " entsteht". Wir erinnern uns: Wenn mein Gehalt auf meinem Girokonto ankommt braucht es ja eine entsprechende Gegenbuchung.

Daher sieht die Buchung dann so aus

2019-03-01 Firma Baumeister
   Einnahmen:Gehalt   -2000.00
   Haben:Girokonto  2000.00

Während mein Girokonto immer voller wird laufen die Einnahmekonten immer mehr ins negative. Was ja auch der Realität entspricht. Wenn ich Gehalt bekomme, wird meine Firma etwas ärmer.

Ausgaben

Das Gegenteil ist der Fall wenn ich Geld ausgebe

2019-03-10  Tankstelle
   Ausgaben:Benzin    50.00 
   Haben:Girokonto   -50.00

Wenn ich von meinem Girokonto eine Rechnung bezahle, dann muss das Geld ja irgendwo "verschwinden", und das tut es ausschliesslich auf Konten der Kategorie "Ausgaben". In Ledger sprich man eigentlich nicht von Kategorien, sondern nur von Konten. Konten können auch Unterkonten enthalten (z.B.) Ausgaben:Nebenkosten:Gas und Ausgaben:Nebenkosten:Wasser. Wenn ich mit diesen Konten nun so etwas buche:

2019-03-09 Stadtwerke
   Haben: Girokonto  -100.00
   Ausgaben:Nebenkosten:Gas  50.00
   Ausgaben:Nebenkosten:Wasser 40.00
   Ausgaben:Nebenkosten: 10.00

Dann sieht man das hier vom Girokonto eine Rechnung von 100 Euro der Stadtwerke bezahlt wurden, die komplett auf dem Konto Nebenkosten gelandet sind. Davon 50.00 auf dem Konto für Gas und 40.00 auf dem Konto für Wasser. Ausserdem hat die Stadtwerke mir noch eine Allgemeine Gebühr von 10.00 berechnet, die ich nicht direkt dem Gas oder Wasser zuordnen kann, die aber doch zu den Nebenkosten gehören. Hier sieht man auch, das eine Transaktion mindestens zwei Buchungen enthalten muss, es dürfen aber auch mehr sein. Sie müssen sich nur zu 0 summieren.

Haben

Ist eigentlich ganz einfach. Hierunter fallen alle Konten auf denen sich üblicherweise Geld befindet, also das Girokonto,das Sparbuch, das Portemonaie. Es ist Geld (oder Werte) das ich habe. Wenn mir ein Konto Zinsen abwirft, handelt es sich sehr wahrscheinlich um ein Haben-Konto

Soll

Das sind quasi Schulden die ich irgendwo habe. In der Regel erkenne ich Soll-Konten daran, das ich Zinsen dafür zahle, denn irgendjemand hat mir hier Geld zur Verfügung gestellt. Typischerweise sind das Baukredite oder die Kreditkarte.

Ausgleich

Ausgleichskonten sind Konten, die es in einer perfekten Buchhaltungswelt eigentlich nicht geben sollte. Leider ist die Welt aber nicht perfekt, Und daher habe ich mir zwei Unterkonten fur Ausgleichsbuchungen angwöhnt

Ausgleich:Einstandsbuchung

Dieses Konto benutze ich genau 1 mal am Anfang der Buchführung, und danach nie wieder. Wenn ich irgendwann heute mit der Buchführung anfange, dann ist ja auf meinem Girokonto bereits Geld, und meine Kreditkarte ist bereits im Minus. Ich buche also auf mein Girokonto das Geld drauf, das heute drauf sein soll, und die Gegenbuchung geht dann halt gegen das Konto Einstandsbuchung.

Hier wird also tatsächlich Geld aus sehr dünner Luft erzeugt. Damit das nicht zum schummeln benutzt wird, Habe ich genau eine Buchung ganz am Anfang, und danach nie wieder.
Ausgleich:Ausgleichskonto.

Da ich auch mein Bargeld (also das Portemonaie) mitverwalte kann es natürlich auch mal passieren, dass ich einfach weniger Geld im Portemonaie habe, als eigentlich laut meiner Buchhaltung drin sein sollte. Mal verliere ich Geld in der Waschmaschine, oder sonstwo, Manchmal taucht Geld unverhofft im Flusensieb wieder auf.

Für all sowas gibt es dieses Konto als Gegenkonto zum Portemonaie. Das Konto sollte so selten wie möglich verwendet werden, und es sollte möglichst wenig von 0 abweichen. Wenn das nicht mehr gewährleistet ist, ist das ein sicheres Zeichen für ein generelles Problem mit der Disziplin beim Buchen, oder beim Ausgeben von Bargeld.

Wenn ich z.B weiss, das ich am Abend vorher 50.00 bei einem feuchtfröhlichen Zug durch die Gemeinde ausgegeben habe, und das auch so buche, mir aber irgendwie 51.00 in meinem Portemonaie fehlen, dann buche ich einfach 51.00 Euro auf das Freizeitkonto, und benutze für den verschwundenen Euro nicht extra das Ausgleichskonto. Erst wenn ich mir das Verschwinden absolut nicht mehr sinnvoll erklären kann, ist das ein Fall fur dieses Konto.

Budget

Eigentlich bringt Ledger von Hause aus eine Funktionalität mit, mit der ich Budgets (also Geld, das für bestimmte Ausgaben reserviert ist) verwalten kann. Leider ist diese etwas beschränkt, was die Flexibilität angeht. Ich simuliere also mittels des Kontos Budget und seiner Unterkonten ein Verfahren, das sich schon bei meiner Großmutter bewährt hat, um Geld fur später an die Seite zu legen: Briefumschläge.

Immer wenn mein Gehalt kommt packe ich In jeden dieser Briefumschläge ein wenig Geld. Und wenn dann die Autoversicherung abbucht, mache ich diesen Umschlag auf, und er enthält genau die Summe, die ich erwartungsgemäss zu zahlen habe. Natürlich fülle ich diese Umschläge nicht wörtlich. Sie existieren nicht einmal. Sie sind lediglich virtuelle Briefumschläge, und das Konto Budget ist ein Unterkonto meines Girokontos. Die Bank kennt dieses Unterkonto nicht. Aus Sicht der Bank habe ich 300 Euro auf meinem Girokonto. Ledger kann mir aber auf diese Art anzeigen, das von diesen 300 Euro sich bereits 180 in einem virtuellen Briefumschlag mit der Aufschrift Autoversicherung befinden, und mir daher nur noch 120 Euro zur freien Verfügung stehen

Die dadurch notwendigen Buchungssätze einer Transaktion können manchmal schon sehr verwirrend wirken, aber mit etwas Übung ist das machbar. Ich werde darauf noch ausführlich eingehen.

Arbeitserleichterungen

Wie schon zu Anfang erwähnt liest Ledger die Dateien lediglich, und wertet sie aus. Zu keiner Zeit schreibt Ledger in eine der Dateien irgendetwas hinein (es gibt eine kleine Ausnahme, die man explizit anfordern muß, und die man fast nie braucht)

Das bedeutet aber auch, dass ich die kompletten Buchungen selbst mit der Hand tippen muss, inklusiver der passenden Gegenbuchungen. die Kontonamen dürfen keine Tippfehler enthalten (was bei Namen wie Ausgaben:Haushalt:Lebensmittel:Biokiste schon mal spannend werden kann) Wenn ich ein Konto einmal Abwassergebühr und einmal Schmutzwassergebühr nenne, dann sind das für Ledger zwei komplett verschiedene Konten, die es dann jeweils einzeln aufsummiert, und niemals zusammenführt

Gegen diese sehr aufwändige und fehleranfällige Tipparbeit hat Ledger nun einige Vereinfachungen auf Lager:

Der Kontenrahmen

Natürlich werde ich mich im Laufe der Zeit mal irgendwann bei einem Kontonamen vertippen. Und bevor ich dann Geld auf irgendwelche Konten namens Ausgaben:Atuovresicherung buche und mich wundere, das auf dem echten Konto keine Veränderung passiert, ist es doch besser, wenn Ledger das kontrolliert.

Ledger lässt sich so konfigurieren, das ich ihm einmal sage, welche Konten ich verwenden möchte, und wie der gesamte Kontenrahmen (also alle meine Konten und Unterkonten) aufgebaut ist. Danach kann ich nur noch diese Konten verwenden. Jeder Tippfehler wird gnadenlos angemeckert, und Ledger weigert sich so lange meine Buchungen auszuwerten, bis der Fehler behoben ist. Gott sei Dank sagt er mir sehr genau, wo das Problem liegt

Aliase

Ein Konto mit dem Namen Ausgaben:Haushalt:Lebensmittel:Biokiste kann beim Tippen schon sehr aufhalten, Daher bietet Ledger die Möglichkeit statt dieser Wortmonster kurze Aliasnamen zu vergeben. Ich muss dann z.B. nur noch "Bio" tippen, und Ledger weiss, das ich dieses Konto damit meine.

Die Leerbuchung

Auch bei Beträgen hat man sich schnell mal vertippt, oder verrechnet, welche Summe eine Gegenbuchung haben muss. Wenn die Stadtwerke von mir z.B. Nachzahlungen haben möchte kann ich einfach schreiben

2019-01-02 Stadtwerke
   Gas 12.34
   Wasser  56.78
   Girokonto

Wie man sieht fehlt beim Girokonto der Betrag, und wenn es bei einer Transaktion exakt ein Konto ohne Betrag gibt, dann nimmt Ledger an dieser Stelle einfach genau den Betrag an, der nötig ist, um die anderen Buchungen auszugleichen. In diesem Fall werden also -69.12 auf das Girokonto gebucht (also 69.12 abgebucht)

Das Standardkonto

Die meisten von uns haben genau ein Girokonto, und alle Bankbewegungen laufen über dieses eine Konto. Da kann es selbst wenn man als Alias etwas so kurzes wie "Giro" verwendet, schnell lästig sein, das zu jeder Transaktion immer wieder dazu zu schreiben. Ledger bietet allerdings die Möglichkeit exakt ein Konto zum Standardkonto zu machen, welches danach immer dann angenommen wird, wenn die Transaktion nicht ausgeglichen ist, und das Konto nicht bereits in der Transaktion verwendet wird.

2019-01-02 Stadtwerke
   Gas 12.34
   Wasser  56.78

ist also ein gültiger Buchungssatz, wenn vorher z.B. Girokonto als Standardkonto vereinbart wurde. In diesem Fall wird automatisch das Girokonto als Gegenkonto genommen, und der entsprechende Betrag, wie im Abschnitt Leerbuchung erklärt ermittelt. Auch

2019-01-02 Stadtwerke
   Gas 12.34

ist damit nun eine gültige Buchung, obwohl die Transaktion auf den ersten Blick die Regel verletzt, nach der eine Transaktion aus mindestens 2 Buchungen bestehen muss. Die 2. Buchung geht hierbei auf das vorher festgelegte Standardkonto

Der Ledger Mode

Wie man sieht hat Ledger schon von Hause aus eine Menge Möglichkeiten, die einem die Tipparbeit erleichtern. Für die Emacs Umgebung gibt es nun sogar den Ledger Mode, der einem die Eingabe noch weiter vereinfacht, indem er z.B. passende Buchungsdaten vorschlägt, oder immer wiederkehrende Buchungen schon nach ein paar getippten Buchstaben vorschlägt, oder gleich vollständig einfügt. Daneben bietet er noch recht komfortable Funktionen um Berichte zu erstellen, oder die gebuchten Daten regelmäßig mit der Realität abzugleichen. Der Ledger Mode wird aber mal einen eigenen Beitrag Wert sein.

Medusa - Die Mutter aller Hydras

Andy Drop — Tue, 14 May 2019 17:56:29 GMT

Medusa

Eines der Probleme aller Texteditoren ist, das sie eigentlich zwei verschiedene Funktionen miteinander vereinbaren müssen, die Erfassung von Text, und die Bearbeitung von Text. Das wir uns nur selten bewusst sind wie verschieden diese beiden Aufgaben sind, ist auch Teil des Problems. Unser Verstand neigt dazu nahtlos zwischen diesen beiden Aufgaben hin und her zu wechseln.

Wir schreiben einen Satz, und noch während wir ihn erfassen, bemerken wir, dass nach dem letzten Wort wohl besser ein Komma gewesen wäre, und der der ganze Absatz vielleicht sowieso besser als Zitat Teil der Einleitung gewesen wäre.

Diese Art zu arbeiten macht es notwendig jederzeit leicht zwischen der Erfassung und der Bearbeitung von Text umschalten zu müssen. Im wesentlichen haben sich dabei 3 Ansätze durchgesetzt. Allen gemein ist, das sich oft die einfachen Funktionen auf eigenen Tasten (Delete, Tab, PageUp, etc…) wieder finden. Fur die komplizierteren Fälle sind üblich:

Die Menusteuerung (z.b. Word) mit dem Problem das man fü die Mausbedienung dann mit einer Hand zwischen Maus und Tastatur hin- und herwechseln muss.
Eine Mehrfachbelegung der Tasten via ALT, CTRL, META, SUPER oder HYPER Tasten. Das ist das Gebiet auf dem Emacs zu Hause ist.
Ein Leaderkey, also eine Taste die in normalem Text nicht vorkommt, und daher zum Umschalten in den Bearbeitungsmodus dient. Dies ist die Domäne von VIM

Spacemacs und der Leaderkey

Genau wie ich halten auch die Macher von Spacemacs die Idee mit dem Leaderkey, für den Weg den sie gerne gehen wollen. Sie haben daher das Konzept so weit es ging übernommen und als Konfiguration über ein vorhandenes Emacs gestülpt. Der Charme besteht darin, dass dadurch keine der üblichen Funktionen in Emacs beeinflusst wird und nun beide Arten der Bedienung nebeneinander existieren können. Was dabei in meinen Augen leider verloren gegangen ist, ist der systematischere Aufbau der Funktionen wie sie Emacs üblicherweise mitbringt. Die von Spacemacs ausgelieferten Hydras (eine Art visuelle Menüführung) scheinen in meinem Kopf nur selten sinnvoll, oder leicht zu merken

Thing at point

So erscheint z.B. immer die gleiche Hydra, wenn ich den Leaderkey drücke, dabei lassen sich in Emacs unzählige Bedienmodi auswählen, die jeweils völlig unterschiedliche Möglichkeiten der Interaktion erfordern.

In einem Blogeinrtag von Derek Feichtinger habe ich neulich eine sehr elegante Lösung gefunden, die nicht nur fü die einzelnen Modi verschiedene Hydra zur Verfügung stellen kann, sonder auch noch in der Lage ist, in dem sehr beliebten Org Mode festzustellen ob sich der Cursor auf einem Objekt (wie z.B. einem Link oder einer Tabelle) befindet, und dann eine Hydra speziell für dieses Objekt aufzurufen.

Fallback

Das elegante an dieser Lösung ist, das sie zum einen sehr leicht zu erweitern ist, und zum anderen auch die Möglichkeit besteht weiterhin eine Standard-Hydra aufzurufen, wenn keiner der besonderen Fälle vorliegt.

Das bietet gerade auch in der Kombination der verschiedenen Hydras ungeahnte Möglichkeiten. Mein Leaderkey ist zum Beispiel die <menu> Taste, die normalerweise rechts der Leertaste zu finden ist, und bei Windows das Kontextmenü aufruft. Unter Linux hatte die bei mir sowieso noch nie eine sinnvolle Funktion

In jeder einzelnen Hydra belege ich wiederum die <menu> Taste mit der am häufigsten benutzten Funktion. Dadurch kann ich mit dem zweimaligen drücken der Menu Taste z.B. im Org Mode das geiche tun, was sonst Ctrl-C Ctrl-C tut, während im Ledger Mode eine neue Buchung angelegt wird.

Auch hier funktionieren, wie bei der Spacemacs Lösung, weiterhin alle eingebauten Emacs Tasten weiterhin wie gewohnt, Ich habe mittlerweile alle Hydras, die ich bisher so erstellt habe in das Medusa Projekt integriert, die Sourcen finden sich hier.

My perfect typing environment. Finally.

Andy Drop — Mon, 22 Oct 2018 22:00:00 GMT

If you have read my earlier articles about my search for the perfect keyboard, you may have got an idea of what I was looking for. Namely a mechanical keyboard with a decent keyboard layout, optimized for my use case. I mostly do my writing with Emacs, and a lot of it is german text and programm code. In the meantime I found my perfect solution, and realized I had no article of it in my blog. So this is it, maybe it is of use for some of you.

The keyboard

My decision finally zeroed in on buying a conventional keyboard with MX-Switches, as they have that exact tactile feeling that is deeply satisfying while I type. They are a bit loud for an office environment with colleagues around, but as I only use the keyboard at home it is ok. I ordered it with some touch of my personal coloring taste, and a special keyboard layout, that I gave some thought beforehand.

The thoughts

Some of the thoughts I had, before I ordered the keyboard, were going into the use cases I have, and in the constraints that a normal keyboard is delivering to this use cases. Namely:

I type a lot of programming code

The optimal keyboard layout for that would be most probably an american, because most programming languages were developed with an american keyboard in mind. Characters like [, { or | are easily reachable on those keyboards. Sadly
I write a lot of german text

and that means I absolutely want to have Umlauts in my layout. The german layout has those keys to the right of the keyboard, where they rule out some of that keys that are crucial for programming on an american board. As a consequence the german layout makes heavy use of the AltGR key to shift into a layer in which those keys are reachable. Unfortunatly this key is normally pressed with the least sensible finger, the pinky. Which leads me to the next issue,
I write in Emacs

The Emacs community has a concept that is called "Emacs pinky syndrome" and refers to he fact that Emacs makes heavy use of all your auxiliary keys like Shift, Ctrl or Alt. there is an often quoted saying, that Emacs is just an abbreviation for Escape-Meta-Alt-Ctrl-Shift. And for most of that keys you have to press some letters with your left pinky on one of that keys. Sometimes even more than one of it.

The layout

The gist of that matter was space. I needed the space for the german Umlauts, as well as those coding keys, that are to find in an american layout. Oh, and more Meta-keys would be of help for Emacs, to eliminate those long key combinations that are hard to memorize.

The solution got in reach, when I realized that I nearly never use the numbers in the numbers row at the top of the keyboard. Instead of there, I type them on the number pad to the right. And there it was: SPACE, THE FINAL FRONTIER! Ah, and nobody needs CapsLock either.

So I began to move all those keys that are only reachable via the AltGr key to the upper number row, leaving as much characters as possible in place that were already in the top row except numbers. All brackety chars ({[<>]}) are now on only 4 keys (7,8,9,0) which causes the only relocation that was needed. The = char had to move to the right to give way for the >, and so also the ? had to move and I chose to place it on the key where the 1 once was, so it is right below the !.

Following the same idea the ' was placed on the same key as the " so I have all quoting chars on one key, To use the normal chars used for quoting a string there is now no need for a Shift key anymore. That made place for the ~ which moved a key down, and can now be typed with just Shift instead of the pinky-heavy AltGr.

The only two keys left where now the | which I moved to the same key as the & (both are used in many programming languages as logical AND and OR). The now empty key on the lower left became home to the backslash, together with the normal slash as the un-shifted key. The @ sign found it's home at the place of the former 3 together with the Euro sign when shifted.

You can see the result in the following image:

To make Emacs a little bit easier to use I also made CapsLock the Super-key and the now unneeded AltGr became the Hyper-key. The Alt-key was named Meta (that would have been the correct name for it's function anyways).

Conclusion

Within two weeks I had fully memorized the positions of the moved keys, and I don't mix them up with the traditional layout I use at the office computer. This risk was, what held me back from using the NEO Layout, which is also optimized for Germans and programming use.

The Super and Hyper keys are great when using Emacs. I made me a still growing set of Hydras and mapped it to the Hyper key (Hyper/Hydra made it very easy to memorize). The Super key becomes more useful to call whole Emacs modes like mu4e, magit or calendar modes.

As a side effect I never get stuck in CapsLock anymore, so no more badly typed password three times in a row.

The feeling that "something is wrong" while I type had completely gone, and now it feels so naturally, that i'm far less distracted, and could finally better concentrate on the content.