Plain DrOps

An Org File working as a Config-File

Andy Drop — Thu, 13 Aug 2026 10:00:00 GMT

You may have noticed on the Fediverse that I haven't been trying to permanently configure my Stream Deck lately. Instead, I've built my own solution.

This solution consists of two components. First, a client running on my phone that displays 32 buttons with small images on the screen. Second, a server called DeckServer that pushes different button layouts (which I would normally see on the Stream Deck) to this client.

The Problem

The DeckServer runs as a background service with no user interface. To configure the buttons it should push to the client, I would normally need a small program with a GUI where I could assign images to individual buttons, define which commands each button should execute, and manage switching between layouts.

However, after some thought, I realized there's a much simpler solution. After all, I live in my Emacs editor, especially in Org-mode.

Org-mode files, like Windows configuration files, are hierarchical but can manage many more levels.

A typical hierarchy in Org-Mode could look like this:

Main (e.g. = Stream Deck Buttons=)
- Subcategory* (e.g. ** Layouts)
  - SubSubcategory* (e.g. *** Button 1)
    - Attributes (e.g. :BILD: ~/bilder/start.png, :Befehl: systemctl start ...)
- Navigation (z. B. ** Layout-Wechsel)

A key feature of Org-mode that worked well for DeckService configuration is tables.

The Solution

Tables in Org-Mode are constructed using = | = (pipe), = = (hyphen), and = + = (plus):

| Spalte 1 | Spalte 2 | Spalte 3 |
|----------+----------+----------|
| Wert A   | Wert B   | Wert C   |
| Wert D   | Wert E   | Wert F   |

Rows: Each row starts and ends with = | = .
Separator line: A line with = = (at least 2) and = + = defines the columns.
Alignment : When entering data, Org-Mode automatically aligns columns based on the longest entry.

If you make changes (e.g., a longer command), Org-Mode adjusts the column width accordingly.

| Name     | Befehl          | Icon          |
|----------+-----------------+---------------|
| Start    | systemctl start | ~/icons/start |
| Stop     | systemctl stop  | ~/icons/stop  |

o, I simply wrote a layout in Org Mode exactly as I wanted it. To do this, I wrapped it under two headings. At the top level, just the word Layout, and below it, a heading with the name of this specific layout.

* Layouts
** Haptmenü 
|--------+------+----------+-------+--------+-------+--------+---|
| Home   | Mail | Internet | Emacs | Musik  | Video |        |   |
|--------+------+----------+-------+--------+-------+--------+---|
|        |      |          |       |        |       |        |   |
|--------+------+----------+-------+--------+-------+--------+---|
|        |      |          |       |        |       |        |   |
|--------+------+----------+-------+--------+-------+--------+---|
| Zurück | Stop | Pause    | Vor   | Leiser | Stumm | Lauter |   |
|--------+------+----------+-------+--------+-------+--------+---|

In the third level, I then compiled the properties for each of the buttons labeled above under their own respective headings. For example, it looked like this:

*** Home
:PROPERTIES:
:Label: Home    
:Image: /home/andy/ablage/icons/WhiteOnBlack/128/Very-Basic-Home-Filled-icon.png
:Actions: Layout
:Parameters: Home
:Color: #000000
:END:

*** Emacs
:PROPERTIES:
:Label: Emacs    
:Image: emacs.png
:Actions: Layout, Execute
:Parameters: EmacsMain, emacs
:Color: #000000
:END:

As you can see, for each button, it is defined what label should appear on it, which image to use, and what should happen when the button is pressed. In the case of the Emacs button, for example, the layout switches to the EmacsMain layout, and then the command emacs is executed on the command line.

The Advantages

The advantages are obvious:

If I spontaneously think of additional configuration options, I can simply add them to the file and tweak the parser in the server for this file a little.

If I want to create another layout, I just copy an existing one and change the labels in the table. Done.

For buttons that do similar things, I can simply copy them and directly modify the differences.

All of this in the editor that I have open all day anyway: Emacs.

A field trip into vibe coding: The SpaceCadetDeck

Andy Drop — Wed, 29 Jul 2026 09:00:00 GMT

Currently, I need to familiarize myself with a lot of new technologies. I’m not fluent in Android or web development, and modern languages like C# are also on the agenda. Add to that the omnipresent topic of AI - I have opinions but little experience. So, I decided to start a project to change that.

The Project

The idea practically presented itself. After moving and setting up my workspace, I rediscovered my Stream Deck. While it mostly worked, it had constant quirks. The old software is no longer compatible with my system, and the new one, though functional, often dies after my PC goes into deep sleep. Not ideal.

So, I sat down to solve both my Stream Deck problem and learn AI - by building my own solution: the SpaceCadetDeck.

I didn’t want to dive deep into Stream Deck tech, though. Instead, I repurposed my Fairphone 6 (running /e/OS) as a touch-based 4x8 button grid. It’s portable, customizable with icons, labels, and colors, and perfect for the job.

The phone as a Stream Deck

Now, as mentioned earlier, I don’t know Android programming at all. I’ve looked into it before and found that you practically need to know Java for it. A language I could learn, but don’t really like the style of. At some point, I read about a language called Kotlin. With which you can also program this. I looked into it more closely. As a language, I prefer it more, so I decided to learn Kotlin.

But before I learn it, I’m diving into the biggest of the small individual experiments. I want to create a Kotlin project using AI that somehow turns my phone into a Stream Deck. Without me writing a single line of Kotlin myself. That means I can’t control the AI at this point and have to trust it to do the right thing. I give it relatively free rein. I check every command it wants to execute beforehand so it doesn’t mess up my system. But content-wise, I know absolutely nothing and can’t judge what it’s doing except by looking at the result.

The program running on the phone should be relatively simple. It receives a button layout for the 32 buttons it should display from a server on the PC and simply reports back to the server which of these buttons were pressed. So only two tasks: receive layout, send button presses. Everything else happens on the PC that is being controlled.

The AI I chose was Matrix-Vibe. Simply because, unlike many others, it’s a European product, and I can get an insight into the state of the art on my continent.

The Linux PC as a server

On the other side, I wanted to create a project in a language I’m familiar with so I can look at the generated code and assess how its quality compares to what I would write myself. That’s why I chose Python for the server, and this server called DeckServer has a few more tasks.

It provides a WebSocket server for the Android system client to connect to.
It receives button presses from the Android client and performs the appropriate tasks based on the previously sent layout, such as starting programs, switching layouts, switching to windows, adjusting volume, etc.
And most importantly, of course, it has to send the configured layouts to the Android client.

The first Vibe Coding Session

I developed both projects in parallel, each in a separate window.

The Android client is very straightforward based on the requirements: I’d like 4x8 buttons. I want to receive the layout and send button presses - all via WebSocket, which I’d like to be configurable at startup. I also want these settings to be remembered between program starts. After a net time of about 45 minutes, it was developed to the point where I could install it on my phone, and it worked right away.

The server’s requirements are naturally a bit more extensive, and I also sought more advice on individual points. The WebSocket connection was changed to a secure connection. For debugging purposes, I added the ability to send the USR1 signal to the server to force it to resend its layout. I also thought about how to configure the button layouts. All in all, it took about four hours.

Then I slept on it overnight, thinking about how I could configure the button layout. I came up with the idea of not writing a program for it at all but storing all layouts in a configuration file. If I write this configuration file in Org-mode - which is built into Emacs, which I already use - then I can simply write the button layout as a table directly in the configuration file.

In the next coding session, I worked with Matrix Vibe to build the exact format of this config.org file. Additionally, I had the code generated that is needed to parse this file format.

The file then looked something like this:

* Global
:PROPERTIES:
:Port:: 8766    
:Host:: 0.0.0.0
:UseSSL:: True
:CertFile::
:KeyFile::
:GenerateCert:: True
:PingInterval:: 20
:PingTimeout:: 60
:END:

** Buttons

*** Home
:PROPERTIES:
:Label: Home    
:Image:    
:Actions: Layout, Dance,Execute  
:Parameters: Home,, Programname
:Color: #FF0000
:END:


*** Bäh
:PROPERTIES:
:Label:    
:Image:    
:Actions: Activate  
:Parameters: Terminal
:Color:
:END:


* Layouts
** Home                                         :default:

|------+------+---+------+-----+---+---+------|
| Home | Link |   | Helm |     |   |   |      |
|------+------+---+------+-----+---+---+------|
|      |      |   | Bumm |     |   |   |      |
|------+------+---+------+-----+---+---+------|
|      |      |   |      | Bäh |   |   |      |
|------+------+---+------+-----+---+---+------|
|      |      |   |      |     |   |   | Test |
|------+------+---+------+-----+---+---+------|

