I know two ways to be wrong very well, but people have more ways to be wrong, and I don’t know the rest very well at all. But I’d like to.

The first way to be wrong - and the most wrong someone can be - is to make a contradiction. People do this when they get their sums wrong, miscounting how much money to give to a shopkeeper; or when they make contradictory statements, claiming that a politician they dislike has no right to do something, then claiming that everyone has a right to do the thing the next day, because their own political party’s members did the thing.

People who study types of wrong call this first type ‘analytically wrong’.

The second way to be wrong is saying something is the case when it isn’t. People do this kind of wrong all day, and we judge the wrong by degrees (when you’re only a bit wrong), or justification (when you had good reason to think something, overlooking a subtle detail) or intentions (because saying ‘you’ll be fine’ is fine, but saying ‘I think we ate the last cake already’ with the intention of checking the fridge later, alone, isn’t).

People who study types of wrong call this second type ‘synthetically wrong’, and focus on how universities and corporations can avoid being wrong, but almost never discuss the messy little allowances and unstated rules of being wrong-about-facts.

People have many more ways to be wrong.

This VPN uses military-grade encryption!

People say this about VPNs, which gives uninformed listeners the impression that:

• encryption comes in grades (it could, but it doesn’t),
• one of the highest is ‘military grade’, which is therefore ‘good encryption’ (unlike the standard encryption you buy at the shops),
• so this extra encryption must make you safer.

These statements are all synthetically wrong, but the original sentence? Is it wrong? The ‘military’ (whether that means Italian soldiers who look at Tik-Tok, or Chinese generals who want to transfer plans across China, or any other meaning), all use standard encryption, like TLS certs, mostly on their outdated Android phones and Windows 10 PCs. So is the sentence right? It seems about as right as saying ‘I eat military-grade breakfast cereal’.

For now, I’m calling this ‘presumptuously wrong’. It’s possible to show someone has a presumption, and to show it’s wrong when they’re making making short inferences. I have a Polish friend who noticed someone checking up on her, to make sure she didn’t steal anything, moments after learning she’s Polish. There’s only one difference to make the difference, so the check-up clearly came from bigotry. And more than clearly, her thinking was analytic.

• Premise 1: This person is Polish.
• Premise 2: Redacted
• Conclusion: Therefore, we must check she’s not trying to steal anything.

The missing step is as plain as x + 2 = 4. People may obfuscate this process, objecting ‘no, in fact:’

    0!
x = ───
    0.5

…and the assumptions around theft were not concerned with being Polish, but ‘simply that they were concerned about certain things, after reading certain reports, and taking certain facts into account…’ et c. ad obfuscatium. However it goes, following this thread just means taking the long-way around.

But that little trick-of-the-Maths works rarely. Mostly, people degenerate quickly into mind-reading accusations. Most people don’t act on a single piece of information simply because they have a lot more information. Give the aforementioned bigot another day, and he would have plenty of other facts he could plausibly have taken into account. Or if not ‘plausibly’, we could not deduce the bigotry from clean (not ‘pure’, but still ‘clean’) Mathematics. Likewise in the case of people advertising Nord VPN’s ‘military-grade encryption’, I can’t see any room for good motivations, but I can’t Mathematically verify bad intentions.

This kind of presumptuously wrong might just be the regular wrong but inferred, but it has sharp differences. It often looks like someone holding a world-view that’s wrong, and the statements are more of an indicator of the wrong than actually wrong themselves.

I found myself being presumptuously wrong a while ago while watching a CGP Grey video with a slippery question.

Which planet is closest to Earth?

The ‘gotcha’ here is that Earth and Mars revolve around the Sun, so they spend some time far away from each other. Once you start looking at how close other planets are to Earth on average, the answer turns out to be Mercury. But the video’s not about getting the question wrong, it’s about the underlying world-view that makes us think in terms of planets in a line.

For the past month or so, I’ve been using the standard editor: ed. It’s standard because it’s old and has outlived everything which came before it. And it’s so old that using it has become a bit of a meme, but it has lessons for anyone who wants to take it seriously.

Ken Thompson created ed to run on a typewriter connected to a computer (i.e. a ‘terminal’). He would type out what he wanted, and the typewriter would type any response. But long responses, like DOCUMENT SAVED SUCCESSFULLY or ALTERATIONS ACCEPTED. NEW LINE READS AS FOLLOWS: ... would waste paper. Instead, ed communicated success by staying silent, and communicated errors in your coding by typing ?. If you want to know what that ? means, you can get help by typing h. And if you want to know that typing h will help you then Ken Thompson expects you to read the manual before you start using the thing (it’s only 11,000 words, about the length of a newspaper if you ignore most of it).

