Language-server-protocol (lsp) is standard to communicate information about a current programming project to an editor integration, powered by a “language server” for the specific programming language. Emacs has two major implementations of this editor functionality: eglot (built-in) and lsp-mode. Getting this set up is usually one of the first things that new users will want to do, but in my experience one can get by for a surprisingly long time using Emacs without needing to reach for eglot or lsp-mode. That is because many of the functions that lsp-servers provide can be provided by Emacs through other means.

As someone who quite often moves between different programming languages, I find the need to set up each lsp-server to a bit clunky. Despite being presented as a simple one-stop solution, you often need to research exactly what server to use, how to set it up, and to tailor it to your machine in some ways. For me, this only makes sense in a few languages that I use often, and even then it might not be the first thing I take care of.

(defun cape-language (&optional interactive)
    (interactive (list t))
    (if interactive
        (cape-interactive #'cape-language)
      (cape-wrap-super #'cape-dabbrev #'cape-dict)))

(add-hook 'completion-at-point-functions #'cape-history)
(add-hook 'completion-at-point-functions #'cape-keyword)
(add-hook 'completion-at-point-functions #'cape-file)
(add-hook 'completion-at-point-functions #'cape-language)
(add-hook 'completion-at-point-functions #'cape-abbrev)

(use-package etags-regen
  :config
  (setq etags-regen-ignores
        '("*.pyc" ".git" ".venv" "venv" "node_modules"))
  (etags-regen-mode 1))

(setq xref-show-xrefs-function #'consult-xref
      xref-show-definitions-function #'consult-xref)

The debate surrounding llm-generated code is more intense than ever. There are some people who have recently tried to turn this debate into action as an attempt to stem the tide of llm contributions that are flooding maintainers. Most notably Vim “Classic” and my own adopted public git forge of Codeberg. This is a shame, since it flies against the spirit of Free (Libre) and Open Source Software (floss).

Linus Torvalds has effectively been vibe-coding the Linux kernel for decades (his models being the world’s best kernel programmers and his agent harness email) and that has clearly turned out fine, but I still write most my code the old-fashioned way (at least in a raw loc-way) because I think that the hardest parts about programming are not solved by llms. I also do not like to refer to llms as “ai”.¹

You are of course free to not accept contributions made by llms (or any contribution for any reason) to your own project, and you are also not forced to host someone else’s vibe-coded projects on your infrastructure; the beauty of floss is that they are then also free to fork your project.² But rejecting code not for technical reasons (of which there are often many for vibecoded code) but for ideological reasons is unfortunate.

At the same time there is of course a genuine problem for maintainers happening that I do not know how to solve. One possible solution may be to only accept contributions that you yourself believe to be written by a human, while nominally accepting llms to be used in any capacity. This means that llms can be used when they are useful, but that code must remain readable and succinct enough for humans to process and develop.

llms are fundamentally a tool. Trying to ban llms is giving them too much credit; it is contributing to the framing made by companies like Anthropic and Openai that llms are a new class of software that is so powerful it must be banned, and entirely unlike all the other tools that make software development easier. Imagine banning the use of compilers and only accepting contributions written in Assembly as a way to reduce the number of contributions. It works, but is it in any way reasonable?

Such a policy — that contributing to a project because of the circumstances of the contribution’s creation, and not due to its quality — is directly contradictory to the spirit of free software. Being able to read, spread, and easily customize a program is just as useful as being able to merely run it. And the long-term strengths of free software is that it can adapt to everyone’s (collective) needs instead of each person building their own custom software.³

Arguments that llms fundamentally a part of a system of political oppression fall flat against the case of open-weight models that can be run at home on (high-end) consumer hardware. Are you going to be against online search in general because most people use Google as their provider?

The Russian-born French philosopher Alexandre Kojève pointed out that — when studying the history of Hegel’s geist — it is uninteresting to study the existence of the nihilist, because the path of nihilism is one of (intellectual) suicide. This is what is happening to these projects ideologically opposed to llms; projects like Vim Classic. They are intellectually oriented not towards improving the program either through bug-fixes or new features, but merely towards making sure that every line of code was written by hand (wilfully ignoring other automated tools such as lsp, the aforementioned compilers, macros, automated config tools, even editors themselves!). There are features that could be in the next release of my beloved Emacs right now because they have been blocked because of the initial use of an llm.⁴

If you actually care about the direct impacts and externalities of llms, this is not the path forward. It shutting your eyes and plugging your ears to the reality that llms are widely used to develop software, akin to what the Qing empire did during the heyday of European colonialism. Instead the solution might be to solve the underlying causes of overconsumption, fossil fuel use, and increasing inequality. ❦

Writing this, I have arrived at the island of Formosa, the adopted home of the Republic of China (中華民國) as well as the Taiwanese people. I intent to stay here during the fall term, as I complete part of my studies abroad.

This journey (as planned) will be the longest time I have been away from home, amounting to a rough 2% of my then-lived lifetime. I have always been a part of a very internationalized family, with Oslo and Berlin holding especially fond places in my heart. But thinking of being away from Stockholm, I am nonetheless filled with a sense of yearning in my heart:

Of cities I know in the world

Thou are the city that has it all

Through the Malar’s love to the sea

A mixture of salty and sweet.

Last year, while I was visiting the prc, I was tasked to photograph everything I ate while I was away. This was a wonderful idea, and one that I wish to adapt to my longer stay away. For this aim I have created a sub-blog, generated with similar tooling as that of the main blog. It can be found at https://joarvarndt.se/food/, with the landing page showing one meal for every (Gregorian) calendar day. This is automatically generated by a small Emacs lisp program building on my use of my own fork of org-static-blog. This means that each entry is itself a full post, that I could theoretically fill with entire essays if I wished it. Head on over and check out if anything looks tasty, right now there are

(message "%s posts (last updated %s)"
         (length (directory-files
                  "~/Documents/blog/food/posts/"
                  nil
                  directory-files-no-dot-files-regexp))
         (format-time-string "%B %d, %Y"))

66 posts (last updated October 16, 2026)

for you to look through! If you want to subscribe to these (short) posts, I have created a dedicated rss feed for that.

It is developed as a subproject to the main blog using git, and so the two are heavily interwoven with each other. The css stylesheet of the “sub-blog” even @import-s the main blog stylesheet, only changing the few parts that need custom tweaking. That way the small, incremental improvements and opinionated changes I make to the main blog’s design will automatically carry over into this project.

I have some expectations written down privately that I plan to go through once I return, an inspiration from a friend who recently returned from a time in the orient. Hopefully these will be interesting to cover once I finish my time here. My initial impression is that it is quite similar to the mainland¹ but still distinctly different. How to describe these differences I do not yet know.

One wonderful surprise is how every receipt is a lottery ticket as part of a scheme to incentivise people to demand them, and thus make it harder for businesses to avoid taxes. It is interesting to see how one can use the otherwise destructive tendencies exploited by gambling for a noble cause.

So far I have been very warmly welcomed, and I look forward to a great time familiarising myself with this foreign country and its people. ❦

I have found a peculiar delight in encryption, and particularly in using pgp-based asymmetric cryptography. This is especially useful for securing email communications, but doing so requires remembering to run M-x mml-secure-sign or mml-secure-encrypt in Mail Utilities For Emacs (Mu4e) before sending the message. For this reason I have been wanting to write a quick method that automatically adds signing capabilities and encryption only when the recipient has a public key. Thankfully, I did not have to do so because of Nicolas Cavigneaux’s recent post Sign Always, Encrypt When Possible where he showcases his functions for doing exactly that. It prompted me to tweak it slightly, and to add the functionality to automatically discover public keys that I have yet to import.

Cavigneaux’s post sets up an elegant arrangement: email should always be signed with your pgp key, and you should “upgrade” from there to encryption only if your correspondent can handle encrypted mail and has shared their public key with you. This is done by using Emacs’ built-in Easy Privacy Guard (epg) tooling to compare the owners of the imported public keys on the machine with the list of recipients in an email.¹ If you have the public key for all recipients, the message will be automatically encrypted — otherwise it will merely be signed to prove that you are the author.

This was exactly what I had wanted, and I quickly incorporated this functionality into my own configuration. Testing it out, I felt a bit uneasy sending encrypted mail automatically. Because it is not the default, I felt that fully automated encryption made me unsure whether the mail has been encrypted or not — even when I know I have the recipient’s public key. I thus made the slight modification of prompting for both encryption and signing:

(defun kudu/message-sign-encrypt-if-all-keys-available ()
    "Add MML tag to encrypt message when there is a key for each recipient,
sign it otherwise."
    (if (bounga/message-all-epg-keys-available-p)
        (if (y-or-n-p "Encrypt? ")
            (mml-secure-message-sign-encrypt)
          (when (y-or-n-p "Sign? ")
            (mml-secure-message-sign)))
      (when (y-or-n-p "Sign? ")
        (mml-secure-message-sign))))

In practice I will probably always be pressing Y when prompted, but this adds a level of certainty that the code is running correctly. It reminds me of an advertising gimmick for housewives in the 1950s: when cake mix first became available, it was not appreciated because it was perceived as being “too easy” — it did not feel like baking a cake yourself. And so the recipe was tweaked to simply require an extra egg to be added. In practice this was a trivial change, but it meant that you felt more responsible for the finished work.

But there is an additional step I want to automate that Cavigneaux alluded to, but did not implement. He writes:

[T]he policy is only as good as my keyring. Encryption depends on having imported the right public keys; nothing here fetches them for me.

I have recently been having more correspondence with people using the Swiss-based email provider Protonmail. Proton provides support for the Web Key Directory (wkd) method of providing keys, where the dns settings of a domain point to a file containing a public key for a specific user. This allows the email itself to “provide” its own public key for encryption. The public key of any @protonmail.com or @pm.me address can be quickly imported in a second using gpg --locate-external-keys email@pm.me. Proton will similarly use wkd to get your public key, and so you will receive encrypted mail as well. This is still easy to set up for any other email provider, as long as you can edit the domain settings.²

Sadly, epg does not come with any options for Gnupg’s --locate-keys or --locate-external-keys flags. This might be a good addition. In the meantime, we can write a quick and dirty function to do the job for us in the background when opening any new email:

(defun kudu/message-locate-keys ()
  "Tries to find the public keys of 'bounga/message-recipients' via WKD through --locate-keys."
  (dolist (recipient (string-to-list (bounga/message-recipients)))
    (let ((recipient-email (cadr recipient))
          (proc (make-process
                 :name "gpg-locate-keys"
                 :command (list epg-gpg-program "--no-tty" "--locate-keys" (cadr recipient))
                 :connection-type 'pipe
                 :filter (lambda (proc string)
                           (process-put proc 'output
                                        (concat (or (process-get proc 'output) "") string)))
                 :sentinel (lambda (proc event)
                             (when (eq (process-status proc) 'exit)
                               (let ((output (process-get proc 'output))
                                     (email (process-get proc 'email)))
                                 (cond ((and output (string-match-p "imported: [1-9]" output))
                                        (message "Public key imported for %s" email))
                                       ((and output (string-match-p "pub" output))
                                        (message "Public key available for %s" email))
                                       (t (message "No public key found for %s" email))
                                   )))))))
      (process-put proc 'email recipient-email))))

We use --locate-keys because the stricter --locate-external-keys will check the domain even if a key already exists in the local keyring. --locate-keys will instead instantly find local keys and finish early, while only missing keys will be checked. This is done asynchronously through make-process so that it does not cause the ui to freeze as we wait for network requests to finish. gpg seems to check very quickly, so it is not a large performance hit regardless.

We want to have imported any new keys before sending our email because Cavigneaux’s functions are run on 'message-send-hook. We therefore run kudu/message-locate-keys much earlier:

(add-hook 'mu4e-view-rendered-hook 'kudu/message-locate-keys)

This adds any correspondents’ public keys on any opened email, and so does not have to go through your entire contacts list. A downside is that it does not check for a public key when you are the person sending an unsolicited email, but it will when you get their reply.

This is not the world’s most elegant function, and if someone more familiar with epg has any comments regarding ways to improve it I will happily edit this post for improvements. Just send me a (pgp encrypted!) email. Run echo 'am9hcnhwYWJsb0B2b25hcm5kdC5zZQ' | base64 --decode | xargs gpg --locate-external-keys to import my key. If you have wkd set up, I will automatically fetch your public key. If not, this is a great opportunity to fix that!

Gnupg’s --locate-keys can also be made to automatically check public keyservers, such as the popular keys.opengpg.org one. To do this, add this line to ~/.gnupg/gpg.conf:

auto-key-locate clear,local,wkd,keyserver

And then this to ~/.gnupg/dirmngr.conf:³

keyserver hkps://keys.openpgp.org

I will also note how wonderful Emacs and epg make working with encrypted files, messages, and/or text more generally. I must admit that I used a plain-text .authinfo for an embarrassingly long time to store some of my secrets, thinking it would be bothersome to use the encrypted .authinfo.gpg for auth-sources. If you are like me, do not worry — the peace of mind from being able to write down personal information and simply leave it scattered on your filesystem is well worth just having to type your password. ❦

(defun bounga/message-recipients ()
  "Return a list of all recipients in the message, looking at TO, CC and BCC.
Each recipient is in the format of `mail-extract-address-components'."
  (mapcan (lambda (header)
            (let ((header-value (message-fetch-field header)))
              (and
               header-value
               (mail-extract-address-components header-value t))))
          '("To" "Cc" "Bcc")))

The concept of fomo has always alluded me. Part of the reason is a persistent need for eccentricity, for growing against the grain. That is not to say that I am persistently rebellious, but that there is a natural aversion to doing things “the way everyone else does it”.

The word eccentricity has for me always evoked a relation to its meaning within astrodynamics¹ — the amount by which a given orbit deviates from a “perfect” circle to an ellipse. For a spacecraft raising or lowering one’s orbit requires entering into an elliptical orbit before one can circularise, meaning that an eccentric orbit often means that an object is either shooting away from a body or crashing down toward it, only to gently miss. By comparison a circular orbit is merely the stable, unchanging floating above another world. The eccentric is instead constantly changing speed and direction, moving towards and away by large amounts while maintaining some sort of liminal existence.

Seinfeld (1989-1998) is one of the most influential sitcoms of all time, rivalled only by its contemporary Friends. It covers the dramatized life of the titular Jerry Seinfeld, a comedian who is played by himself, in New York City. Jerry’s life, like in most sitcoms, is closely intertwined with a quirky cast of misfits that he calls his friends: Elain Benes — a cultured literature major who sees herself as the only “normal” member of the group, George Constanza — an insecure but highly determined and neurotic man whose bold attempts at improvement often end in failure, and Cosmo Kramer — the whimsical and perpetually unemployed neighbour whose bold actions (contrary to Costanza’s) often succeed, but that are then undermined by Kramer’s own poor judgement.

In the final episode of the sixth season Elaine, down on her luck, meets Jacopo “J.” Peterman, the author of the Peterman’s fashion catalogue, where accessories or articles of clothing are marketed with stories of adventure, mystique, and international intrigue. Elaine starts to work on the catalogue, and Peterman becomes a side character in the world of Seinfeld. He is well-travelled, wealthy, and charming, seemingly living proof of the life described in the narratives of the catalogue.

In the episode The Van Buren Boys Elaine is tasked with ghostwriting Peterman’s biography, a task that she expects to be fairly easy because of Peterman’s history of mischief. She anticipates that it will merely be a question of documenting and detailing the his many stories, but is caught off-guard when he instead wants her to write about his ordinary everyday life instead of exotic travels. Elaine quickly realises that Peterman’s normal life is (as for most people) dreadfully dull. Instead Peterman buys the rights to the stories of Kramer’s life — who has a genuinely bizarre and eccentric lifestyle — for a one-time fee of 500 usd.

This duality exists within all of us, although in differing degrees. The two aspects of Kramer and Peterman are two sides of the same coin, the striving for action and authenticity (Peterman) as well as the genuine everyday experimentation and adventurousness itself (Kramer). They are both however true eccentrics.

Peterman is fundamentally a fake — a poser — who tries to appear differently from how he “truly” is. Regardless of if he does it through fictitious takes in the catalogue, buying jfk’s golf clubs or antique cake, or venturing on impromptu journeys to Burma² it is always in the attempt to appear as something other than his “true” self. In this regard he truly is a performative man, in the sense that his life is the performance of the role that he has chosen for himself.

You only know me as you see me, not as I actually am.

⸺ Immanuel Kant

Kramer instead represents the reverse; an ideal form of the eccentric attempting to anchor themselves in the real. Instead of attempting to stand out Kramer tries to act as society wishes that he would act. His “job” at Brant-Leland Investments, something that appears to us as absurd, is absurd precisely in its dichotomy with the “ordinary” working life of the audience.

Thus Kramer and Peterman are equally troubled beings wrestling with the social expectations of the eccentric as being both the troublesome madman and the hopeless romantic of life. What they have in common is their unwavering confidence in themselves,³ in that whatever project they assume it will only be seen through by their own will and hope.

I’m out there, Jerry. And I’m loving every minute of it!

⸺ Cosmo Kramer

What is one to choose then? Am I a Kramer of a Peterman? A narcissist would never confess to being a narcissist⁴ and in a similar vein a true Kramer would never want to be seen as a Kramer, and a Peterman would never want to be seen as a Peterman. Both are, despite their similar surface-level behaviour, attempting to imitate the life of the other. This is of course most clearly seen in Peterman buying Kramer’s stories, but an example of the reverse is Kramer’s attempt to market his perfume The Beach to an executive at Calvin Klein⁵ — he wishes to advance to story teller and not merely the mystic who lives for his own sake.

Choosing the reverse from what wishes to be is no better, as it plays into the performative play forced upon the Kramer/Peterman. Instead we must accept two facts: (i) that Kramer and Peterman are not two separate state of being but instead one holistic idea — id est the replacement of “Kramer/Peterman” with Kramer+Peterman⁶ — as well as (ii) that this is inherently an unstable phenomenon. By this instability is meant not that Kramer+Peterman will inevitably collapse, but instead merely that it is in movement relative to both itself and the world.

The consequences of these two statements are tremendous for the life of the eccentric. It means that the goal of the eccentric is constantly moving and that a Kramer+Peterman must constantly move with it. There is no possibility to “rest on one’s laurels” and simply live with the reputation of once having been eccentric. It is a constant spirit that one must involve oneself with, even at the expense of temporary comfort. But that the Kramer+Peterman dichotomy is moving relative to itself is also meaningful, as it means that simply “picking” either Kramer or Peterman is a fruitless task (for reason we have already established). One is by necessity both elements of Kramer+Peterman, and each element takes turns (although not necessarily equal turns) in being the dominant factor in the pair. The other is still present and merely dormant — ready to take over when the opportunity arrives.

What then decides the degree to which either Kramer or Peterman is dominant? It is most assuredly the degree of self-awareness that is possessed in the moment.⁷ The Kramer is dominant when the lack of self-awareness of appears, when the eccentric is simply acting out of instinct for what they deem required. Peterman is the opposite, being an insecurity over one’s lack of eccentricity and whimsy, and thus corresponding to the conscious effort of standing out. The two must not always be in a strict hierarchical order, but can fluidly exist in different ratios between one another; they may even be of equal share.

We can therefore conclude that the Kramer-Peterman dichotomy is not really a dichotomy, but a duality where neither side can truly exist without the other. The hipster or eccentric, filled with whimsy is therefore always insecure in some regard, but brave enough to see their vision through; the master in Hegel’s master & slave dialectic. ❦

One of the first use-cases I found for llms back when Chatgpt first released was automating the creation of citations, or rather the transformations of citations structured in one way into .bib-files that can be used to create a wide variety of uniform citations in \(\LaTeX\) documents. llms are fantastic for this sort of work, where some sort of messily structured data needs to be transformed into some other form that is then useful. As llms become cheaper and cheaper it becomes easier and easier to make data become useful. The benefits of this is obvious to the point of it being the main strength of what is perhaps the world’s oldest continuously developed software project; gnu Emacs.

Much of software engineering is piping that transforms data from one form to another, where we can then process it, ingest it, or present it in some interesting and beneficial way. This is true regardless of the underlying nature of that data. In Emacs there are primarily two forms of this data: lisp code and text. Ardent lisp wizards will object on the basis that one of the core strengths of lisp is that it does not discriminate between lisp as a program qua list of instructions and lisp as a data structure due to its simple syntax.¹ The classic unix environment also made use of this compatibility made possible by a common language of text.

Emacs is a lisp interpreter that comes with a text editor and tools to evaluate elisp code written in said editor. This simple basis allows Emacs to very quickly and easily be extended. While other programs (and even text editors specifically) may offer theoretically similar capabilities² through scripting languages and apis they do not offer the truly free experience that only a few Emacs-like programs build their experience upon. Most code written in Emacs is not packaged or distributed anywhere, but is made up of small and opinionated changes and functions that are likely not maintained in any way. This means that each Emacs user’s computing experience is personally tailored to his or hers own preferences.

The second of the four freedoms (freedom #1) of free software is the “the freedom to study how the program works, and change it to make it do what you wish”. In practice this only means access to the source code under a free-software license. But Emacs takes this much further; instead of a merely “negative” freedom (freedom from proprietary restrictions) it adopts a positive approach, where the user is directly given the tools and documentation³ to change each and every part of the Emacs source code.

Emacs, unix, and modern llms all make use of the unique strengths of text. Emacs however goes much further in this regard than the standard unix system, and in many regards can be seen as an extension and intensification of it. Tietze pointed out recently how the textual representations of almost all data in Emacs is “completes computing” through the universality of text and primarily the text buffer.

If the costs of creating software goes to zero due to continuing advancements in llms it would bring this quality that Emacs has to all software. The restrictions of proprietary software has always been an invention by monopolistic software companies wishing to add a shackle on what is really just a bunch of abstract logical statements. That this has been maintained is impressive, but it can not do so under the onslaught of code produced by llms.

Trivially creating quick and simple programs that serve the user is Emacs’ greatest strength, and it is something that will be accessible to everyone, no matter their experience in software creation. One will be able to make small little applications that serve yourself, and because of its low cost will naturally freely share them with friends, colleagues, and family members. It is, to repeat a often-used sentiment of mine, a revolution in the field of software development — a dramatic return to the older state of affairs, albeit now aided by the lessons of the time in between. In this case it is a return to the times before “free software”, when specifying that a given software was free to use, share, and modify was not necessary but expected and normal.

To reiterate, vibe coding and llms have two great strengths:

1. Easily creating, recreating, and modifying small programs that do not need to be maintained and are tailored for the user’s needs.
2. Formatting roughly structured data into ways that fit the user’s needs, or writing small scripts that do so.

The consequence of these two strengths is a renaissance of free software development where the user become free to construct their computing environment however they see fit. “Emacs is a great operating system, if only it came with a decent text editor” goes the famous quip; Emacs is of course not a operating system in the strict sense,⁴ but it does allow for the almost complete reshaping of one’s interactions with a computer — being able to replace most other use-facing applications. llms extend this freedom to outside the frame of Emacs and into almost every part of the software stack. ❦

Pluribus — the newest show by Vince Gilligan (of Breaking Bad fame) — is a show that is refreshingly new in its ideas. After finishing it I discussed its themes with some of my friends and acquaintances, almost all of whom had quickly connected the show with artificial intelligence (ai). But for me, continuing on an earlier thought that ai is not extraordinary, it was much more obvious that Pluribus is about “the internet” more-so than ai.

The obvious reason that one might connect the “joining” in episode one with ai is that it leads very quickly¹ to what in practice becomes a sort of post-scarcity economy, at least for those 13 individuals who remain. But importantly this takeover is not a result of rapid gains in intelligence, but instead in communication. That each individual appears much smarter is a consequence of at all times having 7.1 billion people, some of whom are experts on the relevant topic, as instantly available sources. The large systems of coöperation and organisation that are displayed throughout the show² could not be done by mere intelligence alone, but instead it requires fast and seamless communication and delegation of needs and tasks respectively.

The technology that humanity has created for this task is commonly referred to as “the internet”, although it is not a single cohesive thing. The increasing connectivity of the internet means that more and more things can be utilised by this collective whole — every computer can in theory connect to every other computer. And because each individual today usually possesses a device capable of connecting to the internet (at least in the developed world) we can in turn communicate our wishes and opinions to (theoretically) every other internet-connected person in the world.

Throughout the first season (but in the following cases in the second episode) they³ will often cite the opinions of individual members of the collective, such as the bottling-plant worker who bottled a specific bottle of water, or of medical doctors throughout the world. That this is the case makes me think that the thoughts of the individual (as in activity in the mind) are still present, it is simply the case that the information transfer is so enormous that a chain of reasoning can be diverted and spread across the minds of all the people of mankind. What is individuality if all your thoughts and memories can be moved to another body?

While the degree to which this happens in Pluribus is of course impossible as of this time it is still occurring at a smaller scale today. When we share our opinions, and critically read those of others, we slowly construct a homogeneous state where all opinions and thoughts are the same and that serves as some kind of collective hive-mind. The widespread idea of “filter bubbles” is many ways false, we are much more filtered through our physical surroundings than our digital ones.⁴

They continually insist on the greatness of the joined experience, and on how each member of mankind saw it as a wonderful thing — just as we ourselves insist on how wonderful it is to be a part of digital society.

And in fact it is hard to argue with the benefits. As Koumba points out,

As we speak no-one is being robbed or murdered. No one is in prison. The colour of one’s skin, by all accounts, now meaningless. All zoos are empty. All dogs are off their chains. Peace on Earth!

This is in all regards an improvement in the state of things. It is in fact the idealised state of, dare I say it, most of mankind. What is the point in undoing the joining, as is the goal of Carol and Manousos, when continuing in the same trajectory inevitably leads to the same outcome? But Carol’s response to Koumba — “What has been lost?” — is equally valid, for it is clear that there is something in the human experience that is missing, both for the individuals and for the collective.

Hannah Arendt, in her book The Human Condition divides human activity into three different forms:

1. Labour
2. Work
3. Action

These three activities all have their own corresponding sphere — the private, the social, and the political respectively. What the joining destroys is both the social and political realms, and with them the two higher forms of human activity, work and political action. The Earth is left with only 14 distinct individuals, only one of which is really relevant for any economic activity. Thus there is no requirement for social interaction for any sort of production; when they leave Albuquerque Carol is perfectly able to go about her life, but she is left entirely alone — not even able to shift her life into the digital as the world did in 2020.

One of the most impactful scenes for me was strangely the almost silent scene when Zosia removes a body from a crashed car, helping place it in a truck before continuing on. It struck me in its simplicity — there is no genuine activity left, only cleaning up the entropy of the universe.

Performing work — in order to create a work — becomes useless once this final position has been reached; there will always be someone who is better and irregardless the extreme division of labour means that all work becomes eliminated, leaving the individual as a mere unit of labour power. This leads to Marx’ (and that Arendt adopts) description of the worker as alienated from their labour, incapable of seeing the whole production of an object through and only relevant in the production of a small part.

When the social and political disappears we are left alone. Alienated no just from or labour but also from each other. The individuals in Pluribus are separated from the rest of humanity, who all have one single shared experience that they can not communicate with Carol and the others. The only way to understand them is to join them, to become a part of this information flow and learn. But in doing so one naturally loses one’s identity and individuality, because the act of understanding the other necessarily brings you closer to them⁵ — just as how the internet makes you closer to some form of a global digital culture.

Is there a solution to all this? That is the question that is posed by Pluribus; What do we do when there is nothing more to be done as individuals? Does our individuality have any innate meaning and worth giving up social connections for, or should we trade it for the material rewards that come with social organisation? The answer may simply be that individuality was always meaningless — as they argue — and vastly eclipsed by the satisfaction of universal understanding. ❦

My girlfriend recently bought a Framework 12 laptop¹ with a correspoding stylus and, influenced by my ravings about the power of gnu Emacs, wants to take handwritten digital notes on it for her engineering and mathematics classes and then organise them in org-mode. I see an earlier version of myself clearly in her, and of course want to help her attain the vision she has for her own Emacs system. At the same time I am a strong believer in that you should not try and learn Emacs, but that it should be molded to your own personal desires. For that reason I try to act in merely an advisory capacity, while helping whenever she asks.

At first we discovered an old package named org-xournalpp that seems to fit perfectly. It creates xournal++-specific links that opens the corresponding xournal file whenever clicked, and they are rendered like inline images in the org-mode buffer. We had some trouble getting Emacs to load the file after installing with the new built-in :vc keyword for use-package (it worked fine on my machine, but not hers) but after installing it the inline previews would not be displayed. Worse yet, running the included org-xournalpp-mode (that tries to render the images) would cause Emacs to freeze.

But how hard can it be to implement your own version of this functionality? Org-mode already has the ability to display inline images (as I am well familiar with) and xournal++ can export to both .png and .svg formats. For this we wrote a small function that uses xournalpp to export a given file to png format and then inserts a link to it in the buffer.

(defun create-png-xournal-file (&optional only-export)
  "Creates a png from a xournal file and inserts it into the buffer."
    (interactive "P")
    (let ((file-name (expand-file-name
                      (file-name-sans-extension
                       (read-file-name ".xopp file to convert: ")))))
      (shell-command (format "xournalpp --create-img=%s.png %s.xopp"
                             file-name file-name))
      (unless only-export
       (kill-new (concat "[[" file-name ".png" "]]"))
       (yank)
       (org-display-inline-images))
      (org-redisplay-inline-images)))

  (bind-key "C-ö" 'create-png-xournal-file)

If org-startup-with-inline-images is t this is then immediately rendered as an image in the buffer. If called with a prefix argument (usually C-u) this skips the insertion part and calls org-redisplay-inline-images to get an updated version.

The experience of imagining functionality that you wish was possible and in an afternoon creating a program (even one as small as a single 11-loc function) that fulfills your requirements is something that you rarely get outside of Emacs. Even in other free software, few programs open themselves so fully to introspection and modification. Something as simple as the *scratch*-buffer, with its use as a quasi-persistent repl, invites creative solutions and problem solving — not to mention the self-documenting capabilities of C-h and docstrings.

While I am not one of those users insistent on reducing the number of packages installed², there is a certain perspective that you should be emphasised; You can easily make do with home-grown functionality that builds on packages you already have installed, or the rich functionality that already comes with Emacs. ❦

I have a few different computers. Those machines have different capabilities, form factors, portability, hardware, and software — and yet I still want to do roughly the same work on them. While most of the work I do is with text — reading, writing, editing, programming — Sometimes I want to work on one specific machine because I might need a dedicated graphics card or I need the machine to fit in my pocket. The solution to this is to have work sync automatically between my machines.

This is not a unique problem to have — some common solutions include Microsoft Windows’ Active directory or doing all your work through cloud-based offerings like Google’s Drive or Microsoft’s Sharepoint. There are however a few issues with these solutions. They are almost by definition insecure since they entail sending my data to a third party’s computer¹. Services like Proton drive or Koofr at least do the bare minimum of encrypting your files so that only you can access them, but they still keep you reliant on someone else’s infrastructure, and you have to be able to connect to their services in order to access your data.

A better workflow would be (to be able) to work entirely offline and then sync those changes semi-periodically when I am online again. I do not want to have to think about if a machine is connected to the internet or what work I have done on it earlier (or not done). I simply want to pick up (or sit down at) a computer and keep going with whatever I was doing before — all without relying on a centralized host. This of course requires all machines to have their own copy of the data, and for those machines to sync changes to that data between themselves.

This syncing functionality can be offered through a lot of different services or systems. I personally use Syncthing for this, but you could just as well use rsync paired with cron jobs to sync your files securely over ssh. Syncthing is cross platform (so I can use it on android, gnu/Linux, and theoretically Microsoft Windows) and doesn’t rely on port forwarding (and so it doesn’t matter what network I am connected to).

If you want to use rsync and sync to your phone I would probably use something like tailscale paired with termux to run your cron jobs. That way you get a single ip address to hardcode into your rsync scripts and you can move across networks and use your phone’s cellular connection. I actually use tailscale myself (even though it is not free software) to speed up discovery between devices.

Tailscale also allows me to ssh quickly between machines to transfer files that aren’t in my general work-related folders. This is usually stuff that allows me to perform my work (like dotfiles or other configuration). It pairs wonderfully with gnu Emacs’ tramp since machines ssh-ing over tailscale don’t need any further authentication (they are authenticated through the tailnet) and it also means I don’t have to expose port 22 to the open internet.

I have five different machines that each keep a complete copy of all of my critical files:

1. Parana. This is my server. It does not hold any centralised role in my network, but is configured to serve content to the open web and maintain high uptime. Runs Debian stable.
2. Nile. My desktop computer. Like Parana this is located at my home. This is a more high-powered device meant for user-facing interaction. Runs Arch linux.
3. Yukon. A larger, higher performance laptop that acts as a portable workstation when I am away from home for longer periods of time. Runs Debian testing.
4. Danube. A small, durable, and low-power² laptop that I can easily toss into my bag. This is probably one of my most used devices because it has a nice keyboard and long battery life. Runs gnu Guix.
5. Yangtze. My phone. In this context it mostly acts as a music player and a way for me to access my grocery list. Runs lineageos.

One of the biggest advantages to this approach is that not only is the general state of the files kept in sync, but I have five different machines located in different places that all have copies of my data. This means I can maintain the integrity of my data even if I lose my phone (1/5), my laptop is stolen (1/5), or my home burns down when I am away (usually 3/5). I can also wipe my computers — something I do semi-regularly — without worrying about losing anything of importance on them. My desktop and server both have high uptime, so there is always some node on the network that is mirroring changes. Critically I am still able to automatically sync files between my phone and laptop when my home network is offline³.

It is however inevitable that conflicts occur when syncing files between machines that are not always online. Thankfully there is a tried-and-tested program that fits with this offline workflow on a distributed number of machines; git.

Git is very useful not just as a collaborative development tool, but also for singular users. Syncthing has an integrated way of dealing with this by retaining copies of files and renaming them. This is good, but it is still an annoying hassle to deal with. Using git is a lot nicer (partly because I can use magit to resolve problems) but git also allows me to see the history of the edits that I have made. Most of my git repositories are not kept on any external server like github’s or codeberg’s, but instead only exist in this pseudo-lan/vpn that my devices all interact through.

All my machines (yes, even my phone) also posses its own copy of my configuration files for gnu Emacs, and so the way that I interact with my computers is always tailor-made for my preferences and workflows. Because of Emacs I work almost exclusively with files in plaintext (usually formatted using orgdown). Working with plaintext of course makes using git very straightforward, but I still use git for non-plaintext tasks.

Git is harder to use in non-plaintext contexts, but in my experience most binary files do not change often enough to experience many conflicts. That might differ for you however, and you might require some other custom solution.

The end result of this system is that each machine becomes an old-school terminal that interacts with a broader computing system, although one that does not require a centralised server or even a network connection to operate! While all my machines possess complete records of the data and are fully empowered to make arbitrary changes (I am the only user after all) no single computer encompasses the whole of the computing environment. I can always discard one element of the network for another⁴.

This approach not only maintains your own sovereignty over your data, it doesn’t cost anything and also allows you to make use of your preëxisting storage for a continuos backup solution. It doesn’t stop you from accidentally wiping a given file from all of your machines of course, so adding some sort of air-gapped backup is also necessary.

The modern day computer is increasingly less personal. Smartphones today act more like network terminals than real computing platforms (even though they are many times more powerful than old supercomputers). Building a decentralized system in this fashion is one way of maintaining a computer that is still intimately personal while still offering the advantages of network storage and automatic backups. It allows you to make your own choice about what software to use and how to use that software, and is therefore free in the true essence of free software — and of the enlightenment idea of freedom it is based on. ❦

I have recently read not just one, but two different blog posts arguing for roughly the same thing. To summarise them; You have a finite amount of time to learn new things, and so you should not only focus that time toward learning things that actually matter, but you should also only try and learn things that are easy to learn. I fundamentally disagree with both of these two things, but think they are prevalent in “productivity” sphere, especially in those targeting people at the intersection between policy and technology, where I happen to find myself right now.

Programming languages (and their users) are often grouped into two main intellectual schools of thought: Object-oriented programming (oop) and functional programming. These two schools both claim to offer ways to manage the increasing complexity that comes with the development of larger and larger programs. Functional programming states that this complexity can be managed by following these principles:

1. Functions are first-class citizens.
2. Functions are deterministic.
3. Functions should not have side effects.
4. Data is immutable.

Not all of these are directly applicable to non-programming concepts, but twisting them somewhat gives us an interesting perspective on how do deal with complexity and chaos in our lives.