*** Link
:PROPERTIES:
:Label:    
:Image:    
:Actions:   
:Parameters:
:Color:
:END:

*** Helm
:PROPERTIES:
:Label:    
:Image:    
:Actions: Layout  
:Parameters: Emacs
:Color:
:END:

You can already see how easy it is to create a layout here. Emacs helps you keep the table in a nice rectangular format.

After two coding sessions with a total of around 8 to 10 hours, both the server and client were ready for use.

What’s next

Apart from the fact that some more functions still need to be added to the server, such as D-BUS capability so I can detect context changes in the system and display other layouts accordingly, the software is largely finished.

Now I’ll sit down and take a closer look at both the generated Python code and the generated Kotlin code. The Python code mainly for quality, style, and similar things, the Kotlin code to learn myself how such programs are structured, how they work. Which files I need and how they all work together.

The agent was an incredible help when it came to documenting the entire project. The README was automatically generated for my Git repository. I could have the commit messages generated and all changes were listed without missing a single one.

I can definitely understand why Vibe-coding is so appealing. Fast results when you’re able to describe your project precisely. From experience I’ve had with project managers so far, though, I have to say that’s exactly why you need a programmer for it.

I’m of course aware of the technical and social implications of AI, and each one is enough to deter me from professional use. In the long term, though, I think the problem will solve itself economically. And whether my talent as a normal programmer will still be in demand then remains to be seen.

When Johnny.Decimal and My Brain Fell Deeply in Love

Andy Drop — Mon, 20 Jul 2026 12:00:00 GMT

I’ve long been searching for a system to help me not just manage my digital collections, but actually use them meaningfully. At some point, I stumbled upon the Johnny Decimal System - an approach that seemed logical and well-thought-out at first glance. Clear numbers, clear categories, everything in its place. Sounds perfect, right?

I started my trial phase by converting part of my document collection to Johnny Decimal.

Why Johnny Decimal Was a Good Starting Point

The Johnny Decimal System showed me how important clear structures are. Each category has a number, each area has its place. This helped me organize my thoughts and manage my files deliberately rather than just dumping them somewhere. The simplicity of the system was a major advantage: no unnecessary clutter, no redundant subcategories—everything has its place.

And yes, it was a good start. The fact that Johnny Decimal uses numbers worked in my favor, since I actually have a pretty good memory for them. Plus, the system has clear hierarchies, which should work well with my brain that thinks in trees.

But here’s the catch: I’m not a fan of overly rigid systems. I like flexibility. I like being able to adapt things without feeling like I’m breaking rules.

Where It Stopped Working for Me

But as often happens in life, "good" eventually isn’t enough. I realized I didn’t quite fit into the rigid structures. Not because the system is bad—on the contrary, it’s well-designed and functional. But I’m me. And I work best when things aren’t just functional but also made for me .

My issue with Johnny Decimal led me to think deeply about what I actually expect from a filing system. Essentially, I need fast storage and retrieval of documents. That means the directory tree must be quickly navigable.

My Own System: A Logical Evolution

So what makes a Johnny Decimal tree so easy to navigate? After some thought, the answer was clear: the path can be quickly auto-generated from just a few initial characters. I only need to type a minimal number of characters, then press Tab to auto-complete the rest. I have to conclude that

Once I understood this, I built my own variant. It requires a bit of discipline and creativity when setting up the folder structure, but it’s just as fast to navigate. I simply ensure that each level of my directory tree is designed so that all directories start with a different letter. So, if there’s already a folder called "Finanzen" (Finance), and I want to create one for my company, I won’t name it "Firma" (Company) because "F" would be duplicated. Instead, I might use "Beruf" (Profession).

On top of that, I try to use the first terms that come to mind—ideally short ones—in case I ever need to enter them somewhere without auto-completion.

My home directory, for example, looks like this:

+├── 3d  
+├── aud  
+├── Bildschirmfotos -> /home/andy/img/Screenshots  
+├── blog  
+├── cloud  
+├── doc  
+├── ebooks  
+├── fin  
+├── fotos  
+├── geo  
+├── img  
+├── INBOX  
+├── music  
+├── org  
+├── prj  
+├── rezepte  
+├── Schreibtisch  
+├── slides  
+├── snap  
+├── Sync  
+├── todo  
+├── vid  
+├── Vorlagen  
+└── wiki

As you can see, there are occasional overlaps with the first letter. I usually handle this by capitalizing one of the terms.

Why This Works for Me

In the end, it’s not about finding the "perfect" system. It’s about finding one that works for me . My system might not be revolutionary, but it’s mine. And that’s the key difference.

It feels right because I don’t feel like I’m breaking rules when I adjust something. It grows with me because my needs change, and the system changes with them. And it’s my system because I didn’t just adopt it—I built it myself. And that gives me a sense of control and ownership.

Conclusion: The Best Approach Is the One That Fits You

Johnny Decimal was a great starting point. But as with so many things in life, it’s not about blindly adopting something—it’s about making it your own. My system is a tribute to the strengths of Johnny Decimal, but it’s also proof that sometimes you have to break the rules to get what you truly need.

Who knows? Maybe this is just a temporary stop. Maybe I’ll change everything again in a year. But that’s the beauty of it: it’s my system. And I can change it as often as I want.

Nomen est omen - and since a child usually needs a name, this illegitimate offspring of Johnny Decimal is simply called Andy Alpha.

Hoarding and Herding

Andy Drop — Mon, 13 Jul 2026 12:00:00 GMT

I still remember well how I used to save everything: music, photos, eBooks, documents – just everything. The fear of missing out or losing something was simply too great. But at some point, I realized: I had everything, but I wasn’t using any of it. The shift from hoarding to tending was a real liberation for me.

Hoarding vs. Tending

Back then, I just collected everything without thinking. The result? A huge mess. I no longer knew what I actually had, and when I searched for something, it was often hopeless. In the end, I had a data graveyard instead of a usable archive.

Today, it’s about actively maintaining and using my collections. Every file has its place and purpose. With clear structures and a little appreciation for what I truly need, everything stays organized and useful.

How I Tend to My Collections

Principles

For me, tending means that every file has its fixed place, and I know why I keep it. I regularly spend time tidying up: deleting what I no longer need, archiving what’s important, and updating what’s outdated. What’s especially important to me is maintaining the metadata in the files. This way, I always have all the information at hand, no matter where I use the files. For this, I often write small programs to take the work off my hands. Tools like Org-Mode, Notion, or my own solutions like the Book Sorter project help me with this.

Practical Steps

I prefer working with tree structures – my brain just likes that. Every file has its place in a logical hierarchy. To find everything quickly, I use tags. And to avoid manually sorting all the time, I automate as much as possible. For example, with scripts that move new downloads directly to the right place.

My Collections in Detail

Music

My music collection is currently about 68 GB in size. I chose MP3 because it’s playable almost everywhere. The files are stored in a tree structure: ~/music/Genre/Artist/Album/XX Songtitle.mp3. The XX represents the track number on the album – if available. As a tree, it looks like this:

Pop/
├── Adele
│   ├── 21
│   │   ├── 01 Rolling in the Deep.mp3
│   │   └── cover.jpg
│   └── Skyfall
│       └── 02 Skyfall (instrumental).mp3
├── Alanis Morissette
│   └── Jagged Little Pill
│       ├── 01 All I Really Want.mp3
│       ├── 02 You Oughta Know.mp3
│       ├── 03 Perfect.mp3
│       ├── 04 Hand in My Pocket.mp3
│       ├── 05 Right Through You.mp3
│       ├── 06 Forgiven.mp3
│       ├── 07 You Learn.mp3
│       ├── 08 Head Over Feet.mp3
│       ├── 09 Mary Jane.mp3
│       ├── 10 Ironic.mp3
│       ├── 11 Not the Doctor.mp3
│       ├── 12 Wake Up.mp3
│       ├── 13 You Oughta Know (Jimmy the Saint Blend) _ Your House.mp3
│       └── cover.jpg

I wrote a Python program that runs through my entire directory tree and generates tags from the path names where none exist yet. This means I can simply copy new songs into the directory structure, run the program once, and the new songs are already tagged with meaningful entries.

Photos

My photos take up about 67 GB of space. Here too, I rely on JPEG because it’s the most universal format. The structure is similar ~/img/fotos/Year/Year-Month-Day/ISO-Timestamp.jpg. This way, I can find every photo quickly by date. As a tree, it looks like this:

