Plain DrOps (Posts about emacs)

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)

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

Finance under Control with Ledger (2) - The Emacs ledger mode

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

In the last part I wrote about how bookings in Ledger work and how they are written. Because they are just simple text files, you don't need more than a plain text editor. Choosing Emacs, the work becomes a little bit easier.

Well, admittedly, easy is not the right word when it comes to mathematics, but having your finances under control, and being not overwhelmed every January from the wave of "unexpected" bookings is a good feeling. And Emacs helps you with Ledger Mode at simply writing flawless booking records.

Automatic accountname completion

A major source of problems is that the account names (which are usually within categories) may become very long. Expenses:Living:Additional costs:Electricity is a quite ordinary account name. When you load your ledger file The Ledger Mode reads all your account names and after that you can add the parts of those account names by tab completion. In addition to the time saved on typing, this decreases the chance of typos.

Speaking of typos in account names: Ledger offers the opportunity to create unknown accounts in a booking on the fly if the don't exist. As seductive as this option is, you should stay away from it and choose the exact other way to be your way of working.

With that configuration Ledger refuses to work as soon as an account you want to book to, was not explicitly set up beforehand. This refusal may seem annoying at first, but then Ledger at least gives you a good hint which account was misspelled. Without this hint you are faced with the challenge of just having wrong values in this accounts and trying to find the cause in hundreds of bookings.

Aided reality checks.

Another help to ensure that your bookkeeping does not deviate from reality, is a regular reconciliation of accounts. I do that for my current account & the credit card based on the bank statements and for my purse by simply putting the contents of it on the table.

In any case, I get the account balance that my bookkeeping should also show. The Reconcile function of the ledger mode asks me for this value when called, and then gives me a listing of all bookings that I have not yet matched with reality. Now I can sit down with my bank statement in my hand and mark all the bookings that I also see in Ledger. During this process I always see the difference of my confirmed bookings against the reality. As soon as this difference is 0, the adjustment is done, and the temporary markings become final. I never have to worry about these finalized bookings again.

Automatic report updates

Reality matching is sometimes difficult, especially with cash, because it presupposes that every cent you may have spend somewhere for some candy bar somehow gets into the accounts. For this reason, I recommend to minimize cash payments at the beginning and pay a lot with plastic. The money you get from the ATM could then be booked with an general cash account, or split, or split according to your feelings. Only those who are willing to keep disciplined notes of their cash spendings will have fun with tracking their cash expenses.

I use a USB voice recorder anyway for small notes and so the cash accounting works very well. In those cases where it becomes a bit more work to understand my expenses, it is helpful that Emacs shows me the register of my expenses in a second window. Its good to see spendings and income (when I was at the ATM) in my wallet and update immediately when I add bookings.

Suppose I think that two weeks ago I bought food for 15 Euros at the chinese food store. When I type that into my ledger I see immediately something can't be right, because the final sum of my cash accounts correspond to what I have in my wallet (and thus the 15 euros were actually spent) but the time of this spending cannot be correct because otherwise my wallet must have been temporarily in the negative numbers, which is simply not possible with cash.

So obviously it was not two, but one week ago, after I was at the ATM in between. I can make my booking shift through time and see immediately in the report whether one Booking may have been possible or not.

Automatic cleanup

Even if this function is actually nothing stunning, it is tremendously practical if you don't have to pay attention to where in the file you write your bookings, or whether you also place all decimal points below the other. The ledger mode has both functions, legible formatting and time sorting of booking. I have it even made more simple for me and call this "make pretty" by a hook every time I save my ledger file. So all data is always Formatted for easy reading

Finance under Control with Ledger (1) - Basics

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

Who of us does not know that. At the end of the money there is plenty of the month left, and is usually used by the Gasworks and the goldfish breeders' club to collect their annual fee (including the price increase) from your account.

I also had a time when I had to do a lot of financial juggling to live from month to month, even though I had as much money as today. I just did not have under control as well as I now have. The heart of the problem was actually that I almost never knew how much of the money in my account was really free to spend, and what bills would come up in the near future.

