I have been using GNU Emacs for about three years now. I initially began using it after completing a semester of introductory programming classes exclusively in GNU Nano, with a series of shell scripts to compile and run C# code, and to set up a trio of terminals; one for code editing, one for compilation, and one to actually run the CLI program I was writing. I had practically created my own little system for terminal multiplexing. This might sound like hell, and in hindsight it was. I was not even aware of some of the abilities of nano to perform syntax highlighting, display line numbers, indent lines et cetera. I merely needed something quickly to write text in, and was horrified at my classmates who had to sit idly and wait for visual studio to start or restart after crashing, it did not help that visual studio was not even available in platform of my choice. In the beginning I only needed to write short programs, simple loops, input and output and the like, and so the simplicity of nano was not in any way a burden — in some ways it was even a boon due to its quick startup time and lack of clunky UI. But eventually I found it annoying having to create and resize my layout of terminals and writing long commands to get Microsoft’s Windows-centric tooling to compile on Linux became a chore. So I created little scripts to optimize my workflow. Nothing incredibly complex mind you, just little fixes here and there. When what is called “fall break” in Sweden came around I decided to ditch Nano entirely. I had friends who used Vim, but being a staunch hipster I decided I couldn’t copy them, at least not without trying the alternatives.

And so I started out with GNU Emacs. The approach of an environment I could extend in-situ, rather than having to deal with a multitude of different tools obviously appealed to me greatly, having done so earlier using shell scripts. I completed my assignments much faster than I was expected to, and used the extra time in class to read An Introduction to Programming in Emacs Lisp from within Emacs, making me more and more inclined to extend and shape Emacs to my own needs. Eventually I found out about org-mode and started to use it for very simple notes, quickly jotting down grocery list and project outlines. The big threshold came when I discovered the in-built functionality for \(\LaTeX\) exports. I had some early encounters with latex, but most of my knowledge was limited to what it was conceptually and how to write \frac{}{}. However, the default article class that is used when exporting from org-mode looks very nice, at least compared to what I was writing in LibreOffice or Google Docs. It is of course possible to get a similar quality in output from a WYSIWYG¹ editor, but the amount of time you’d have to put in to do so is much larger than simply writing the text in org-mode and pressing C-c C-e l p. This of course does not have any impact on the quality of output, but as a fan of typography I like to think that a nicely formatted document enhances ones Aristotelian ethos, in that your credibility as a writer is improved in the eyes of the reader. Emacs therefore became relevant in not just my programming classes and microcomputer classes, but also all classes that involved some sort of essay or technical writing — Swedish, English, religious studies, history, engineering, and management. But there were two main subject that took up a considerable portion of my time where I had to put my cohesive Emacs workflow aside and resort to traditional techniques: physics and mathematics.

For taking notes I started out with a simple notes.org file, separating subject and topics organically with headers. I would recommend other to do the same. Initially, simply writing things down is the goal, and any optimisations will likely result in a net loss. I was inspired by Gilles Castel’s next-to famous series of blog posts on his note taking in LaTeX and vim, particularly his emphasis on “no delay [being] acceptable”. Of course, there are significant deviations in mine and Castel’s approaches and, to be perfectly honest, I think his notes are of a far superior quality. The primary difference is in medium; while the mathematics are written in latex, I prefer to write prose in the much lighter syntax of org mode or markdown, no \emph for me. Instead, I use org-latex-preview and org-fragtog to display latex inline and use the org documents themselves as notes instead of exporting them to PDF. Here is an example of a quick step-by-step way to solve first order differential equations using the integrating factor:

While Karthink has shown that you absolutely do not need to rely on writing snippets as Castel does, I still take that approach. Karthink relies heavily on auctex, an amazing suite for writing latex in Emacs, but most auctex functionality can not be used directly in org-mode. cdlatex, by the same author as org-mode, is however very useful through the org-cdlatex-mode minor mode. It allows for auto-completion of commonly written things like \(^{\text{super}}\) / \(_{\text{sub}} \text{-scripts}\) and Greek letters. It also creates a “just press tab whenever you want to continue writing” workflow that will move point in or out of delimiters and complete symbols. This combined with a liberal set of custom expanding templates using yasnippet creates a fast and coherent system since yasnippet also uses TAB as a key by default, meaning that you can spam it throughout writing, only thinking about the math conceptually as you’re listening to the lecturer.