2025
├── 2025-04-10
│   ├── 2025-04-10T16:53:35.jpg
│   ├── 2025-04-10T16:53:43.jpg
│   ├── 2025-04-10T16:53:54.jpg
│   └── 2025-04-10T16:54:07.jpg
├── 2025-04-14
│   └── 2025-04-14T12:48:22.jpg
├── 2025-04-17
│   └── 2025-04-17T20:40:33.jpg
├── 2025-04-25
│   └── 2025-04-25T09:30:41.jpg
├── 2025-04-26
│   ├── 2025-04-26T14:29:16.jpg
│   ├── 2025-04-26T18:16:10.jpg
│   ├── 2025-04-26T18:16:30.jpg
│   ├── 2025-04-26T18:16:34.jpg
│   ├── 2025-04-26T18:20:30.jpg
│   ├── 2025-04-26T18:20:36.jpg
│   ├── 2025-04-26T18:22:01.jpg
│   ├── 2025-04-26T18:22:37.jpg
│   └── 2025-04-26T20:14:18.jpg
│   ├── 2025-05-14T19:55:05.jpg

For photo management, I mainly use a small shell script that sorts freshly downloaded images from my camera into a folder structure based on the metadata in the image. In every image, I store the time when taken, and for photos from my phone, I also store the location unless I explicitly disable it. For manual editing and managing the images, I use the program DigiKam, as it can write metadata back into the photos and also recognize faces.

eBooks

My eBooks take up about 60 GB. I mainly use EPUB and PDF because these formats work on most devices. The structure is a bit more complex: ~/ebooks/Genre/SubGenre/SubSubGenre.../Series/Title -- Author.epub. This helps me keep track of my many books. As a tree, it looks like this:

science fiction/
├── fermi's progress
│   ├── dyson's fear -- chris farnell.epub
│   ├── descartesmageddon -- chris farnell.epub
│   ├── planet of the apiaries -- chris farnell.epub
│   ├── the phone job -- chris farnell.epub
│   ├── fermi's progress -- chris farnell.epub
│   └── fermi user manual annotated -- chris farnell.pdf
├── mind control -- finn, thomas.epub
├── monk and robot
│   ├── psalm für die wild schweifenden, ein -- becky chambers.epub
├── the expanse
│   ├── abaddons tor -- james corey.epub
│   ├── calibans krieg -- james corey.epub
│   ├── leviathan erwacht -- james corey.epub
├── the further adventures of sampson 39 -- chris farnell.epub
├── the murderbot diaries
│   ├── home_ habitat, range, niche, territory -- martha wells.epub
│   ├── rapport_ friendship, solidarity, communion, empathy -- martha wells.epub
│   ├── all systems red -- martha wells.epub
│   ├── artificial condition -- martha wells.epub
│   ├── exit strategy -- martha wells.epub
│   ├── fugitive telemetry -- martha wells.epub
│   ├── network effect -- martha wells.epub
│   ├── rogue protocol -- martha wells.epub
│   ├── system collapse -- martha wells.epub
├── wayfarers
│   ├── a closed and common orbit -- becky chambers.epub
│   ├── galaxie und das licht darin_ ausgezeichnet mit dem kurd laßwitz preis 2023, die -- becky chambers.epub
│   ├── record of a spaceborn few_ wayfarers 3 -- becky chambers.epub
│   ├── the long way to a small, angry planet_ the most hopeful, charming and cosy novel to curl up with -- becky chambers.epub
├── zero gravity -- schuhmacher, nicole.epub

To manage my eBooks, I naturally use Calibre. This program stores all its books in an internal folder structure that cannot be modified, but it does have an export function that allows me to determine the structure of the export paths – meaning where the author and book title should appear in the path. There, I can also specify a genre or book series. For genres, I use the typical categories known from the book trade.

The book trade categories are structured in multiple levels, such as non-fiction, chemistry, organic chemistry. Unfortunately, I can’t enter complete paths in the genre field. So, I wrote a tool that takes the deepest category – organic chemistry, for example – and, after exporting, recreates the full path, including non-fiction and chemistry above it. It reads an Org file where I’ve stored my adapted book trade structure and adjusts the paths accordingly.

I then copy this folder structure to my eBook reader. The goal is to ensure that even eBook readers that don’t natively support stable folder creation can handle a hierarchical structure. Additionally, I can use my program for visualizing eBooks in such a way that a new shelf is started for each main category.

Documents

My documents take up about 1.5 GB. Here, I use PDF because it can be opened almost anywhere. The structure is ~/myfolderstructure/ISODATE_Type_Sender_Content.pdf. The ISO date at the beginning helps me sort everything chronologically.

The documents folder has the wildest structure. Essentially, I store scanned incoming mail there – these are the PDF documents that reside there. But I also store outgoing mail there, which is why you’ll also find text or Open Document formats.

This tree structure has grown organically over the past ten years. I use it in several places, both for directories and for folders in my mailbox. And it has largely proven itself. If you look closely, you can still see remnants of attempts to better organize everything. But wherever I work on the files, I’ve since reversed those changes.

As a tree, it looks like this:

.
├── Beruf
│   ├── Bewerbung 
│   │   └── lebenslauf.odt
│   ├── 2017-10-17_Abfindung.pdf
│   ├── 2017-10-18_Arbeitsbescheinigung.pdf
│   ├── 2025-08-17_Arbeitsvertrag.pdf
│   ├── 2025-12-31_Zwischenzeugnis.pdf
│   ├── 2026-04-23_Laufzettel.pdf
├── Familie
│   ├── Familienstand
│   │   ├── Hochzeit
│   │   │   ├── 2003-11-15_Heiratsurkunde.pdf
│   │   │   ├── 2025-09-12_Aufgebot.pdf
│   │   │   └── 2026-05-29_Heiratsurkunde.pdf
│   │   ├── Todesfall
│   │   │   ├── Beerdigung
│   │   │   ├── 2016-08-11_Sterbeurkunde.pdf
│   │   │   ├── 2016-08-12_Angebot_Bestatter.pdf
│   │   │   ├── 2016-08-18_Einäscherungsurkunde.pdf
│   │   │   ├── 2016-08-25_Baumvertrag_a.pdf
│   │   │   ├── 2016-08-25_Baumvertrag.pdf
│   │   │   ├── 2016-08-25_RE_Hankemeier_Bestattung.pdf
│   │   │   ├── 2016-08-26_Beisetzungsurkunde.pdf
│   │   │   ├── 2016-09-30_ErbscheinMitVorblatt.pdf
│   │   │   └── 2016-09-30_Erbschein.pdf

I will definitely write a separate article about this structure. It will explain in detail why I chose each folder the way it is today. This will also bring me closer to the topic of plaintext than is the case in this article.

Conclusion

For me, herding means taking responsibility for my digital collections. It’s not about just filling up storage space, but about consciously handling what I preserve. This gives me a good feeling and even saves me time in the end.

What I Expect from an Editor as a Programmer

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

For the past 25 years, I’ve primarily worked with just one program editor in my professional life: the VB6 editor. But my journey began much earlier - in the early 90s. Back then, things were a bit simpler, or at least more straightforward.

Initially, it was just a plain text editor. The first environment worthy of that name was PDS 7.1, Microsoft’s BASIC Professional Development System, which-despite running under DOS-already featured the window layout we still know today from Microsoft environments like VB to Visual Studio, and which has been widely adopted. In that environment, I felt right at home.

And that’s exactly what I’m trying to analyze in this article: What was it that made me feel that way? What do I expect from my programming editor? And how can I configure Emacs to seamlessly handle all these tasks?

Window Handling

As a rule, I work with just one or, at most, two windows for the code-and only when I need to see multiple code sections in parallel. In addition, I need a window where I can see the project tree and expand or collapse it. Ideally, there would also be a window that gives me an overview of the individual functions and classes in the currently displayed file, so I can quickly navigate within the file. Flexible window management is essential for me, without getting lost in too many windows.

Navigation

By navigation, I mean everything that helps me quickly get to the point in the code I currently need, and ensures I don’t see any code that isn’t relevant to me at that moment. That’s why I also consider code folding to be part of navigation.

I want to be able to jump up and down in the code tree, as well as navigate level by level. If I’m in a function, I want to be able to press a key to jump to the class header and collapse that class if I need to focus on another one. Jumps to the beginning and end of a file should go without saying. It would be great to have jumps to the point where a variable is declared. Or, in the case of programming languages with header files, to be able to jump back and forth between the file and its header file, or between the file and its associated test file-because sometimes you work on code and on the corresponding tests in parallel.

Additionally, I want to be able to navigate in the file tree, either by directly calling up the file or by using meaningful shortcuts to jump to the appropriate folders.

Editing