And then I sat down and decided to change that. First with pencil and paper, later with the support of the PC. I have tried various systems, bringing me finally to Ledger. Over the past year, I have been making little tests of how to handle my money, and since there were no major difficulties, I switched to Ledger at the beginning of 2019.

What can Ledger do (bookings & transactions)

Actually, ledger can do very few things, but for those it is very flexible, so it can cover a lot of use cases.

It reads one or more text files with postings
It sums up these postings (and distinguishes between the accounts in which they are posted)
It either displays the complete register, or the balance on the screen

One thing that stands out is that Ledger definitely does not write to the postings in my files. I write my postings, and Ledger just evaluates them. It's very fast and precise in that.

An example:

2019-03-10 gas station
   Gasoline 50.00
   Checking account -50.00

What we see here is a transaction. This is the building block that we most often deal with in Ledger. It consists of the head, which indicates, when the transaction took place and who the partner was (here the gas station), as well as a number of postings (these are each a little indented). Postings are the smallest building block we use in Ledger. A posting identifies an account and an amount added to the account (or subtracted if the amount is negative). Several of these postings form a transaction.

The essential feature of a transaction is that the postings ALWAYS have to sum up to 0. Otherwise, the transaction is not valid and generates an error, crashing ledger.

Consequently, this means that there must be at least one counter entry in each transaction. A transaction thus always consists of at least two postings, and is therefore commonly called "double entry accounting". Every euro that comes from one account must go in another account.

If I let Ledger evaluate the above example and let me see the balance, it tells me, for example, that the account gas is now 50.00, and my checking account is now 50.00 in debt.

Accounts

"That's great," you may say now, "if I need the 50.00 Euro again, then I'll just book it from the gasoline account, and …". But that's not how it works. The gas station will not like it if you took their money from them back. Even if you could do that in the theory of bookkeeping.

In reality, you use a few categories of accounts, that you then only use for certain types of postings. This is called the standard form (or chart) of accounts, and theoretically can be made by anyone as he feels like. In practice, however, a handful of chart of accounts have proven to be standardized in a way that different companies work with the same chart of accounts.

For me as a private user, a specific chart of accounts has been tried & tested that consists of 6 categories

Income

Somewhere the money has to come from, and here we find all the accounts, where the money is almost "created". We remember: If my salary arrives on my checking account, it will need a corresponding conter entry. Therefore, the posting looks like this

2019-03-01 Company Baumeister
   Income:Salary -2000.00
   Credit:Bank 2000.00

As my bank account becomes more and more positive, the income are becoming more and more negative. Which also corresponds to the reality. When I get a salary, my company gets a little poorer.

Expenses

The opposite is the case when I spend money

2019-03-10 gas station
   Expenses: Gasoline 50.00
   Credit:Bank -50.00

If I pay an invoice from my bank account, then the money has to "disappear" somewhere, and it does so only on "expenses" accounts.

In Ledger one speaks actually not of categories, but only of accounts. Accounts may also contain subaccounts (for example) Spending: Utilities: Gas and Spending: Utilities: Water. If I post something like these with these accounts:

2019-03-09 Stadtwerke
   Credit:checking  -100.00
   Expenses:Additional costs: Gas 50.00
   Expenses:Additional costs: Water 40.00
   Expenses:Additional costs: 10.00

Then you can see that here from the checking account an amount of 100 euros for the Stadtwerke was paid, which comes completely from the account Expenses:Additional costs. Of which 50.00 from the account for gas and 40.00 from the account for water. In addition, the Stadtwerke has charged me a general fee of 10.00, which I can not assign directly to the gas or water, but it is part of the additional costs. Here you can see that a transaction must contain at least two postings, but it may also be more. They must only add up to 0.

Credit

It's really easy. This includes all accounts on which there is usually money, ie the checking account, the savings account, the wallet. It's money (or values) that I have. If an account pays interest to me, it is most likely a credit account

Debit

These are debts I have somewhere. As a rule, I recognize debit accounts by paying interest because somebody has made money available to me here. Typically, these are the house loans or the credit card.