Typing in ed won’t teach you much, except that you don’t like ed. But ed is not just made to type, save, and forget - Ken Thompson made it to edit files, and that’s where things get interesting.

Open a file to edit, and you see this:

9162

And that scares people. But don’t be scared. It’s a character-count for the document, so if you print out the document, the typewriter will need to go ‘thwack!’ 9,162 times to type the entire thing out. Sounds expensive!

Unlike Ken, I edit markdown files, which become pages like this thing you’re reading. So I start a session with ed by asking where the headers are in the document.

13  # Why Don't You Love Me, ChatGPT?
24  ## Generating Content
97  # How Double Your Content Output
118 ## Making Content with Makefiles
144 # Where is the Love?
194 ## How to be a Content-Chad Like Me

We can look at the section ‘Generating Content’ by asking ed to print lines 25 to 96:

25,96p

It’s a drag, but an interesting one. To move, to think around the document, you must deliberate in the document’s own terms (line-numbers) about which lines to read, and then what to add or change. And you can, of course, change; but again ed demands deliberation. You must specify which word you want to change to what, and the result (in the best case scenario) is nothing, because ed does not show you how the new line looks. The text document must live mostly in your head.

The syntax consists of basic mnemonics. You type s/one/two/ to substitute ‘one’ with ‘two’, or c to change a line. Moving lines uses ‘t’ for ‘to’, as in 37t24: ‘move line 37 to line 24’. The syntax matches sed exactly, which makes sense, since sed is the ‘stream editor, so the early users ofsedwould presumably think 'oh this is easy, it's just likeed'. But we rarely usesedenough to really learn it; or I never do. I look up a command when I need it, can't figure out *why* the command works like that, then forget the command immediately. Working a week withedhas made it easy to parse/^#/s/Ed/ed` (meaning ‘find the next line starting with “#” and substitute ‘Ed’ with ‘ed’).

Some of these substitution commands can look verbose, but ed comes with a rare feature; something present but mostly forgotten in vim, and entirely lost to modern editors like VS Code. You can script ed. Just like sed and awk, you can use this tool to work on a document until you feel sure you know what you’re doing, and a little bored. Once bored and certain, you can place your command in a script and make the computer do the work for you. I don’t use this feature much, just like I never used to imagine changing metadata with sed. Perhaps if I use it for another month it’ll become second nature. Some just find it easier to use than sed.

Whatever its direct uses on a document, it will always retain a similar benefit to using a paper-and-pen: it demands deliberation. No hopping around the document like a drunk hummingbird. No colour syntax or spellchecker. Just a blank page, and the question of what exactly you want to do in order to get your ideas pressed into the disk.

Modern wiki software only fits other people’s purposes - none seem designed for someone who has markdown notes and wants to interact with them. Switching wiki software demands changing the notes to adhere to the software’s new standards. I can’t find a single project which says ‘we will process your markdown’.

Gitlab’s wiki uses Gollum, which insists that links look like this:

Golum is an awful wiki.  See my [review here](/wikis/golum_review/).

But while you’re writing the file wikis/overview.md, then the natural way to link to wikis/golum_review.md should be a link to that file:

Golum is an awful wiki.  See my [review here](golum_review.md).

The link to another markdown file should say where that markdown file is. The linking system here clearly thinks in terms of a website address rather than linked notes.

The Gitea wiki has no such limit, but somehow manages to find a worse one: it cannot show files inside a directory and they don’t plan to change that limitation. This basic directory structure is impossible:

writing/
├── ed.md
├── emacs.md
├── ghostwriter.md
├── helix.md
└── vim.md
wikis/
├── gitea.md
├── golum.md
├── links.md
└── vim.md

Instead, everything must remain in the root directory. People have raised this as an issue, and the Gitea devs closed it, so now all the wikis have this structure:

├── ed.md
├── emacs.md
├── helix.md
├── ghostwriter.md
├── gitea.md
├── golum.md
├── links.md
├── vim.md
└── vim_2.md

Worst of all, both Gitea and Gollum suffer from a GUI which demands that spaces are represented with hyphens.

It’s a shite state of affairs.

Markdown apps are no better.

Every computer I see up-close has the same sad story. A mess of files sit on the desktop. In ‘Pictures’, random pictures sit (the user downloaded them before making a half-hearted attempt to organize) with a few folders, some marked ‘holiday’ (which one?), and others given names by the computer. Renaming the lot would require an unknown amount of time, none of it rewarding.

But it’s not the users’ fault. It’s like moving into a house with a ‘room for small things’, containing books and a toothbrush rack on the wall, and a ‘room for wet things’, containing the toilet, shower, and kitchen sink. The place comes with an in-built ontology, a default way of thinking, and all of it’s wrong.