When it comes to editing, it’s the little things that make the workflow easier: When I type an opening bracket, a closing one should be automatically inserted. Different bracket levels should be displayed in different colors so I can immediately distinguish them visually. I’m the kind of person who uses tabs while editing-but tabs in the code are simply ugly to everyone else. That’s why it’s important that I can use tabs while editing, but they are automatically converted to spaces when saving. This needs to work flawlessly, especially in languages like Python, where indentation has semantic meaning.

Autocompletion / Intelligent Support

Autocompletion is another exciting topic. What I’ve always used is something like IntelliSense: As soon as I start typing the beginning of a variable or function I’ve already used, the full name is suggested. The key here is to have neither too many options to choose from nor to miss important ones. Precise, context-sensitive autocompletion supports me without overwhelming me.

Snippets

Here, I still dream of a universal snippet language. I want to be able to insert text blocks where I can use variables, similar to what Cookie Cutter allows. Additionally, while writing, I want to be able to create short text snippets like an if-block or a select-case block in Visual Basic-or comparable structures in other languages-using a two- or three-letter combination. Ideally, all these blocks that do the same thing in different languages would use the same abbreviation. That’s why I call it Universal Snippets. This flexibility would help me speed up my work without worrying about language-specific details.

Trial Run

The trial run is actually quite simple: I want to be able to compile and start the program from my editor-and then play around with it. Depending on the programming language, this may require some intermediate steps. These should happen automatically under the hood so I can focus on what’s essential: testing and trying out my code.

Debugging

When it comes to debugging, I’ve experienced just about everything. The most spartan way to debug is probably to insert a Beep somewhere in the program code and see if it beeps during execution. Console outputs that I write directly into the code are only slightly more comfortable. But what I really want is to be able to step through the code meaningfully: Step In, Step Over, Step Out. I also want to be able to view the status of various variables.

Setting breakpoints is essential for me-not just at fixed points in the code, but also based on expressions. For example: a breakpoint when an expression is true, or a breakpoint when the value of a variable changes. So I don’t want to stop when the value of variable a is equal to 7, but rather whenever it changes from its current value to any other value. This is something my ancient Visual Basic 6 could do, but many modern development environments lack.

It’s also important to me that I can see compiler or parser error messages directly and jump to the corresponding file and line with a click.

Testing

Nowadays, almost all modern programming languages come with an integrated testing framework. And I think that should be used. I want to be able to use these testing frameworks directly from the editor so I can run my tests quickly and efficiently. It would be great if I didn’t have to run the entire test suite every time, but could instead run just the current file and its associated tests. This way, I can work in a targeted manner without wasting unnecessary time.

Git Integration

For Git integration in Emacs, there’s Magit-do I need to say more? It just works and is solid. The only area where I’m a bit spoiled is diffing: No matter which machine I’m on, I use Beyond Compare by Scooter Software. For me, it’s the ultimate diffing tool. If I could create something comparable in Emacs, that would be amazing. I haven’t managed to do that yet, though.

A cool feature for Git integration would be if every time I save, an internal Git commit is created in the development branch I’m currently working in. Then, if I’ve saved 27 times by the end of the day and decide to keep that state, I can squash those commits and end up with a single clean commit.

Deployment

With deployment, it’s like this: Sometimes it’s part of Git integration through hooks like on GitHub. Other times, it has to be done manually. If I have to do it manually, I’d like to be able to select targets. And the whole thing should be closely integrated with Git.

Refactoring

I’ve listed refactoring separately here. Even though I sometimes do it directly while editing code, it makes more sense to sit down at regular intervals and focus solely on refactoring. When I want to restructure something, most of it is cut, paste, and rewrite. But what would help me tremendously is if I could be sure that I can search and replace variable or class names across the entire project-without the project blowing up in my face.

My Conclusion

In the end, it’s not about finding the "perfect" editor-it doesn’t exist. But it is about having an editor that supports me rather than holding me back. A tool that helps me work faster and more efficiently, without constantly having to wrestle with it. With Emacs, I have the opportunity to create exactly that kind of environment for myself.

And yes, I know I’m demanding. But if I’m going to spend eight hours a day in front of a screen, I at least want a tool that doesn’t drive me insane.

In future articles, I’d like to delve into each of these sections individually and take a close look at what solutions Emacs offers, what small functions I might be able to write myself, or where there’s still room for clever workarounds.

EmacsWiki Blog Carnival "Programming"

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

Emacs is more than just a text editor - it’s a full-fledged programming environment that can be perfectly tailored to your needs. Whether you’re working with Python, C++, Lisp, Rust, or JavaScript, with the right configuration, Emacs transforms into a powerful IDE, offering everything you need for efficient coding: syntax highlighting, debugging, version control, REPL integration, and much more.

But how do you use Emacs as a programming tool? Which packages, settings, or workflows make your daily coding more productive?

Possible topics—or bring your own ideas:

Language-Specific Setups: How do you configure Emacs for your favorite language? Which packages (e.g., lsp-mode, flycheck, company) are indispensable for you?

Debugging & Testing: How do you integrate debuggers (e.g., realgud, dap-mode) or test frameworks directly into Emacs?

Project Management: How do you organize large codebases in Emacs? Do you use tomagitike projectile, magit, or forge for Git workflows?

REPLs & Interactive Development: How do you work with REPLs (e.g., for Python, Clojure, or Haskell) directly in Emacs?

Performance & Scalability: How do you keep Emacs fast and responsive, even with large projects? What optimizations have you implemented?

What’s a Blog Carnival, Again?

(Copied from Christian Tietzes introductory post)

This is our first Emacs Carnival, so you may not know the format. A blog carnival is a fun way to tie together a community with shared writing prompts, and marvel at all the creative interpretations of the topic of the month. I’ve provided a couple of interpretations above, but you may think of something else entirely. That’s amazing, roll with it, that’s what makes this fun!

For future Carnivals, check out the “Carnival” page on EmacsWiki. It includes instructions, and is our community space to coordinate participants and topic ideas.

Submissions

Just DM / email me with your submission! When I find a post elsewhere I will link it here, also. I’ll collect submissions up to, and including, August 1st (Central European Time), so that every time zone has had a chance to meet the July 31st deadline :)

These have been submitted:

What I Expect from an Editor as a Programmer (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)

Thanks everyone for participating!

August will be hosted by Charlie Holland with the topic of "The Search for Knowledge". You can also be host of a future carnival yourself, don’t be shy :)

My 10 Years with Emacs

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

Today, 10 years ago, I had my first encounter with Emacs, and that day definitely changed the way I work with computers—if not my entire life.

I remember that day so clearly because it was the day after the very first meeting of the "Warpzonista Coding Club." At that time, the Warpzone was my local hackerspace, and its focus was mainly on hardware tinkering. I wanted to meet more people who, like me, were into programming, and while enjoying the most beautiful sunshine and some light Son Cubano music, the idea of founding the Coding Club came to me. The first meeting took place on February 27, 2015. After a brief introduction, the conversation naturally turned to a topic every programmer eventually has to decide for themselves: their choice of text editor.

Since I was mainly coding professionally at the time, I used the integrated development environment that Microsoft shipped with Visual Basic 6. However, I wanted to program in Python on Linux and was looking for a good editor. I had already tried Vim before, but something about it didn't sit right with me. That evening, I met Christian Kruse, and we talked about how my mind works—I naturally think in hierarchies. Trees are my thing; I approach problems by backtracking through different solutions, and I break down projects into tasks and sub-tasks.

He then said: "Then Org mode will be your thing," and gave me a quick overview on his laptop. The next day, I installed Emacs and tried to get a feel for it myself. To cut a long story short: Org mode was amazing, but I absolutely couldn’t get used to the way Emacs worked. Christian had already warned me, and I knew I needed something called CUA mode. A bit of Googling led me to my first configuration files, which others had shared on the internet.

The First Configs

I spent a few weeks putting together a usable configuration. I gathered some snippets from various places online. CUA mode was included, YASnippet as well, and I discovered that I could create my own keybindings. At the time, I didn't know I could set keybindings per mode, so I made them all global, which, of course, didn’t take long before my first "config bankruptcy," a term I wasn’t familiar with back then. The main reason was that the configuration snippets I copied often came with their own namespaces, which I didn’t recognize at first.

My second approach to configuring Emacs was much closer to what I still use today. I had read a lot in the Emacs manual, understood keybinding layers, and also realized that when copying other people's configurations, it was crucial to adapt them to my package manager. My second config was therefore much more structured.

I set up a minimal ini.cfg that did nothing except loading three other configuration files:

A base configuration where I defined my preferred settings for each installed package (except for keybindings).
A keybinding configuration that contained all keybindings in one place—this way, I thought, I wouldn’t accidentally create conflicts.
A custom adjustments file where any changes made through Emacs' built-in configuration tools would go.