Compensation

Compensation accounts are accounts that should not exist in a perfect accounting world. Unfortunately, the world is not perfect, and so I've got two subaccounts for compensations

Compensations:debut

I use this account exactly 1 time at the beginning of the bookkeeping, and then never again. If I start accounting sometime today, my checking account already has money and my credit card is in debt. So I book on my checking account the money that should be on it today, and the counter posting then goes against the account Compensation. Here, money is actually generated from very thin air. So, to not use this for cheating, I have exactly one posting at the very beginning, and then never again.
Compensation:lostfound

Since I also manage my cash (ie the wallet), it may sometimes happen that I simply have less money in the wallet than actually should be according to my bookkeeping. Sometimes I lose money in the washing machine, or elsewhere, sometimes money unexpectedly reappears in the lint filter. For all this there is this account as a counter account to the wallet. The account should be used as seldom as possible, and should be as little as possible off from 0. If this is no longer guaranteed, this is a sure sign of a general problem with discipline whith posting, or with spending cash. If I know, for example, that I have spent the night before 50.00 on a pub crawl, but I somehow 51.00 are missing in my wallet, then I just book 51.00 on the leisure account, and don't use thelostfond account for the missing 1.00. It is only used when I can no longer reasonably explain the disappearance.

Budget

Actually, Ledger has a built-in functionality that allows me to manage budgets (money that is reserved for certain expenses). Unfortunately, this is somewhat limited in terms of flexibility. So, using the Budget account and its subaccounts, I'm simulating a method that has worked well for my grandmother to put money aside for later: envelopes.

Whenever my salary arrives I put a little money into each of those envelopes. And then, when the car insurance wants its money, I open this envelope, and it contains exactly the amount that I have to pay as expected. Of course, I do not fill these envelopes literally. They do not even exist. They are just virtual envelopes, and the budget account is a subaccount of my checking account. The bank does not know this subaccount. From their perspective , I have 300 euros in my checking account. But Ledger can show me in this way that of these 300 euros are already 180 in a virtual envelope labeled car insurance, and I therefore have only 120 euros to spend.

The necessary postings of a budget transaction can sometimes be very confusing, but with a little practice this is possible. I will go into detail later.

Work easier

As mentioned earlier, Ledger simply reads the files and evaluates them. At no time does Ledger write anything in one of the files (there is a small exception that you have to explicitly request, and you almost never need)

But it also means that I have to type the complete postings myself by hand, including the matching counter postings. The account names must not contain any typos (which may be exciting for names such as Expenses:Household:Food:Biobox) If I call an account once dirtwater fee and once dirtwater charge, then these are for Ledger two completely different accounts, which then each individually summed up, and never merge

Ledger has some simplifications at hand for this very time-consuming and error-prone typing work:

The chart of accounts

Of course, I will eventually mistype an account name over time. And then, before I book money on any account called Expense:Carinsuracne and wonder why there's no change in the real account, it's better if Ledger controls it.

Ledger can be configured to tell it what accounts I want to use, and how the entire chart of accounts (all my accounts and subaccounts) is built. After that I can only use these accounts. Any typos will be mercilessly flagged, and Ledger will refuse to validate my postings until the error is resolved. Thankfully, he tells me exactly where the problem is.

Aliases

An account named Expenses:Household:Groceries:Biobox can be very annoying to type. Therefore, Ledger offers the possibility to give short aliases instead of these word monsters. I then have to go e.g. Just type "Bio" and Ledger knows I mean that account.

The empty posting

Even amounts could be mistyped quickly, or you can't calculate in your head, what sum an counter posting has to have. If the Stadtwerke bills me I just want to write this:

2019-01-02 Stadtwerke
   Gas 12.34
   Water 56.78
   checking account

As you can see, there is no amount in the checking account, and if there is a transaction with exactly one account with no amount, Ledger simply takes the amount needed to balance the other postings. In this case, -69.12 will be posted to the checking account (ie 69.12 deducted)

The default account