People cannot organize their own basic files, and the blame for this horrifying mess lies entirely with Windows 98. People were told to have a ‘My Documents’ folder, and a ‘My Music’ folder, so that’s what they used.

These documents were created by engineers, who think in terms of filetypes. The .pngs and the .jpgs and .gifs into ‘My Pictures’, while the .mp3s and .wavs go into ‘My Music’, and .doc and .pdf documents use ‘My Documents’.

But people don’t think like this. They don’t organize their head or activities by filetype. They think in terms of work/ home, or friends/ family, or maybe pidgeons/ home-renovation, because people can be strange. These file structures are too important to have a default. People should make their own.

I deleted my defaults documents and rebuilt slowly, finding my own structure.

├── arc
│    { "Archives" for picturese, and other things I don't want to lose.
├── dl
│    ⎧ Downloaded items, to be sorted.
│    ⎨ Currently this sits at 541MB, so I really should think
│    ⎩ of a better way to handle downloads, that doesn't involve house-keeping.
├── img
│    { Art, memes, and surrealism.
├── kn
│    { "Knowledge Bases" mostly full of PDFs.
├── pro
│    ⎧ This chonky folder contains every git I've taken an interest in over the
│    ⎨ last five years, all my own writing, and a boat-load of forgotten dreams
│    ⎩ which I will never fully realise.
├── rec
│    ⎧ "Records" of bills, bibliographies, and any other list-type information. 
│    ⎩ Some are automated, like the list of all WiFis I've connected to.
├── sync
│    { Files synchronized with phone, like pictures, podcasts, music and notes.
├── vids
│    { "Videos" I want to watch later.

Kubernetes documentation feels like malicious compliance, a rebellion against the concept of clarity.

Kubernetes lets you ask about anything with the command kubectl explain $thing. So I did:

kubectl explain namespace

The results make me wonder if anyone sober has read the ‘explanations’.

KIND:       Namespace
VERSION:    v1

DESCRIPTION:
    Namespace provides a scope for Names. Use of multiple namespaces is
    optional.

Uhuh. So ‘namespace’ is a space, or ‘scope’, for ‘Names’ (why the capital?).

Use of multiple namespaces is optional.

Okay, so if I use one namespace, not two, or three, then Kubernetes will not create an error. This is similar behaviour to:

• Variables,
• functions,
• variables which begin with the letter ‘l’,
• owning a dog,
• and eating breakfast.

This sentence feels about as informative and surprising as saying that ‘Namespaces begin with the letter “N”’.

But the docs continue to inform us:

FIELDS:
  apiVersion    <string>
    APIVersion defines the versioned schema of this representation of an object.
    Servers should convert recognized schemas to the latest internal value, and
    may reject unrecognized values. More info:
    https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources

APIVersion defines the versioned schema…

So the ‘API version’…tells you the version?! But the version of what?

…of this representation of an object.

Well at least it didn’t say ‘API’.

So these objects are not real objects (like spoons and rocks) but representations of an object. Or perhaps the writers have drunk so much Python that they think some computer objects are comparatively real.

  metadata  <ObjectMeta>
    Standard object's metadata. More info:
    https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata

Presumably these ‘standard objects’ are more objects than the mere representation of objects. Am I studying Kant again?

  status    <NamespaceStatus>
    Status describes the current status of a Namespace. More info:
    https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status

Status describes the current status of a Namespace.

I think that should have been:

‘Status’ describes the current status of a Namespace.

Even by the standards of a vacuous pedant, the docs fail.

More info:

I really doubted this statement, but the URL ends in .md, which felt promising. In fact, the docs are in html, and not even very readable html.

I’m not a fan of the change from AD to CE, for two reasons.

The first reason is the weird assumptions built into the standard reasons to update.

“‘AD’ means ‘anno domini’, or ‘in the year of our lord’. It’s not an inclusive world-wide standard, not appropriate for countries of other faiths, or people of no faith. It smacks of our colonial history, so the term ‘common era’ (CE) works much better.

This sounds reasonable when ‘our history’ is colonialist, because we assume that the ‘us’ in question is the European nations who did all the colonialism. It sounds less reasonable when you say it in Serbia, a culture which has plenty of hang-ups from colonialism, but not their own. Within Serbia, Poland, and plenty of other nations outside of the ‘we, with our colonialist past’, it’s just a request to update their books and habits from outside. And why should they listen? Why should the academics of the UK tell people how to track time? Who are these outsiders who control the naming standards?

The demand to update does not come from colonised people. It comes from the ivory tower, washing their hands of their embarrassing past.

The second problem with changing the names is that you can’t. We can add a new name for ‘100 AD’, but cannot remove the old one. Old books will not be updated. Old contracts must be respected. We can’t outgrow the history of literature, so we cannot change this word. We can only add another word which means the same thing.

• This article was written for the lazy bear’s Vim Carnival

I have notes on lots of things. When you write notes in markdown it’s called ‘a knowledge base’, which sounds classy. So now I have lots of knowledge bases, and I strive to keep them bland and featureless.

A good knowledge base has no fancy features. Features are bad. They tie you down to particular software, or one workflow. Everything ‘integrated’ with the notes also holds onto your notes, jealously.

Proprietary solutions are prone to the usual abuse, but many open source note apps aren’t much better - they have their own oddities, and special markdown abilities, which won’t work in other contexts. This leaves you unable to publish notes, as that special in-line image format from a fancy app won’t work on a website.

The websites are no better. I publish with Hugo, and it’s great, but every theme also invites you to place special snippets for graphs or video

`{{ .video | youtube.com/?url=thing }}`

It looks harmless, but it’s a trap. The video link won’t work on other web compilers, or gemini, so the knowledge base will be tied to that particular software.

Hence Vim. Vim is harmless. It won’t tell you how to write or organize your notes. It just makes editing easy. Because vim is easy.

The Linux Knowledge Base

The collection of text notes on how to do stuff in Linux has grown and become opinionated. I’m slowly going over the pages to try and tag every single page with knowledge dependencies, i.e. what you need to know before reading the page.

Here’s the head of one page on editing files encrypted with GPG:

---
title: Edit gpg encrypted files with vim
tags: 
- vim
- data
- gpg
- comfy
requires: 
- data/gpg.md
- writing/vim.md
---

The `vim-gnupg` plugin lets vim edit gpg-encrypted files as if they were unencrypted.

[...]

That ‘requires’ tag means I can generate a note at the top of the pages saying what you need to know before reading the page.

I have not tagged all pages yet, but once I do, the website will state what’s required to read an article at the front. This will make me happy, because documentation should not have links in the body.

Vim with a Knowledge Base

File Navigation

Open & Search

Open a file at line 20:

vim writing/ed.md +20

Open the file while searching for the word ‘Delete`:

vim writing/ed.md +/Delete

Buffers & Tabs

You can open multiple files with Vim and navigate with ‘buffers’ (the word still feels strange).

vim writing/*.md

The command :ls shows the buffer, and b2 takes you to buffer 2 (writing/vim.md) in this case.

:ls
  1 %a   "writing/ed.md"                line 1
  2      "writing/vim.md"               line 0
  3      "writing/vim_tricks.md"        line 0
:b2

You can also cycle through them.

• Select the next buffer with :bNext (or :bn).
• Select the previous buffer with :bPrevious (or :bp).
• Select the last buffer on the list with :bLast (or :bl).

Tabs are similar, but you can see the tabs at the top.

Open files in tabs with -p.

vim -p writing/*.md

Then use :tabedit % to open a new tab.

Go-to-File

If you put the cursor on a file’s name, you can go to the file immediately with gf. This is excellent, as it lets you wander your own knowledge base as if a palace.

Weird markdown formats, like Gollum sometimes demand that you leave out the .md suffix in links, so your link to [GPG](gpg.md) won’t work. You have to write [GPG](gpg). Vim lets you navigate to gpg.md anyway by adding a standard suffix:

set suffixesadd=.md

Now you can go to the word gpg and press gf, and instantly enter that file.

If the file is in another directory, you can link to it like this:

Check [the standard editor](writing/ed.md) for why `sed` works like this.

But you might want to link to it like this:

Check [the standard editor](ed.md) for why `sed` works like this.

In this case, you can still navigate to it by adding all the other directories to the path where Vim checks. Just add this to your vimrc file:

set path+=**

Edit Jumps

• g; to go to the last place you edited.
• g, to jump back through edit-locations.

Netwr Navigator

On rare occasions, I’ll use the in-built navigator: Netwr. There’s an excellent setup guide here as it’s not very good ‘out-of-the-box’.

Editing

Mapping Keys to Output

Notes on Linux means lots of code-blocks, which look like this:

 ```
 ls
 ls -a
 ```

This is boring to type, so now I just type ‘comma’ then ‘grave’, and vim produces the code block. You can map the keypress by sticking this in ~/.vim/vimrc:

map ,` o```<Enter>```<Esc>kA

Interactive Find and Replace

Sometimes you want to find and replace a word in a lot of files, but also confirm each change. Vim lets you do this by starting up with a ‘find and replace’ command:

vim -c "%s/${nano}/${vim}/gc" -c 'wq' **/*.md

Input Command Outputs

Vim can run a command and type out the results for you:

:r!date

Thu 16 Apr 13:08:48 CEST 2026

Writing with Markdown

Set up a Spell Checker

I have the standard spell-checking commands in my vimrc, but the command to actually use the spell-checker hides in the markdown-only file, because you don’t always want a spell-checker on.

set spelllang=en_gb
set complete+=kspell

hi clear SpellBad
hi SpellBad cterm=underline
hi SpellCap cterm=underline
hi SpellLocal cterm=underline
hi SpellRare cterm=underline

All those hi-light commands make Vim’s spell-highlights less nauseating.

In the markdown-only setting, add this to actually use those spell-checking commands:

setlocal spell

Once you have the spell-checker working, it just has a few commands:

• z= asks the wordlist for suggestions on better spelling.
• zg accepts a word as a word, and adds it to your dictionary in ~/.vim/spell/.
• zug removes a word which is not a word.

If, like me, you speak a kind of English which people describe as ‘not default’, you should share this spelling file with all your computers, so you don’t have to rebuilt it every time.

This next command is amazing. Once you start using it, you won’t stop, and may look back on all the years you never had it and weep.

inoremap <C-l> <c-g>u<Esc>[s1z=gi<c-g>u

If you type a typo, you can press Control + L to jump back, fix the typo (with Vim’s first guess at the correct spelling) and then jump back, all during insert mode.

Formatting Text Lines

I still don’t know how to do this. On the one hand, writing one sentence per line helps when using git, and feels natural. But it feels less natural to read.

As an example, that last paragraph has a new line on each sentence:

I still don't know how to do this.
On the one hand, writing one sentence per line helps when using `git`, and feels natural.
But it feels less natural to read.

Option 1: have a separate markdown reader.¹ Markdown is supposed to wrap lines for you, so you can break anywhere.

Option 2: wrap the lines with vim.

I can press gqap to reformat the paragraph, and it looks better.

I still don't know how to do this.  On the one hand, writing one sentence per
line helps when using `git`, and feels natural.  But it feels less natural to
read.

However, every time you edit, you need to wrap the lines again.

Not Vim with a Knowledge Base

The best thing about using Vim is not using Vim. After all, it’s just a text editor. As mentioned above, features are bad. Vim happily works with other tools by integrating those command. Like the Tao, it does nothing, and accomplishes everything.

Link Checks

Having plain text means easy parsing. I have a little bash script which searches markdown files for links, and checks to see if they work, then spits out a list of dead links. I’ll stick the script at the end in case anyone wants to use it for their weighty collection of markdown files.

Make Stuff

The Makefile at the root of knowledge base automates the standard commands. The first command is a help menu. I want the project to be friendly in case anyone else wants to join me in my quest to rid documentation of links inside the body.

make

article         Write a new article
clean           Remove all generated files
database        Make a recfiles database
help            Print the help message
map             Show knowledge dependency map

make article will create a standard article template then commit it to the git repository.

The Dependencies Map

Each setup guide and note lists what you need to understand before starting. If you have graph-easy installed, you can run make map and see a full graph of dependencies (example at the end).

Recfiles

Recfiles are plain-text files which are also a relational database. They look like this:

%rec: guide
%key: title
%type: requires rec guide
%type: provides rec guide
%type: wordcount int
%sort: wordcount

file: data/gpg.md
title: gpg
tag: data
tag: gpg 
wordcount: 13

file: hardware/brightness.md
title: brightness
tag: hardware
tag: laptop 
wordcount: 16

[...]

This file is a record of every file in the knowledge base, along with the word-count.

The Commands List

Recently, I’ve begun another recfile database for commands. I have a boat-load of little commands that don’t merit their own page/post/article, and really just exist so I can search for them quickly.

  $ recsel ~/LK/command.rec -q qr

aim: Make a QR Code image:
cmd: qrencode 'https://play.google.com/store/apps/details?id=org.briarproject.briar.android' -o "$FILE".png
bin: qrencode
tag: qr

aim: Make a QR Coded message in the terminal:
cmd: qrencode -t ansi "Hello World"
bin: qrencode
tag: qr

aim: Read a QR Code image:
cmd: zbarimg $FILE
bin: qrencode
tag: qr

aim: Show wifi QR code (only with Network Manager):
cmd: nmcli device wifi show-password
bin: qrencode
tag: qr
tag: wifi

Links

If you want to check the project, it’s available over ssh:

ssh -p 2222 soft.dmz.rs -t lk

…or at Gitlab.

Appendix A

Link Check Script

#!/bin/sh

set -e

timeout=4

find_links(){
    echo "$1"
    sed '/```/,//d' "$1" | \
    sed -nr 's/.*\[.+\]\(([^ )]+).*/\1/p ; s/^\[[^\^]*\]:\s(.*)/\1/p'
}

check_link(){
    while read link; do
        if "${link##*:*}"; then
            check_file "$link" "$file"
        else
            prefix="${link%%:*}"
            case "${prefix}" in 
                http) check_http_link "$link"
                ;;
                https) check_http_link "$link"
                ;;
                gemini) check_gemini_link "$link"
                ;;
                mailto) echo "ignoring email: $link"
                ;;
                magnet) echo "ignoring torrent: $link"
                ;;
                *) echo "$file: unknown protocol $link"
                ;;
            esac
        fi || dead_link_error "$link" "$file"
    done
}