This setup worked well for about 1–2 years. Over time, I became more familiar with Emacs, learning how CTRL-X and CTRL-C serve as entry points into the entire keyboard system. I began to appreciate how well-thought-out and sensible Emacs' defaults were, but they still didn’t work with my brain. A big step forward was discovering the Hydra package. But first, Ledger

Ledger

One of the first packages that had a real impact on my daily life was Ledger mode. Ledger is a plain-text double-entry bookkeeping system. I quickly started writing my bank transactions into a file. With a bit of thought, I even managed to implement my grandmother’s envelope budgeting system. This ended up saving my finances by giving me complete clarity over my money.

Hydra

Up until that point, I had two ways to call functions: either through a keybinding or by looking up the function name online and calling it via M-X. With Hydra, I could now group important functions together, making them available only in relevant modes. I became a huge Hydra fan and eventually consolidated all my Hydras into a single file, which evolved into my Project Medusa, now the fourth file in my Emacs configuration.

Helm

The next big improvement was Helm. Choosing from multiple options in the minibuffer, especially for M-x, was a pain. Helm provided a much more comfortable interface. I could even display results in a separate buffer within the same window or in a neighboring window.

Although things were already much better, a Video by Prot made me rethink my approach to window management. Since then, I have replaced Helm with what I call the VOCEM stack.

VOCEM

VOCEM stands for Vertico, Orderless, Consult, Embark, and Marginalia. Many Emacs users have adopted this combination, though each package can also be used separately:

Vertico: provides a fast and minimalistic vertical completion UI.
Orderless: allows for flexible, out-of-order completion.
Consult: offers enhanced search and navigation tools.
Embark: acts like a context menu, making it easy to take actions on items near the cursor.
Marginalia: adds helpful annotations to minibuffer completions.

Denote

Denote had just as much of an impact on me as Orgmode. Long before Emacs, I had been trying to organize all the loose thoughts, ideas, and sources that I otherwise carried around in my head on my computer. Similar to how Luhmann, here in the region, worked with his legendary Zettelkasten. Either the approaches didn't work for me at all, or the filing system (which always maintained some kind of external index of the knowledge) eventually lost sync between the knowledge and the index. Denote attaches all metadata directly to the file, and so, even when sharing across all my devices, I have never managed to throw my mental exoskeleton out of sync. A great, well-thought-out piece of software.

Things I Intentionally Avoid

For example, I do not use a package tool that keeps the entire configuration for a package in one place. I deliberately want all keybindings for all packages in one location, and the same goes for my Hydras. These build on each other, and it is practical to have them all in a single file without other distractions.
Zettelkasten. I don't know the software, but I have a strongly negative opinion about the digitization of Luhmann's concept. It's the year 2025, and the hyperlink has been invented.

Conclusion

The path I have taken over these 10 years is just one of thousands of possible ways. Everyone uses Emacs for different things, and every mind works differently. I can definitely recommend carefully considering your own requirements for the Emacs environment:

Take a short note whenever something feels "wrong" to you. Eliminate these things from time to time.
Try to figure out what kinds of things you want to work with in Emacs: Configs? Novels? Accounting files? Addresses? Emails? Websites? Quotes? Places? This list could go on indefinitely.
For each of these things, make a list of the actions you commonly perform on them. For example, web links: Open in browser, open in external browser, save, publish in blog, sync across all devices, etc.
Gradually build your personal workflow from these elements.
Don’t do this directly on the computer, write these thoughts down on paper and keep this workflow as a battle plan for yourself.

Thanks

Of course, I want to start by thanking Christian Kruse, who nudged me in the right direction 10 years ago. But also a few other people (and I’ll surely forget some in the end). As a bonus, you’ll get to know how I refer to these people in my mind.

Sacha Chua, the "Mother of the Company," for her tireless work in keeping the Emacs community connected through her Emacs News and the annual Emacs Conference. She also regularly documents the real-world problems she solves and the methods she uses, explaining why they work.
Protesilaos "Prot" Stavrou, "The Philosopher," for Denote and especially for openly sharing his thoughts on designing Emacs packages in his blog. This makes it easy to understand whether his packages align with one’s personal workflow.
Karl Voit, "Mr. PIM," for his fantastic Org-mode talk and the idea of rethinking how one manages personal information from the ground up. I came to different conclusions than he did, but through this, I learned how my brain works and that it makes sense to embrace its differences.
David Wilson, "The Explainer-in-Chief", for his countless System Crafters videos, which are always helpful when you need something explained in great detail.

Many others, whose ideas I’ve read here and there, have also grown close to my heart.

Here’s to the next 10 years with all of you.

EmacsWiki Blog Carnival "Maintenance"

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

In October, as the days grow shorter and the air turns sharper, many people naturally shift their focus from the creative energy of summer to the quieter work of maintenance. It’s the season of clearing gutters, deep-cleaning corners of the house that have been ignored, and tending to the small repairs that keep daily life running smoothly. Just as some turn to housekeeping and autumn cleaning, others return to digital upkeep — reviewing notes, pruning old files, or fine-tuning their Emacs configuration so it feels nice and reliable. "Maintenance", in whatever meaning will be the topic of the EmacsWiki Blog Carnival in October.

What’s a Blog Carnival, Again?

(Copied from Christian Tietzes introductory post)

For future Carnivals, check out the “Carnival” page on EmacsWiki. It includes instructions, and is our community space to coordinate participants and topic ideas.

Submissions

Just DM / email me with your submission! When I find a post elsewhere I will link it here, also. I’ll collect submissions up to, and including, November 1st (Central European Time), so that every time zone has had a chance to meet the October 30th deadline :)

These have been submitted as of 2025-10-30:

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

Thanks everyone for participating!

November is being hosted by Donald Hunter: An ode to org-babel. You can also be host of a future carnival yourself, don’t be shy :)

Collecting and Categorizing Web Links in Org-mode

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

Whether they’re called bookmarks, favorites, or weblinks, we all accumulate a large number of them over time. At some point, it all becomes overwhelming and needs organizing. So, I wrote a Python tool for that.

What Has Happened So Far

New weblinks always originate from my browser. whether it's Firefox on my desktop and laptop or on my phone. I could simply leave them in Firefox, allowing me to sync and access them across devices. Sounds good enough, right?

But I also maintain a page with links on this blog that I want to share publicly. Ideally, I wouldn’t have to manage these links separately. That’s why, years ago, I decided not to use built-in or online bookmark managers. Instead, I store all my weblinks as plaintext in Orgmode format. Each link is a heading with the page title, linked to the respective URL.

If I feel like it, I add a short note or a quote from the page. On my laptop and desktop, a small browser add-on (Org Capture) appends new links to my Links.org file using Emacs’ org-capture protocol. On my phone, this add-on doesn’t work, so I share the page with the Orgzly-revived app, which lets me edit Org-mode files on Android. The link also ends up in Links.org, and I sync my entire org directory across all my devices.

The Links.org File in Detail

The file starts with a set of metadata lines that my static site generator needs to create the public link page. It looks like this:

#+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

The last line ensures that tags assigned to individual links aren’t exported to HTML.

All new links start as second-level headings. The first-level headings are divided into four sections:

1. Quicklinks

These are my frequently used links, marked with :noexport:, so they don’t appear in the public link list. They are placed at the top of the file for quick access.

* ------ 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. Public Links

These links are visible on the blog. My site generator processes this section and turns it into a dynamic list using a bit of CSS magic.

3. Private Links

This is where things get interesting. Right now (March 4, 2025), this section holds around 450 links, categorized with up to four tags. The organization, however, is… let’s say, questionable. More of a dumpster fire, really.

4. The INBOX

Basically, the same chaotic mess as the private links. just without any tags assigned yet.

So, my tool’s job is to process sections 3 and 4.

What’s the Goal?

The tool should take all weblinks from sections 3 and 4 and organize them into one logical tree structure based on their tags. The tricky words here are one and logical.

Are There Multiple Possible Trees?

Of course, otherwise, it would be too easy. Tags are inherently non-hierarchical. If I tag a link with a and b

* Link :a:b:

I can create two different trees:

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

As soon as I have three tags, I can insert the additional tag at three different levels. in each of the two trees. resulting in six possible trees.

The mathematical representation is 3! (i.e., 3 factorial). If anyone remembers exponential growth from the COVID era, that’s nothing compared to factorial growth. it’s child’s play in comparison.

With six tags, we’re already at 720 possible trees, and just eight tags result in 40,320 trees.

And what do I do with all these trees?