Most of us have exactly one checking account, and all bank transactions run through this one account. Because even if you use something as alias as short as "Giro", it can be annoying to write it down for every transaction. However, Ledger offers the option to make an account have the function of an default account, which is then always accepted when the transaction is not cleared and the account is not already used in the transaction.

2019-01-02 Stadtwerke
   Gas 12.34
   Water 56.78

is therefore a valid posting record, if previously the checking account has been agreed as the standard account. In this case, the checking account is automatically taken as an counter account and the corresponding amount determined as explained in the section "empty posting"

Also

2019-01-02 Stadtwerke
   Gas 12.34

is now a valid posting, even though the transaction violates the rule that a transaction must consist of at least 2 transactions. The missing posting goes to the previously defined default account

The Ledger Mode

As you can see, Ledger already has a lot of options built in that make typing easier. For the Emacs environment, there exists even a ledger mode, which further simplifies the input by e.g. proposing suitable posting data, or recurring postings after a few typed letters, or inserting them completely. In addition, it offers quite comfortable functions to create reports, or regularly adjusting the posted data with the reality. The Ledger Mode will be a article of its own.

Medusa - The mother of all Hydras

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

One of the problems of all text editors is that they actually have to reconcile two different functions, capturing text, and editing of text. That we are seldom aware of how different these two tasks are is also part of the problem. Our mind tends to switch seamlessly between these two tasks.

We write a sentence, and even as we type it, we notice that after the last word it would have been better to have a comma, and that the whole paragraph might have been part of the introduction anyway, maybe as a quotation.

This way of working makes it necessary to switch between capturing and editing text at any time. Essentially, 3 approaches have prevailed. Common to all of them is that they often find the simple functions on their own keys (Delete, Tab, PageUp, etc …). For the more complicated cases we find:

The menu control (eg Word) with the problem that you have to switch between the mouse and keyboard back and forth for mouse operation.
A multiple assignment of the keys via ALT, CTRL, META, SUPER or HYPER keys. This is the area where Emacs is at home.
A leader key, which is a key that does not appear in normal text, and therefore serves to switch to edit mode. This is the domain of VIM

Spacemacs and the Leaderkey

Just like for me, also for the makers of Spacemacs the idea with the Leaderkey, is the way to go. So they have adopted the concept as far as possible and put it over an existing Emacs as a configuration. The charm is that it does not affect any of the usual features in Emacs, and now both types of operation can coexist. What has unfortunately been lost in my eyes, is the more systematic structure of the functions that Emacs usually brings. The Hydras delivered by Spacemacs (a kind of visual menu guide) rarely seem useful or easy to remember in my head

Thing at point

I get, for example, always the same Hydra when I press the Leaderkey, while you can choose in Emacs countless modes of operation, each requiring completely different ways of interaction.

In a recent blog entry from Derek Feichtinger, I recently found a very elegant solution that not only can provide different Hydras for the different modes, but is also still able to determine if the cursor is in the very popular Org mode on an object (such as a link or table), and then call a Hydra specific to that object.

Fallback

The elegant thing about this solution is that on the one hand it is very easy to expand, and on the other hand it also offers the possibility to call a standard Hydra if none of the special cases are present.

In the combination of different Hydras this offers unexpected possibilities. For example, my Leaderkey is the <menu> key, which is usually to the right of the space bar, and calls the context menu on Winows. With Linux this had never been a useful feature for me anyway.

In each Hydra, I programmed the <menu> key with the most frequently used function. This allows me to press the menu button twice and - in Org Mode - do the same thing that Ctrl-C Ctrl-C does, while in Ledger Mode a new booking is created instead.

Again, as with the Spacemac solution, all of the built-in Emacs buttons continue to work as normal, I've now integrated all the Hydras that I've created so far into the Medusa project, the sources are here.

My perfect typing environment. Finally.

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

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

The keyboard

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

The thoughts

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

I type a lot of programming code

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

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

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

The layout

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

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

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

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

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

You can see the result in the following image:

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

Conclusion

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

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

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

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