dead_link_error(){
    echo "$2: $1"
}

check_file(){
    path="${1#/}"
    path="${path%#*}"
    test -f "$path" \
    || test -f "$path".md \
    || (
        cd "$(dirname "$2")" && \
        test -f "$path" || test -f "$path".md
    )
}

check_gemini_link(){
    gemget --max-time "$timeout" "$1" -o- >/dev/null
}

check_http_link(){
    timeout=$(( timeout + 1 ))
    curl --connect-timeout "$timeout" -Is "$1" >/dev/null
}

check_markdown_links(){
    find_links "$1" | check_link
}

#################

test -z "$1" && targets="*.md" || targets="$@"

for file in $targets; do
    test "${file##*.}" != "md" || check_markdown_links "$file" &
done

wait

The Dependencies Map

A lot of work remains, but right now the dependencies map looks like this:

                            ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐     ┌−−−−−−−−−−−−−−−−−−−−┐
                            │      GPG Basics      │ ──> ╎              pass              ╎ ──> ╎   pass with otp    ╎
                            └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘     └−−−−−−−−−−−−−−−−−−−−┘
                              │
                              │
                              ∨
                            ┌−−−−−−−−−−−−−−−−−−−−−−┐
  ┌───────────────────────> ╎     gpg with vim     ╎
  │                         └−−−−−−−−−−−−−−−−−−−−−−┘
  │                         ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐     ┌−−−−−−−−−−−−−−−−−−−−┐
  │                         │   Kubernetes Setup   │ ──> ╎       Kubernetes Basics        ╎ ──> ╎  Kubernetes Docs   ╎
  │                         └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘     └−−−−−−−−−−−−−−−−−−−−┘
  │                                                        │
  │                                                        │
  │                                                        ∨
  │  ┌−−−−−−−−−−−−−−−−┐     ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐
  │  ╎   virtualbox   ╎ <── │   Managing Groups    │     ╎           Proxy API            ╎
  │  └−−−−−−−−−−−−−−−−┘     └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘
  │                           │
  │                           │
  │                           ∨
  │                         ┌−−−−−−−−−−−−−−−−−−−−−−┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐
  │                         ╎        Docker        ╎ ──> ╎      Ansible with Docker       ╎
  │                         └−−−−−−−−−−−−−−−−−−−−−−┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘
  │                         ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐                                ┌−−−−−−−−−−−−−−−−−−−−−−−−−−┐
  │                         │    LaTeX Packages    │ ──> ╎            Calendar            ╎                                ╎ nginx logs with recfiles ╎ <───────────────────────────────────┐
  │                         └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘                                └−−−−−−−−−−−−−−−−−−−−−−−−−−┘                                     │
  │                                                                                                                          ∧                                                              │
  │                                                                                                                          │                                                              │
  │                                                                                                                          │                                                              │
  │                         ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐     ┌────────────────────┐     ┌──────────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐  │
  │                         │       Makefile       │ ──> ╎  Recfile Bibliography for TeX  ╎ <── │        TeX         │     │                          │ ──> ╎ Board Games with Recfiles  ╎  │
  │                         └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘     └────────────────────┘     │                          │     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘  │
  │                                                        ∧                                                               │                          │                                     │
  │                                                        └────────────────────────────────────────────────────────────── │         Recfiles         │                                     │
  │                                                                                                                        │                          │                                     │
  │                         ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐                                │                          │     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐  │
  │                         │      Makefiles       │ ──> ╎ Python Projects with Makefiles ╎                                │                          │ ──> ╎ IP Addresses with Recfiles ╎  │
  │                         └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘                                └──────────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘  │
  │                                                                                                                          │                                                              │
  │                                                                                                                          │                                                              │
  │                                                                                                                          ∨                                                              │
  │                         ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐                                ┌−−−−−−−−−−−−−−−−−−−−−−−−−−┐                                     │
  │                         │    Shell Scripts     │ ──> ╎            Newsraft            ╎                                ╎         Recfixes         ╎                                     │
  │                         └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘                                └−−−−−−−−−−−−−−−−−−−−−−−−−−┘                                     │
  │                         ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐                                                                                                 │
  │                         │     Taskwarrior      │ ──> ╎   Taskwarrior Configuration    ╎                                                                                                 │
  │                         └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘                                                                                                 │
  │                           │                                                                                                                                                             │
  │                           │                                                                                                                                                             │
  │                           ∨                                                                                                                                                             │
  │                         ┌−−−−−−−−−−−−−−−−−−−−−−┐                                                                                                                                        │
  │                         ╎ Taskwarrior Contexts ╎                                                                                                                                        │
  │                         └−−−−−−−−−−−−−−−−−−−−−−┘                                                                                                                                        │
  │                         ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐                                                                                                 │
  │                         │       certbot        │ ──> ╎       radicale and nginx       ╎ <─────┐                                                                                         │
  │                         └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘       │                                                                                         │
  │                         ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐       │                                                                                         │
  │                         │         cron         │ ──> ╎         Search System          ╎       │                                                                                         │
  │                         └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘       │                                                                                         │
  │                                                                                               │                                                                                         │
  │                           ┌───────────────────────────────────────────────────────────────────┼──────────────────────────┐                                                              │
  │                           │                                                                   │                          ∨                                                              │
  │                         ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐     ┌────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−┐                                     │
  │                         │                      │ ──> ╎     Soft Serve Maintenance     ╎ <── │                    │ ──> ╎ Soft Serve through https ╎                                     │
  │                         │                      │     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘     │                    │     └−−−−−−−−−−−−−−−−−−−−−−−−−−┘                                     │
  │                         │                      │                                            │                    │                                                                      │
  │                         │         git          │ ────────────────────────────────────────┐  │       nginx        │ ─────────────────────────────────────────────────────────────────────┘
  │                         │                      │                                         │  │                    │
  │                         │                      │     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐  │  │                    │     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−┐
  │                         │                      │ ──> ╎           git stash            ╎  │  │                    │ ──> ╎        Soft-Serve        ╎
  │                         └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘  │  └────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−┘
  │                           │                                                              │                               ∧
  │                           │                                                              └───────────────────────────────┘
  │                           ∨
  │                         ┌−−−−−−−−−−−−−−−−−−−−−−┐
  │                         ╎       git-lfs        ╎
  │                         └−−−−−−−−−−−−−−−−−−−−−−┘
  │                         ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐     ┌────────────────────┐
  │                         │      partitions      │ ──> ╎          Install Arch          ╎ <── │        time        │
  │                         └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘     └────────────────────┘
  │
  │                           ┌───────────────────────────────────────────────────────────────────┐
  │                           │                                                                   ∨
  │  ┌−−−−−−−−−−−−−−−−┐     ┌──────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐     ┌−−−−−−−−−−−−−−−−−−−−┐
  │  ╎   ssh-tricks   ╎ <── │         ssh          │ ──> ╎         Ansible Basics         ╎     ╎       sshfs        ╎
  │  └−−−−−−−−−−−−−−−−┘     └──────────────────────┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘     └−−−−−−−−−−−−−−−−−−−−┘
  │                           │
  │                           │
  │                           ∨
  │                         ┌−−−−−−−−−−−−−−−−−−−−−−┐
  │                         ╎       fail2ban       ╎
  │                         └−−−−−−−−−−−−−−−−−−−−−−┘
  │
  └───────────────────────────┐
                              │
     ┌−−−−−−−−−−−−−−−−┐     ┌─────────────────────────────────────────────────────────────┐     ┌−−−−−−−−−−−−−−−−−−−−┐
     ╎  vim linewrap  ╎ <── │                                                             │ ──> ╎ How to Learn `vim` ╎
     └−−−−−−−−−−−−−−−−┘     │                                                             │     └−−−−−−−−−−−−−−−−−−−−┘
     ┌−−−−−−−−−−−−−−−−┐     │                                                             │     ┌−−−−−−−−−−−−−−−−−−−−┐
     ╎ vim navigation ╎ <── │                         vim basics                          │ ──> ╎  find and replace  ╎
     └−−−−−−−−−−−−−−−−┘     │                                                             │     └−−−−−−−−−−−−−−−−−−−−┘
     ┌−−−−−−−−−−−−−−−−┐     │                                                             │     ┌−−−−−−−−−−−−−−−−−−−−┐
     ╎  vim windows   ╎ <── │                                                             │ ──> ╎       sc-im        ╎
     └−−−−−−−−−−−−−−−−┘     └─────────────────────────────────────────────────────────────┘     └−−−−−−−−−−−−−−−−−−−−┘
                              │                            │
                              │                            │
                              ∨                            ∨
                            ┌−−−−−−−−−−−−−−−−−−−−−−┐     ┌−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┐
                            ╎    vim completion    ╎     ╎          vim in bash           ╎
                            └−−−−−−−−−−−−−−−−−−−−−−┘     └−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−┘