The common approach would be to use them all. That means a link with four tags would appear 24 times in the link list. but there would also be 24 ways to find it. Roughly estimated, my 450 links would result in about 3,000 links in the output file. And that’s too much for me.

Many of these paths wouldn’t even make sense. Suppose I bookmark the location where I last parked my car:

* Auto :germany:munic:mainstreet:

Then I don’t think, "Hmm, I remember parking on Main Street, so show me all the countries that have cities with a Main Street so I can pick the right one."

So, I need to cut down the trees that don’t make sense. This brings in the second key word: the structure should be a logical tree. But, as should have been clear even before Trump, there are some pretty strange interpretations of logic. and that’s not even considering alternative logic.

Computers aren’t particularly good at determining what makes sense in a search. So instead, I rely on a different criterion: frequency. Because counting is something computers are really good at.

If my file contains the tag emacs 200 times but the tag orgmode only 100 times, then the tree looks like this:

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

That works pretty well, but now and then, some strange hierarchies still appear. especially with tags that are rarely used overall. In those cases, a single extra use can already make a difference in how the sorting plays out.

And now I’m even cheating a little.

In most cases, rare tags don’t really matter. But when this happens with major (frequent) tags, it can be quite annoying. That’s why I cheat a bit. Sticking with the car example, I’d actually write it like this:

* Auto :Germany:Munic:mainstreet:

See the difference? The first two tags are now capitalized. For my tool, this signals that country and city are hierarchically more important than the street. This still leaves two possible trees, but it eliminates four others right away. I can only enforce one strict hierarchy level this way, but it helps handle the edge cases quite well.

Why is this cheating? Well, according to the textbook, tags don’t carry hierarchical information, and my programmer’s heart does feel a little dirty about it.

Now, on to the technical part, in case anyone wants to implement this in another language:

The Algorithm

Collecting Links:
- First, I gather all the links I want to process and store them in a dictionary.
- The key is a hash of the actual link, which eliminates accidental duplicates.
Generating Permutations:
- I generate all possible tag permutations.
- Any permutations that violate my "cheated" tag hierarchy are skipped.
Building the Tree:
- The list of links is passed into the core function that constructs the tree.
- Since trees lend themselves well to recursion, the function is recursive.
- Each function call processes one hierarchy level and then calls itself for deeper levels.
- The recursion stops when there are no more links left that don’t already belong to a tag.
Inside the Recursive Function:
- The current tag is added as a node in the tree.
- All links that fit exactly at this level (i.e., having exactly the required tags for this depth) are added.
- If links remain, the voting process begins:
  - Each remaining link votes for the tag it would like to see added next.
  - The tag with the most votes is chosen.
  - A new list of links that voted for this tag is created.
  - The function calls itself with this list and the chosen tag, building the subtree.
  - Once processed, those links are removed, and another voting round occurs if any links remain.
Exporting the Tree:
- Once fully built, the tree is written back into an Org-mode file.
- Done!

The Result

The output file now contains a hierarchically structured and sorted list of tags:

The most frequent tags appear first.
If two tags have the same frequency, they are sorted alphabetically .
All links are included in the tree.
No duplicate links exist.

This gives me a link tree that is highly usable. While it may not be the perfect tree I would create manually, it's close enough. And the best part? There's still plenty of room for optimization in the algorithm.

Tweaking the Voting

Anyone interested in voting systems will have realized that there are dozens, if not hundreds, of different voting methods, each leading to slightly different results and optimized for various goals (fixed number of seats, weighting by stock share, minimizing the tags traveled by horse to the capital, etc.).

This also applies to the voting in this algorithm. Currently, every link votes for every tag that benefits it in some way with one vote. However, other variants could also be considered:

If a link sees 3 possible trees for Tag A and 2 possible trees for Tag B, it could vote with 3 and 2 votes for the respective tags.
The votes could be weighted based on whether a tag is immediately needed at this level or possibly further down the tree.
etc.

Overall, I am already very satisfied with the results. My repository with the current state of the tool can be found (here).

Writing Lisp Code with ChatGPT

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

I am currently organizing a visit to a major festival, with over 175 bands playing over 4 days at around a dozen different venues scattered across the city. It's quite a logistical challenge. Which bands do I want to see, and do they play with enough time in between to get from Location A to Hall B?

So, I copied all the data from the organizer's website into an Org document and generated an overview. In Org, it looks like this:

* 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
   :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:

The table at the top is my overview, and since there are now almost 200 lines in it, it's tedious to scroll to one of these bands in the details section. If the organizer hadn't listed them alphabetically, it would be nearly impossible.

The overview table is generated anew, thanks to Org magic, every time I press C-c C-c on the header line. So, the first column is literally identical to the heading of each band-entry. If this heading contained a link to itself, then the first column would be full of links to the details of the bands.

To generate these links, I have to perform several functions:

Generate a custom ID for the heading
Copy this ID to the clipboard
Select the heading
Insert the link

and all that nearly 200 times.

It would be nice to have a function at least, that performs these steps, which I can then bind to a key.

A question via social media revealed that while similar things have been created before, they all ended up with slightly different goals. And then I thought, let me see if ChatGPT can solve this problem for me.

The original prompt

Me: 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))))

Not bad, for a first shot. The function first moves the cursor to the beginning of the current heading, then retrieves the heading text and its existing ID, if it has one. If the heading does not have an ID, it generates one using the md5 hash of the heading text. Finally, it inserts a link to the heading with its ID.

Unfortunally the cursor is moved to the beginning of the Heading, and so it is inserting the new Link before the ** Heading, making it no longer a Heading, But maybe ChatGPF can correct that.

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))))

This version of the function deletes the original heading and inserts the linked version in its place. But it still has a problem, that you can see in the last line. It always inserts a level-1 Heading (it prepends one asterisk, fix). Correct yourself 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))))

This version of the function first retrieves the heading level using org-outline-level . Then, it deletes the original heading and inserts the linked version with the same heading level. I tried it. and it worked as intended

* 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.

It works

Only thing that needs to be done is copying it to the Config and binding it to a key Oh, and ChatGPT can also do that

Me: 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

Whoever has already looked through my projects will find that there is a project Medusa that I have set up for myself. In Emacs, there are functions that I only need very rarely, and then I often don't have the necessary command in mind. It is then quite helpful to have a hydra for this situation, and the project under which I combine all these hydras is called Medusa for me. Recently, I wanted to create a hydra for Denote, and I found that there were a few problems.

In general, I handle the hydras like this: I have two thumb buttons on my keyboard with which I control the hydras. On the left thumb is a rather general hydra that is intended for all functions that are not only needed in a specific mode. Here, you can imagine that the functions, that you normally reach with the prefix CTRL-x.

On the right thumb is a kind of context menu, i.e. the hydra that belongs to the respective mode I am currently in. You can imagine that there are all the functions that are accessible via CTRL-c as a prefix. Me treating the whole thing like a context menu, can also be seen in the fact that I have these hydras lying on the right mouse button at the same time.

No Mode, no gain

And here the problem already begins. Denote is an application that provides many commands to create and link loosely written notes with each other. However, since these notes can be written in all possible formats, the respective major mode of the format always applies. I write this blog, for example, in Org-Mode, which means that the major mode is not Denote but Org-Mode at the moment. The Package Major Mode Hydra therefore does not work.

However, Denote is also not a minor mode that can be turned on or off arbitrarily in all kinds of documents. A document is only a Denote document if it is located in a certain directory (silo) and follows a naming convention. And since Denote is not a minor mode, it also has no own keymap. But Emacs would not be Emacs if you couldn't do something about it.

We Build Ourselves a Minor Mode

It would be good if Denote had a minor mode that would be active whenever the active document is in a Denote silo. Since a silo is always also a directory, Emacs has a tool on board: directory-local variables.

The manual says:

The usual way to define directory-local variables is to place a file named .dir-locals.el in a directory. When Emacs opens a file in that directory or one of its subdirectories, the directory-local variables specified in .dir-locals.el are applied as if they were defined as file-local variables for that file. Emacs searches for .dir-locals.el, starting in the directory of the opened file, and moving upwards in the directory tree.

My file .dir-locals.el is located in the top directory of my silo, and looks like this:

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

This line ensures that the denote-mode is turned on for all files in this directory. This is a minor mode that Denote does not come with out of the box, but that we have to create ourselves first. This happens in the corresponding part of my Emacs configuration.