But Emacs is not limited to writing mathematics merely in a documentary fashion, but also in a practical one. While theoretical mathematics operate on the syntax of math itself (algebraically), physics is often times interested in the actual values of the operations. For this I often quickly wrote mathematics in polish notation directly, also known as Emacs lisp. I find algebra difficult in polish notation, and so I usually do it in latex first, only performing the last numerical calculation in lisp.

This is what I would call the “killer app” of org-mode compared to other note taking applications like obsidian or pure \(\TeX\) files. Being able to instantly tap into a programming language is really powerful, but it also feels very powerful, even when doing trivial things. Quickly being able to jot down numerical calculations (and having them written down for future reference) is quite useful. While I am sure one can write notes in Jupyter notebooks and other computational documents I have yet to hear of someone do this². Emacs’ configurability means that one can easily adapt it to one’s own needs rather than either writing your own incomplete tooling or learning someone else’s workflow.

After high school I have taken a break from the hard sciences and studied a few different subjects at Stockholm University and the Swedish Defence University. What strikes me as fundamentally different is that while mathematics builds on itself very clearly, where you directly use earlier knowledge to explore new topics, the social realm is a lot more “flat”. One can jump directly into Foucault’s postmodernism or Hegel’s Phenomenology and, while of course missing valuable context, still enjoy a degree of understanding. Comparatively it is quite difficult to get any sort of a grasp for quantum chromodynamics without firm knowledge of the structure of the atom. I also felt that studying depended much more on obtaining a breadth of ideas and perspectives rather than sitting down and mastering whatever new topic the lecture had covered. This then called for a radically different approach.

I ditched my former monolithic “one large file” approach and instead, somewhat reluctantly I admit, began using Org roam. I was critical toward the preaching I observed being done by users of various Zettelkästen systems and felt like the idea of a “second brain” encompassing all your knowledge were useless. Having used the system for almost a year now I still feel the same way. It is quite useful to be able to link ideas, since broad concepts and actors often show up in multiple areas³.

I also took inspiration from Gregory Stein to create an org-mode bibliography that combines notes of books and articles with their respective bibtex entries. Here I am back to the monolithic file approach, with each book or article read merely separated into different broad categories⁴. I have quite a backlog of saved .pdf files that I would like to convert to this new bibliography, but I do not have the time to do it all manually. To start I instead just asked an LLM to convert my hand-written citations for coursework into bibtex entries and sorted them into the file. I will let it grow organically from there.

Academia is in the end a forum for the exchange of new ideas, and the most efficient mode for the spread of ideas is text. While we may see some change in the structure of academic writing, particularly for those less experienced, as a result of large-scale LLM usage I doubt that text will be dethroned as the primary mode of communication for human society, but this is really a subject too deep to cover in a text about using Emacs as a student. For the time being writing reports and essays is still relevant to one’s daily life. I of course do this in org-mode, simply adding some latex headers to the document when I am done:

title: The Meiji Restoration and Modernisation of Japan
subtitle: IR1.1 Seminar 1 Preparatory Assignment
author: Joar von Arndt
options: toc:nil
latex_header: \usepackage[a4paper, top=2in, bottom=2in, left=1.7in, right=1.7in]{geometry}
latex_header: \usepackage[activate={true,nocompatibility},final,tracking=true,kerning=true,spacing=true,factor=1100,stretch=10,shrink=10]{microtype}
latex_header: \usepackage[T1]{fontenc}
latex_header: \usepackage{lmodern}

For longer assignments I usually use a two-column layout. I tweak the values for the margins when I am done writing and ready to submit or print so that the text nicely fits the page, since I think it looks more “complete” and planned out that way. Otherwise I just write plainly in org-mode, using footnotes for citations.