Assumed Knowledge: make, GPG, git.

You can manage dotfiles with nothing but make and standard tools.

• Copy standard configs.
• Track changes with git.
• Keep separate branches for each computer.
• Securely handle secret files with GPG.
• Manage crontab.

The Setup

Mine looks like this:

config/:
 aerc         cava       khard         rofi      tut            picom.conf
 alacritty    cmus       lf            s         vdirsyncer     powerbash.sh
 amfora       dunst      ncmpcpp       sc-im     waybar         powerbashrc
 bat          gtk-3.0    newsraft      sway      zathura        redshift.conf
 bottom       himalaya   procps        systemd   compton.conf
 bugwarrior   i3         profanity     task      mpd.conf
 calcurse     i3blocks   qutebrowser   tspreed   mpv.conf

home/:
 gnupg   mozilla   vim   bash_profile   gitconfig          inputrc     xinitrc
 local   unison    w3m   bashrc         gitignore_global   tmux.conf   Xresources

Hard Links

Standard configs are made with hard links, which means these two files are the same file:

• dotfiles/home/bashrc
• .bashrc

Once you edit ~/.bashrc, that also changes dotfiles/home/bashrc. A make pattern takes care of the path, so there’s no need for dots in your dotfile manager.

$HOME/.%: home/%
    ln -f $< $@