(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 specifies what is written in the mode line when the minor mode is active, and :keymap specifies which keymap should be used. In this case, an empty keymap is created using make-sparse-keymap, and filled with the most common commands I need. I probably could have left out this initial filling, since I'm going to do the final keybindings anyway, but I didn't find an example where an empty keymap was created.

The Actual Hydra

I then equip my freshly created keymap with the only important keys. <menu> is the key code that my right thumb button sends.

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

When I click the right mouse button in a Denote silo, the following hydra appears:

This is generated by the following code. I use the slightly shorter and nicer syntax that the Pretty Hydra package provides me with.

(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, a program to generate Emacs keybindings

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

Apparently, there are a lot of Emacs purists in the world who, over the years, have learned to type such complex key sequences as C-x r t M-. C-c C-p fluently. I'm not one of them. And when I tried to figure out how to customize it for myself, the web forums were full of comments saying it wasn't a good idea.

Essentially, for the following reasons:

Portability: If you heavily customize your Emacs key bindings, you may have trouble using Emacs on another system where your customizations are not available. This could be problematic if you frequently switch between different computers or if you need to use Emacs on a remote server.
Learning curve: Emacs already has a steep learning curve for beginners, and heavily customizing the key bindings can make it even more difficult for others to understand your configuration. This could be an issue if you collaborate with others or need to share your configuration with someone else.
Conflicts: If you're not careful, heavily customized key bindings can lead to conflicts between different packages or modes in Emacs. This can result in unexpected behavior and make it more difficult to diagnose and fix problems.
Dependency on customizations: If you become too reliant on your individual key bindings, you may find it difficult to use Emacs without them. This could be an issue if you need to work on a system where you can't use your custom configuration.

However, I never have to share my Emacs configuration with other people, or use Emacs anywhere else than on my two computers. So points 1 and 4 are already out of the way. As for the learning curve, I'm not planning to come up with even more complicated key combinations. I just want to be able to continue working with what has been burned into my memory for decades. So point 2 is also taken care of.

That leaves point 3, and it's true: If you're not careful, heavily customized key bindings can lead to conflicts between different packages or modes in Emacs.

I've avoided this so far by keeping track of the customizations I've made in nice tables (thanks to Org-Mode). This approach is of course quite prone to errors. The tables always have to be consistent with the keybindings in dozens of places in the config. It takes a lot of discipline, and it becomes difficult to just try something out.

It got a bit better when I started to consolidate all the keybindings in a single file. This file is loaded at the end of the init.el, and keybindings are not made anywhere else. This worked for a long time. No more tables. The truth is in the code. Unfortunately, it wasn't that easy to search the code for potential conflicts. You can't just change the sorting in the code from "Keymap Name" to "Used Key" like you could with the tables.

So I sat down and wrote a tool in Python where I can manage my desired keybindings in Org tables again, and the tool automatically generates the desired keybindings from that. It's called

Keymacs

The program is quite simple. It goes through a file (default: keymap.org in the current directory), collects all the table rows, and assumes that these are descriptions of keybindings. Header rows and separator rows are ignored, as well as almost all other surrounding text. So you can also describe what you had in mind for the individual bindings in the file.

There are two slightly different tables

The explicit table

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

I've picked Treemacs as an example here, which shows a few things quite well. Treemacs has the peculiarity that I don't have to make any inputs in the window. So there's no reason not to just use letters without constantly having my little finger on the Ctrl key. First, the first 3 lines:

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

There are 3 different places where I can simply press c, but they are not in conflict with each other because they are in different keymaps. To get the name of the keymap, the program simply appends -map to the mode.

But wait, there's no treemacs-toggle mode? That's right, but there is a keymap for it and a prefix that it's bound to. I'll show that with the 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

This map is originally called treemacs-copy-map even though the original function in it just copies the current file (and I've mapped that to a shorter c). All the others just put various links in the clipboard, so I've chosen l as the key to get into the treemacs-copy-map, and the following key then selects what kind of link I want (absolute, relative or to the project root?) l a gives me the link as an absolute path.

And of course, I can still use Ctrl combinations if I want to. For example, many programs use Ctrl-n to create a new file, a new object, or something else new. Why should I ignore that? So:

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

So I can create a new file with Ctrl-n and a new directory with Ctrl-Super-n.

However, the common Ctrl combinations are of course useful in many different modes, and you have to be a little careful that the keybindings don't interfere with each other, especially when minor-modes come into play. For that, you'd better use:

The implicit table

At first glance, the table looks the same, but the Key column on the left is missing.

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

But how does keymacs know which key to bind to? I mentioned at the beginning that keymacs ignores header rows and separator rows, as well as almost all other surrounding text. Now here's the reason for the "almost", and for that we need to look at the Org-mode:

** 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 reads the first word from all Org header rows (here 'N') and uses it for the subsequent implicit tables. A new header sets a different key, e.g.

** 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      |        |
 |        |      |       |      |       |                         |        |

Except for the first word, keymacs doesn't care about anything else. Incidentally, you can also see here that the global-map is filled with "Global" (with a capital G). The order of the columns must be correct, the headers are only for the reader and are ignored.

The program

I originally wrote this whole thing to solve my own problem, and later also to test the entire development process using Hatch. That's why the whole thing is also available for (test) PyPi for download. Since I want to internalize this whole Python workflow, I will continue to work on this tool, even though it already solves all my problems. But the code is ugly and so far only has a "happy path" without error handling.

The source code is here

If you just want to install it, I recommend using pipx. Then it's as simple as:

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

The program only reads the keymap.org file and then writes a keymap.el that you can include at the end of your init.el

(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"))

Just quickly print something in Emacs

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

In Emacs, there are several ways to generate neat prints. Most of them end up creating PDFs. But if you just want to quickly have a printout of the buffer to work with a pencil and highlighter, that can sometimes be a problem. I spent an evening trying to solve that, and eventually succeeded. To remember it, I wrote this blog post.

Basically, there's the command print-buffer, which I habitually invoke with CTRL-p. I expect paper to come out of the printer, containing unformatted text, just like what I see on the screen in the buffer.

Unfortunately, that didn't work for me at all. Emacs uses the Linux command line command lpr for this kind of printouts, and it quickly became clear that it wasn't doing any good on the command line either. Every attempt to print something with it, ended with a message saying that the lpr daemon wasn't running. Every attempt to start it failed. At some point, it dawned on me that maybe lpr is just too old as a printing tool.

Back to the Future

lpr is indeed an older command, stemming from the times when printers were often directly connected to Unix systems. However, it came to pass that the "Common Unix Printing System" (CUPS) was developed, providing modern print management on Unix systems. And a little web search revealed that it comes with its own command line command, lp.

The syntax of the two commands varies slightly. lpr usually simply accepts the filename I want to print, while lp accepts a range of options that allow me to control various aspects of the print job, such as the number of copies, the printer, the paper format, etc.

Emacs kindly provides the option to configure the command it uses under the hood. So, instead of lpr, we say we'd rather use lp:

(setq lpr-command "lp")

Since lp and lpr pass different parameters on the command line, it also doesn't make sense to continue using the lpr standard switches for lp. So, we turn them off:

(setq lpr-add-switches nil)

And boom, everything worked as expected. So I persisted it in my Config

Conclusion

If you're not using an antique Linux system, lpr doesn't make sense anymore and should be replaced by lp. In my humble opinion, that would be a good default by now.

By the way, in the configuration, you can also set your own parameters to pass to lp, which I think will help me achieve double-sided printing as well.

Mein Tastaturlayout Edwin

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

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

Die Vorteile sind:

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

Der leider wichtige Nachteil:

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

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

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

Das Layout

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

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

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

Layer 0

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

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

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

Layer 1

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

]]

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

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

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

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

Zufällig ergaben sich die Eselsbrücken:

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

Außerdem bilden sie ein hübsches Quadrat

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

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

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

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

Layer 2

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

Fazit

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

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

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

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

Replacing a defective PGP card with the backup

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

I had managed to ruin the PGP card that holds the PGP key I need to read my email and decrypt my password store. I had a backup in the form of a second hardware key. Well, unfortunately it turned out to be not that easy to replace it.

Of course, I could have simply restored the backup copies of the key that I had stored on the hard drive when I created it to the old key, but I thought to myself: "What if I had completely lost this key? Try it out, switch completely to the reserve key".

While there are dozens of guides out there on how to restore a key from disk onto your hardware token, this is where it gets very thin. I had to google for hours to find a solution. That's why I wrote it all together here, also because I might need it again in the future.

The problem

I look at the private key on my keychain:

$ gpg  --list-secret-keys

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

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

The '>' character after sec and ssb tell me that there are only so-called stubs in my key ring, i.e. only placeholders, and that the actual keys are on a hardware card. Which card it is is in the third line:

Kartenseriennr. = 0006 15889829

So whenever I want to decrypt something with that key, gnupg asks me to insert that exact card. No other card will be accepted, even if it also contains the appropriate keys.

But now I have lost this card and I want to teach gnupg to accept my backup card.

The Solution

Remove old card

First I need the so-called keygrips of the affected keys

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

Geheimer Schlüssel ist vorhanden.

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

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

gpg>

I find these key grips as files in the directory ~/.gnupg/private-keys-v1.d

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

The reference to my key card is stored in these files. Since the card is gone, the files must now also be deleted. After that, gnupg no longer asks for the old card, but it doesn't know what to do with the backup card either

Link new card

Again, this is very easy. I stop the gpg-agent first, otherwise it would make my life hell with its cached information.

gpgconf --kill gpg-agent

Then I plug in the new card and introduce gnupg to the new card

gpg --card-status

After that, gnupg created new files for the keygrips of the new keycard, and after a restart of the user session, it now asks for the backup card

Goal achieved!

My Keyboard Layout

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

At some point at the beginning of the year, after much hesitation, I bought a Moonlander MK1 keyboard. I had expected some advantages from it, but unfortunately I also saw a decisive disadvantage…

The advantages are:

Because the keyboard is split into 2 halves, I can position the two sides to suit my shoulder distance and have a more relaxed sitting posture
Each half is tilted outwards, so each arm is no longer twisted as on a "normal" keyboard
The individual keys are arranged in columns where the finger only needs to reach up and down, without moving sideways when it is not necessary. This is particularly helpful when I'm writing, because my brain seems to think in tables and trees. My brain cells seem to be arranged at right angles to each other. I didn't really get along with the shifted keys when trying to learn touch typing. The offset between the keys comes from operating the type lever on mechanical typewriters and has actually been superfluous since the days of ball-head or daisy-wheel typewriters.
The individual columns are offset in height to allow for the fact that the individual fingers are also of different lengths.

The unfortunately important disadvantage:

The keyboard forces you to type with ten fingers, which unfortunately I hadn't mastered at the time.

This circumstance weighs particularly heavily because I use the same keyboard for my private and my work computer. But since I'm basically removing bugs from legacy software there, on many days I don't write 10 lines of new code, the risk seemed justifiable to me.

A huge advantage is, that the keyboard is completely user-programmable, in several levels and distinguishable in short, long, double and held keys.

The Layout

I thought to myself, if I'm going to start typing from scratch anyway, then I'll save myself the tiresome QWERTZ layout, which again only exists in this form so that the typebar on mechanical typewriters doesn't get stuck as much as possible.

For today's writing on the PC, there are clearly more suitable layouts that relax the hands better. Dvorak, Colemak, or Neo for example. I chose the latter because it is optimized for the German language and I find it easy to remember to have all the vowels under the fingers of the left hand at rest.

And so I essentially oriented myself to Neo 2 when it came to assignment.

Layer 0

The labeling of the keys reads in such a way that the upper half shows what the keyboard outputs when I press the key, the lower half shows what happens when the key is held briefly (200 ms, configurable). happened. For example, if I hold down the "c" key, it becomes Ctrl-C.

As you can see, I haven't made a lot of changes to the normal Neo layout. The changes are:

In the original, period and comma have two different keys, but since I really wanted to have space for cursor keys under my right hand, the period had to go and is now a short comma.
The row of numbers at the top is difficult for me to reach anyway, and therefore impractical for the many numbers I type all the time. So I left them there completely and moved them to a block of ten on level 3. Instead, there are now 20 function keys F1-F20 in the top row. The first 10 by normal typing. By briefly holding it, F2 then becomes F12 etc..
The buttons to switch to the other levels have all moved to the lower thumb buttons. They are particularly easy to reach there.
For the shift key, which is normally held by the weak little finger, I tried various places. In the end, using the space bar - if it is held down - as a shift key has proven itself.
All special characters are usually buried in the 2nd layer in the Neo layout, but since I need the hyphen from time to time in normal writing flow, I put it on the held "j".

Layer 1

Normally all special characters are well distributed here on both hands. But my mind just couldn't manage to remember their arrangement, so I came up with a completely new arrangement for this layer, which aligns with my personal writing habits and, appropriately, also provides very simple mnemonics.

The left half of the keyboard is practically unoccupied on layer 1. Only the keys F21-F24 can be found here, where F1-F4 can be found on level 0. Otherwise, I use the keys for blocks of text that I use a lot for work, so I didn't show them here. Instead, everything takes place under the right hand.

Here you will find the PgUp and PgDn keys, which, when held briefly, not only move the cursor one page up or down, but right to the very beginning or end of the text. In addition, my hand goes a little bit out of the resting position because of the distance.

The stupid upper row is only occupied with very rarely used currency and accent symbols.

Index and middle fingers are busy with brackets. In the rest position with the normal and square brackets, which I often need as a programmer. If I stretch my fingers upwards, then with the pointed and curly brackets. With all clamps, I open the clamp by pressing it and close it again by holding it briefly. However, I very rarely have to stop because I have set my editor so that when I open a bracket, I always get the closing bracket automatically inserted.

The mnemonics came about by chance:

N - normal brackets
R - square brackets (rectagular)
H - HTML brackets
G - curly brackets (geschweift in German)

They also form a nice square

To the right is another square that I need for work because I write a lot of Oracle SQL queries.

It includes the single quotes to delimit strings, the semicolon to end statements, the percent sign for wildcards, and the equals sign for many comparisons.

If I move the two strongest fingers down, there are all the characters I need on the command line to enter paths ( ~ / . ) nice and easy to reach.

The less frequently used characters are nicely scattered in the remaining gaps.

Layer 2

Level 2 is then reserved for the block of ten. For me, this is simply the more intuitive way of capturing digits, and as a separate layer it is not even necessary to move your right hand to the side. The left thumb changes to the level and immediately the 5 is under my right middle finger and all the important arithmetic symbols are arranged around it. Point calculation on the right, dash calculation on the left.

Conclusion

The layout as it is today has now proven itself very well, and as far as touch typing is concerned, I now write largely blindly at almost the old 6-finger speed that I was used to in 40 years. However, over the last 2 weeks I have noticed several times how muscle memory is taking over more and more control. My fingers now type frequently used sequences of letters independently, even before my head can break them down into individual letters. There will definitely be a lot going on in the next year.

The feared effect that I'd forget the standard QWERTZ layout didn't materialize. I always have to get used to it for 1-2 minutes, but then everything is back. I can't write blindly in QWERTZ anyway and don't want to get used to it there. But I'm still fast enough to write this blog entry in QWERTZ, for example, because it was created on my old laptop while I was out and about.

The keyboards feel so distinctly different (partly because I increased the standard incline from just under 20° with the help of a Thingiverse wedge to just under 30° inclination) that my head switches automatically.

All in all, I'm now amazed at how easy touch typing is when the environment is right for it, and why a system is still being taught and popular that's optimized for devices that it's now only can still be found at flea markets at bargain prices.

Einsparpotentiale ermitteln (Gas)

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

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

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

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

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

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

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

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

Das ganze sah dann so aus:

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

Wie kann ich dieses Ziel nun erreichen?

Der Kessel

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

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

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

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

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

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

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

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

Was habe ich also für Handlungsoptionen?

Beim Duschen

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

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

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

Bei der Heizung

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

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

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

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

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

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

Ich wurde geNerdSniped

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

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

Einsparpotentiale ermitteln (Strom)

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

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

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

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

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

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

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

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

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

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

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

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

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

Raum	Verbraucher	Strom	Bemerkung
WC	Lampe Raum	5 Watt

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

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

Im Flur ist alles im grünen Bereich.

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

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

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

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

Im Schlafzimmer ist alles im grünen Bereich.

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

Das Kinderzimmer ist aktuell unbewohnt, unbeheizt und unbeleuchtet.

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

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

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

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

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

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

Operation Wintermute

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

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

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

Der IST-Zustand

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

Strom

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

Der Verbrauch hat sich in den letzten Jahren so enwickelt:

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

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

Gas

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

Der Verbrauch hat sich in den letzten Jahren so enwickelt:

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

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

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

Benzin

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

Der SOLL-Zustand

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

Browser Lesezeichen in Org-Mode speichern

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

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

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

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

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

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

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

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

Die Emacs Seite

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

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

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

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

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

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

Die Browser-Seite

Um in Emacs ein Lesezeichen abzuspeichern reicht also ein Aufruf von

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

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

Iteration 1

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

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

Es wurde also Zeit für

Iteration 2

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

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

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

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

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

Es waren wieder friedliche Zeiten. So einigermaßen.

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

Ich begann also die Suche nach

Iteration 3

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

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

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

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

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

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