Emacs is a tremendously useful tool, and I hope that this either serves as a motivation for beginning to use Emacs (showing of what can be done in it) or to inspire someone else to take inspiration in their own daily activities. I was prompted to writing this by Daniel Pinkston’s talk at EmacsConf 2024, and saw an earlier version of myself in him. I particularly want to emphasize that one approach does not fit all, not even when it comes to personal preference. Some lifestyles/subjects require different techniques, and so you should both experiment and iterate continuously to see what works for you. This is in-line with the Emacs philosophy of complete and instant extensibility, and so I therefore could not imagine a better platform to be writing or taking notes in.

The website is written in Emacs and in org mode, because I find the markup to be intuitive, natural, and easy¹. I generally took a lot of inspiration from others using the same tooling as me, as well as from Gwern, Maggie Appleton and various other blogs and homepages I have read over the years. The colour scheme is a slightly adapted version of Protesilaos Stavrou’s modus themes and the paradise theme. I find them visually pleasing, and they are apparently very accessible to those with impaired vision. I use have used them in Emacs for a long time, and so they fit nicely visually on my desktop when editing content.

The primary font used is Vollkorn, but as a fallback font I also use the legendary Computer Modern, the default typeface used in TeX. Code (Such as the TeX you just read) uses Protesilaos’ Iosevka Comfy font. On my personal machines I use the amazing Cartograph, but I can not afford to use it on the website. The titles are typeset in Zedou, inspired by the French colonial administration in Madagascar.