Command-Based Files

Some files are usually created through commands, like ~/.gitconfig. These can change on different computers, as you add git lfs on one, or a credential helper on another. So if you don’t want to keep them in sync, you can just put the universal commands into a Makefile. If your name ever changes, then all computers receive that change, but nothing will touch the strange git helpers installed on that old laptop.

$(HOME)/.gitconfig: git.mk
    git config --global user.name "$yerName"
    ...

The same approach lets you manage secrets. For example, you can set the secret token value in glab (the Gitlab CLI tool):

git_token != pass gitlab-token
glab config set token "$(git_token)" --host gitlab.com

Secrets Management

You can use pass to manage secrets with make. For example, to keep ~/.config/aerc/accounts.conf as a secret file, just throw it into pass:

cat ~/.config/aerc/accounts.conf | pass insert --echo config/aerc/accounts.conf

Add this file as a secret, and make a rule to create these secrets from all the files in ~/.password-store/:

secrets += ${HOME}/.config/aerc/accounts.conf

$(secrets): ${HOME}/.% : ${HOME}/.password-store/%.gpg
    mkdir -p $(@D)
    chmod 700 $(@D)
    gpg --quiet --decrypt $< > $@ 
    chmod 600 $@

Handling Crontab

Changes in different computers’ crontab files can inflict a lot of merges. Avoid this by just making each set of tasks its own file:

echo '@daily import_events.sh "https://dmz.rs/events.ical"' > extra/cron/calendar
echo '@hourly mbsync -a' > extra/cron/email

Combine the lot with cat, then import this into cron:

cron.txt: $(wildcard extra/cron/*)
    cat $^ > $@
    crontab $@

Example Repo

You can find my basic setup here:

ssh -p 2222 soft.dmz.rs -t mkdots

Or just clone the repo and see how it works:

git clone ssh://soft.dmz.rs:2222/mkdots .dots
cd .dots
make -n

If we accept the premises of the Newcomb Problem, then it’s not possible to receive $1,001,000 from playing this game. But you have the choice to take both boxes, and therefore the mystery-box is empty.

Once you approach the boxes to make your decision, the boxes have been determined. From this point, we know that:

(A) You cannot end this game with $1,001,000.

We know this because it’s a stipulation of the problem: nobody walks out of here with both boxes full of cash. We can’t violate this rule, or we are negating the premise of the paradox.

Another stipulation is the choice:

(B) You may choose to take both boxes.

If the mystery-box contains $1,000,000 and you have the option to take both boxes, then you can walk out of here with $1,001,000. But since you cannot leave with this money, and you may take both boxes, we can conclude that the mystery box is empty.

Suppose the opposite:

(C) The mystery box contains $1,000,000.

More formally:

C ∧ B -> ¬ A

A -> ¬ (C ∧ B)

¬C ∨ ¬B

So if we accept B (another stipulation of the puzzle itself) then we must accept that C is false.