The blog is genereted using org-static-blog. I have an elisp file that runs the necessary configuration code and acts like a declarative configuration for the deployment of the static site. It looks like this:

  (require 'org-static-blog)

  (setq org-static-blog-publish-title "Joar von Arndt")
  (setq org-static-blog-publish-url "https://joarvarndt.se/")
  (setq org-static-blog-publish-directory "~/Documents/blog")
  (setq org-static-blog-posts-directory "~/Documents/blog/posts/")
  (setq org-static-blog-drafts-directory "~/Documents/blog/drafts/")
  (setq org-static-blog-enable-tags t)
  (setq org-static-blog-enable-og-tags t)
  (setq org-static-blog-image "https://joarvarndt.se/vonArndtCrestWhite.png")
  (setq org-export-with-toc nil)
  (setq org-export-with-section-numbers nil)
  (setq org-static-blog-index-length 1)
  (setq org-static-blog-use-preview nil)

  (setq org-static-blog-page-header
        "<meta name=\"Joar von Arndt\" content=\"Joar von Arndt\">
      <meta name=\"referrer\" content=\"no-referrer\">
      <meta name=\"viewport\" content=\"initial-scale=1,width=device-width,minimum-scale=1\">
      <link rel=\"stylesheet\" type=\"text/css\" href=\"https://cdn.jsdelivr.net/gh/bitmaks/cm-web-fonts@latest/fonts.css\">
      <script src=\"https://tinylytics.app/embed/xzJ638St84zSVeyVpBxf.js\" defer></script>
      <link href=\"static/style.css\" rel=\"stylesheet\" type=\"text/css\" />
      <link rel=\"icon\" href=\"static/favicon.ico\">
      <link rel=\"me\" href=\"https://github.com/JanJoar\" />
      <script src=\"https://ajax.googleapis.com/ajax/libs/jquery/3.5.1/jquery.min.js\"></script>
      <script src=\"static/sidenotes.js\"></script>
      <script id=\"MathJax-script\" async src=\"https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js\"></script>")


  (setq org-static-blog-page-preamble "<div class=\"header\">
            <a href=\"https://joarvarndt.se/\"><img id=\"themeImageHeader\" src=\"vonArndtCrestBlack.png\" class=\"header-img\" alt=\"Crest\" width=\"50\"></a>
          </div>")

  (setq org-static-blog-page-postamble
        "<div id=\"archive\">
            <a href=\"https://joarvarndt.se/archive.html\">Other posts</a><script src=\"static/theme.js\" defer></script>
          </div>")

  (setq org-static-blog-index-front-matter "<a href=\"https://joarvarndt.se/archive.html\"><h2>All Posts</h2></a>")

  (setq org-static-blog-enable-tag-rss t)

  ;; For syntax highlighting of code (Like this).
  (setq org-src-fontify-natively t)
  (setq org-html-htmlize-output-type 'css)
  (setq org-src-preserve-indentation t)

  (setq org-image-actual-width nil)

This loads the required javascript² and CSS for themeing, both of which you should have received if you’re reading this. I am a big fan of org-static-blog due to it’s simplicity³, extensibility (its just a simple HTML static site) and obvious org-mode support. I used to use Hugo, a widely praised static website generator, but it only has nominal org-mode support, it requires a special non-org-mode YAML frontmatter that I really dislike. When writing a post, I prefer to leave formatting mostly out of it, and with my main focus on text. Tinkering with the website’s appearance is great fun of course, but I like to keep the two as separate activities. Writing any sort of special syntax brings me out of the experience, and that is partly why I wrote my own javascript to create sidenotes out of basic pandoc (and therefore org-mode) style footnotes.

The website is hosted on my own server at home, on an Intel NUC machine. It runs Debian GNU/Linux and serves the website primarily through an NGINX web server, but the Diplomacy page is served through a gunicorn server that displays a python application so that users can input data that is then saved. My internet connection is quite spotty (not only do I not have fiber, by building isn’t hooked up at all) and so there might be intermittent outages or slow load times. I do try and maintain at least 99% uptime however. I use loopia as my domain registrar, primarily due to having been recommended them from people I trust, however I have made no significant research into alternatives myself.

After writing the posts I used to manually use sftp to remotely connect to the server from my desktop, laptop, or phone (through Termux) and upload my files but this became quite tedious to do, so I wrote a quick script in elisp that does all this for me:

;;; blogPublish.el --- Summary:

;;; Uploads the contents of the blog folder to the required one on the server.

;;; Commentary:
;;; Probably not the most elegant nor beautiful solution, but it seems to work for me.
;;; The HTML files on the remote server are first deleted through tramp, and then
;;; the content is reuploaded in case there are any changes.  Since plain text is so
;;; quick to upload there is no issue with reuploading unaltered content. 

;;; Code:

(require 'org-static-blog)

(defun blog-delete-remote-html ()
  "Deletes all html files on the server."
  (let ((tramp-default-method "ssh")
        (remote-directory "/ssh:jovo@100.119.139.3:/var/www/html/blog/"))
    (with-current-buffer (find-file-noselect remote-directory)
      (let ((default-directory remote-directory))
        ;; Ensure the remote directory is accessible and its contents are loaded
        (revert-buffer)

        (dolist (file (directory-files default-directory t "\\.html$"))
          (when (file-exists-p file)
            (message "Deleting %s ..." file)
            (delete-file file)
            (message "Deleted all .html files in %s" remote-directory)))))))

(defun upload-blog-contents ()
  "Uploads the required HTML to the blog via SFTP for async."
  (let* ((local-dir "/home/jovo/Documents/blog/")
         (remote-dir "/var/www/html/blog/")
         (remote-host "100.119.139.3")
         (remote-user "jovo")
         (sftp-command (concat "echo \"put " local-dir "/* " remote-dir "\" " "| sftp " remote-user "@" remote-host)))
    (async-shell-command sftp-command (get-buffer-create "Blog upload"))))

(defun website-publish ()
  "Function running after org-static-blog-publish to publish to the website."
  (interactive)
  (blog-delete-remote-html)
  (upload-blog-contents))

(advice-add #'org-static-blog-publish :after #'website-publish)

;;; blogPublish.el ends here.

The function is triggered using advice-add after org-static-blog-publish so as to fit seamlessly into my preëxisting workflow. It removes old HTML content from the website using TRAMP, and then uploads it using sftp. TRAMP is of course also capable of uploading the files, but it is quite slow compared to async sftp. Deleting files however takes a comparatively short amount of time. Authentication is handled by tailscale SSH, so I don’t have to expose port 22 to the public internet and don’t have to enter any passwords for upload.