Here is another. ESS has a pretty weird default behavior that I am kind of ashamed of. Its name is “fancy comments”. First, it explains why all of my R code is commented with two hashes. Here is the excerpt from the ESS manual.

Comments are also handled specially by ESS, using an idea borrowed from the Emacs-Lisp indentation style. By default, comments beginning with ‘###’ are aligned to the beginning of the line. Comments beginning with ‘##’ are aligned to the current level of indentation for the block containing the comment. Finally, comments beginning with ‘#’ are aligned to a column on the right (the 40th column by default, but this value is controlled by the variable comment-column,) or just after the expression on the line containing the comment if it extends beyond the indentation column. You turn off the default behavior by adding the line (setq ess-indent-with-fancy-comments nil) to your .emacs file.

In my opinion, this default is kind of ridiculous. Therefore, if you write a comment with one hash and then press Return, that comment will be aligned to the 40th column by default (or: adding 40 spaces before it). My question is: Who would want that?

Perhaps someone would want that. But I actually don’t. After many years of having this weird default, I should change that. In the manual, it says changing one variable ess-indent-with-fancy-comments would work. The reality is, it does not work. It is not as simple and therefore the manual is incorrect. The usual trick of writing a function to change a variable and attach it to the mode hook isn’t working too. As of writing, this is still an open issue.

The problem is, that variable is actually in the ess-style-alist (association list, more or less like the R list or Python dictionary). Which style to use is defined by the variable ess-style. The default ess-style is RRR. Therefore, one has to modify ess-indent-with-fancy-comments of the RRR key.

(defun dont-like-fancy ()
  "switch off fancy comments in the default RRR ess-style"
(setcdr (assoc 'ess-indent-with-fancy-comments (cdr (assoc 'RRR ess-style-alist))) nil))
(add-hook 'ess-mode-hook 'dont-like-fancy)
(add-hook 'ess-r-mode-hook 'dont-like-fancy)

This method is key of hacky, because according to the ESS manual the style RRR should be fixed. The recommended way is to use the OWN style and then customize ess-own-style-list. Actually, by default it switches off ess-indent-with-fancy-comments. This should be the speedier (and officially sanctioned) way.

(setq ess-style 'OWN)
(setf (cdr (assoc 'ess-indent-with-fancy-comments ess-own-style-list)) nil)

I think from now on, I will write comment with just one hash.

\documentclass{article}
\usepackage[citations]{markdown}

\title{Whatever title}
\begin{document}

\markdownInput{source.md}

\bibliographystyle{apalike}
\bibliography{references.bib}

\end{document}

• Let’s also talk about Emacs and ESS. Earlier this year I updated Emacs to 30.1. And then strangely, opening R files would have a larger left margin. After some investigation, I found that the local variable left-margin-width became 2 for all R buffers. On the official mailing list, I found a person (the original poster) who also had the same problem, but there was no answer. Then, I sent an reply. Finally, the original poster told me the reason for this is that the flymake-model integration might have problem. The solution is to disable ess-flymake integration (setq ess-use-flymake nil). I don’t use flymake anymore, so it doesn’t matter. But yeah, it fixed the issue.
• Let’s also talk about mailing lists. In the R community, mailing lists have a bad name. People would prefer, I don’t know, Bluesky now? Or smaller circles, such as, I don’t know, Discord? Slack? Just talking about the technology. I think mailing lists is the most open because one only needs an e-mail address to join. I think now, the people who are still active on R mailing lists are not hostile but instead quite nice. The signal/noise ratio is extremely high. I don’t need to see other social media content, for example.
• The last thing I would like to talk about is CRAN. I read a blog post by Adafruit, a hardware company. The tldr of that is: Adafruit maintains several Arduino (single-board microcontrollers) open source software packages. In 2024, a new company forked their code and added those code to the Arduino Library Registry. The worst part: That new company removed the original open source license, changed the copyright holder to themselves etc.
  I did fork some code myself too. minty is a fork of some code in readr. Although it is fine to fork open source code, I believe in two things: 1) one still has to respect the original license, and 2) one has to communicate with the original authors to show that forking is done in good faith.
  I can’t help but to think about how Arduino Library Registry and CRAN work. Again, CRAN has a bad name. I criticize it sometimes, e.g. this. It is not difficult to find harsher critique of CRAN regularly on blog aggregator rweekly. A few weeks back there was a highlight article entitled Is CRAN Holding R back? Well, every one is entitled to have an opinion and I don’t want to comment whether CRAN is holding R back. But there is a comparison between the semi-automatic and test-free model of package submission (e.g. PyPI) and the manual and constant testing model of CRAN. But the merits of the CRAN model are not discussed.
  In my opinion, it is not entirely a technological question, but a political one. Diplomatically speaking, all models have trade offs. While it is true that it is difficult to get a package on CRAN and keeping a package on CRAN one has to do more work, you should at least know what the package is tested on CRAN’s fleet of test servers and should be installable on three major OSes. You should also expect that the e-mail address of the maintainer should still be reachable by CRAN, most likely also by you. Supply chain attack, in principle, should be more difficult. This model is perhaps “outdated” because only some very conservative open source repositories would still use this model, e.g. Debian. PyPI is in fact similarly, but without the constant testing part. Software repositories of newer languages just ask for a Github address. Arduino Library Registry is an extreme version in this school of thinking, where the entire thing is just a text file ¹. I don’t have a moral of the story for this one. But I believe I sleep slightly better, when CRAN doesn’t operate like Arduino Library Registry.
• Finally, I am moving my private projects to Codeberg. You should too.

Emacs

My current emacs setup is not far away from the time those “Advent of emacs” were written. However, as I said in the ICA paper post, the post on GhostText and Overleaf is now obsolete because of Overleaf’s removal of the so-called legacy interface (basically an HTML <textarea>, I think). I am now using the web interface mostly, which is not ideal.

Other than that, I am still using more or less the same setup: ess, magit, deft, etc. I am still using the same theme (tron-legacy), although not in summer. For the summer, I used the very boomer beige solarized-theme.

The shell situation

I wrote in aoe5 that I don’t use eshell (shell written in elisp). In 2023, I found an important niche of eshell, that is, to run an interactive R session on a remote server. I found that eshell is the a shell I can ssh to a remote server, run R there, and then run (ess-remote) to make it an interactive R session that I can send R code over. Actually, shell can do that too, perhaps more nicely than eshell. Only vterm can’t do that.

The next item is related to remote editing.

dirvish and a crazy feature of magit

I wrote in aoe5 also that I don’t like to use dired. But for remote session (which I needed to do a lot in some part of 2023), it is actually quite nice to use dired to open a remote directory via tramp, e.g (find-file "/sshx:whatever:~/") and then select files from there to edit locally and save it back to its remote location.

But I still don’t like dired for open up too many buffers. Yes, I know there are many fixes for this. But my choice is just to switch to dirvish and override dired with that, i.e. (dirvish-override-dired-mode 1). I also created a function to open a file with xdg-open and mapped it to, well, you know it, C-q.

(use-package dirvish
  :init
  (defun dired-open ()
    "xdg-open the selected file"
    (interactive)
    (let ((selected-file (dired-get-filename)))
	  (async-shell-command (concat "xdg-open " selected-file))) ;
    )
  :config
  (dirvish-override-dired-mode 1)
  :bind (
		 :map dired-mode-map 
			  ("C-q" . 'dired-open))
  )

As I did quite a lot of remote development, I also discovered a crazy feature of magit. Actually, it is possible to use a local magit session to connect to a remote git repository and do all the git things on the remote repository. Mind blowing.

expand-region

Another useful tool that I discovered recently is expand-region. One thing I need to do quite often is to select some quoted text. There are probably some advanced movement commands that I can use. But I think expand-region’s semantic regions are easier to pull off.

(use-package expand-region
  :bind (("C-'" . er/expand-region)
		 ("C-\"" . er/mark-outside-quotes)))

By press C-' repeatedly, I can select from word, sentence, sentence within quotes, Current S Expression, Parent S Expression, Function definition, and then the entire document. I also created C-" which just directly select sentence within quotes. Very handy.

For me, C-' and C-" are probably the last two shortest key combinations that are still available. And I really like this because I usually need to press this repeatedly. So I can just hold Ctrl and press many '. For R code, it is probably the easiest way to select a function definition (probably just press C-' two times), even I know ess-mark-function exists.

Linux

I am still using Ubuntu Linux 22.04 LTS. The tiling WM situation is that I am still using i3. I don’t need to retire from using tiling WM. i3 is super robust and I don’t see a reason to switch to something else, yet.

Mobile Phone

I did not blog about it, but I bought my iPhone 6S Plus in Oct 2016 ¹. At that time, iPhone 7 was already released but I still got myself an iPhone 6S Plus. I will tell you why.

I have used that iPhone 6S Plus for 7 years. To be honest, I feel that I can probably use it for maybe 1 or 2 years more. But the super robust phone showed its age. Its battery can last for maybe 3 hours without switching on low battery mode and keeping it at the lowest screen brightness. The screen has long been broken due to a 1-meter drop. Both can be fixed by replacing the parts. As of writing Apple still provides security updates for this model; although still in iOS 15 (whilst the latest is iOS 17). I don’t know how long it will still be supported. As I said, I can probably use it for some more years. My wife convinced me that maybe I should change my phone instead.

During my trip back home, I bought an iPhone SE (3rd gen) for a very affordable sum of money. I got the lowest end with only 64G. Why? I just found that I don’t need to use the camera (or cameras) and I use maybe just 7 apps (Duolingo, GMail, Firefox, Signal, Spotify, and Tagesshau) very often. And maybe also authenticators, dictionary, and some Bank apps. For those apps, I don’t need the best CPU/GPU/TPU and a lot of storage; and of course, I don’t need to buy the great and expensive cameras on the mainstream iPhones, even the outdated ones. I don’t mind the screen bezels. I don’t even use my phone to watch videos! Just give me a decent, robust, future-proof phone which I can use for a few years!

There are pros and cons. Pros: It’s a breath of fresh air to revisit the smaller form factor, which is super rare on the market. It’s actually very handy to be able to hold a phone with one hand and use with just one thumb. Other than that, it is effortless to carry and sit nicely in the bottom of my jeans’ pocket. I don’t feel it most of the time. I also love the fact that it is still using Touch ID, not the face recognition thing (I hate that). The phone is very snappy and the battery life is very satisfactory. I charge my phone every two days, a thing unthinkable a few months earlier. The speaker is also significantly louder than my old iPhone 6.

Just one con. Maybe I should tell you why my previous phone was iPhone 6S Plus (not iPhone 7): headphone jack. Now I need to finally confront the 2016-era issue of missing headphone jack. I bought a wired headphone using Lightning (weird and is now obsolete) in Japan. But I still don’t understand why it is a good decision for the consumers to remove headphone jack whilst most wired headphones on market (almost a decade after the removal of headphone jack on most smartphones) are still using the 3.5mm headphone jack. And one can’t listen to music with wired headphone and charging at the same time. I still think that it is only good for the manufacturers. Especially for Apple, which also a manufacturer of wireless headphones, e.g. those Beats headphones and AirPods.

I gave a little demo of my half-baked project “orgdungeon” at emacsconf 2023. It’s lucky that the 5-min demo was prerecorded (video). I was in the middle of my vacation in Asia and due to my time table mess up, I did not make it to the Q&A. I am really sorry for that!

Apparently, there are several questions in the conference etherpad. Thank you very much for the questions. I am going to answer the questions below.

Q & A

Q: Could you please elaborate what’s the background of this game? What’s the motivation why you choose this game as introduction for a newbie to enter the Emacs world?

A: The background of this game is a bit silly. It’s actually my wife wanted to create a (general) video game last year and I told her I can create a puzzle game as well. I have no experience in programming any video game, but I enjoy playing niche video games such as Tetris and TIS-100.

I have tried to create educational material for R programmers to learn emacs, e.g. this and, this. Actually, the game presented so far is covering the same material of the latter tutorial. But I don’t think the written tutorial is as effective as this game.

There are so many introductory emacs tutorials. C-h t, for example, is quite good. If the path to emacs is from 0 to 100, those tutorials are good for going from 0 to maybe 20. It is nice to get the feet wet. I think that the gateway to really enjoy emacs, i.e. beyond 20, is to customize emacs so that emacs becomes your own tool. However, there is a huge perceived knowledge barrier of “learning emacs lisp” and “learning emacs internal”. From my own experience, the trick is stop “learning” (from an educational perspective, one can’t learn something for the sake of learning something.), but to “do.” The best way to immediately do something, is to play a game.

Q: Maybe the Emacs tutorial could be adapted to this game flow?

A: Unfortunately, that would be quite difficult. The Emacs tutorial is more about the basics (cursor movement, buffer management etc). And those bits are quite difficult to demo in the current text adventure format. I think a game format like vim-adventures would be better.

Q: What was something that you learned about Org-Mode/Emacs in working on this tutorial?

A: (eval (car (read-from-string string))).

Q: Thank you for the talk! Really cool project! How many planes are you planning to make and what more will you teach the players?

Q: Do you have an end goal for this game? That is, what information do you want it to cover or will it be never ending?

A: I am going to answer both questions jointly. The plan is to at least allow the users to write a 10-LOC function in emacs lisp.

Q: What is plane? Is that something like a question set in the game?

A: I am not a D&D player. But my wife told me a Plane is one parallel universe. But you are right, one Plane in this game is basically one question set, or one puzzle.

Q: Is it for programmers? Non-programmers? Or general?

A: I really hope that this is for everyone. But given the emacs userbase is like 90% programmers, I don’t mind this game is geared towards the programmer type wanting to “go beyond 20”.

Q: What is the link to your GitHub repository?

A: https://github.com/chainsawriot/orgdungeon

Q: Is (find-file org-file-name) [skip-to-plane] a effective way to load information from your org-files?

A: Probably not. The original idea was to have one giant org file and jump between headlines. But the current approach is easier to implement.

Now, it’s 2023 and I have another job. I think it’s time to give you an update.

First, I abandon trackdown; and it also means I partially abandon RMarkdown. The new kid Quarto actually has the same problem. Collaboratively writing a Markdown file on Google Doc is simply unnatural. And the workflow actually introduces many issues, for example, Google Doc converts all double quotes to some weird shit like Microsoft Word. It is also the worse of both worlds: It does not have preview of how the paper would look like and it does not run any embedded R code. Both tech and non-tech people are unhappy. For one time, I tried to write one Markdown paper collaboratively on HackMD. HedgeMD/HackMD open source politics aside, writing RMarkdown paper on HackMD was significantly better than trackdown because of the HTML preview. But still, HackMD was worse of one world: It won’t run R code.

To many people, writing paper locally and submitting patches via Git and editing a file via pull requests are just unnatural. There is only one super techie and R savvy person (my team lead David Schoch) who can write papers with me this way (we wrote two papers this way so far). I just can’t nudge my other collaborators to write papers this way. My e-mails about “the paper is available on GitHub too” were usually just a not useful sidenote.

There should be a RMarkdown / Quarto collaborative writing environment that supports code execution. But the fact that RMarkdown formats have been available for almost a decade but no one sees this as a business opportunity bothers me. Look at all those Notebook environments!

I talked to my collaborator Nathan Teblunthuis previously about his writing setup. His advice is “always write in \(\LaTeX\).” Although it sounds like the so-called Atwood’s Law, he has his point. It likes the mantra of Choose Boring Technology. Yeah, \(\LaTeX\) is not as flashy and trendy as any new shit. But it has been available since 1984. You know, the year when the perpetual war between Oceania, Eurasia, and Eastasia was still going on and that running lady with a hammer did not smash the Telescreen of the Big Brother.

Of course, another reason is Overleaf. It has been the de facto \(\LaTeX\) environment for many fields, including my neighboring field Political Science. So, I decided to write all my ICA papers this year in pure \(\LaTeX\) on Overleaf with my coauthors. And this decision was also opportunistic because all of my coauthors this time are (I believe) tech-savvy.

Overleaf is fine. Of course it is a freemium service ¹. But it is probably the best of two ordinary worlds. At least it has instant rendering and some form of literate programming. Here are the tricks:

Literate programming on Overleaf

Actually, Overleaf supports literate programming in some way. Of course, I can upload my data files to my Overleaf project. If one wants to use literate programming, the \(\LaTeX\) file needs to be in .Rtex file extension. So, just rename my \(\LaTeX\) files to *.Rtex and Overleaf will allow code execution.

The next question is: How the heck can I embed code in those *.Rtex files? Well, I need to use the Sweave…-inspired knitr notation. Isn’t knitr just for RMarkdown / Quarto? Well, it supports \(\LaTeX\) as well.

Inserting a code chunk and inline R code look like this:

<<test, echo = FALSE >>=
mod <- lm(Sepal.Length~Sepal.Width, data = iris)
@

The regression coefficient is \Sexpr{round(coef(mod)[2], 2)}

For this code, I can just render the project and I will get the result. And complex things like ggplot2 also work. The problem, however, is that I cannot install any R package. I must use the ones preinstalled. I recommend running this to get a list of all preinstalled R packages.

<<listpackages, echo = TRUE >>=
dimnames(installed.packages())[1]
@

Actually, there are many packages. Notably, all tidyverse packages and rio (thank you) are available. Even some which I think are potentially dangerous are available too, e.g. fs, ps, and curl. But unfortunately, some packages I like are not available, e.g. here. The point is to be mindful about the limited set of R packages available. For packages not available, I recommend running the analysis locally, saving the output as RDS. And then upload the RDS files and use the literate programming interface to unpack the output in the \(\LaTeX\) source. I would add the R scripts for generating those RDS files to the project too.

From online to offline

The Overleaf project can be brought offline to my computer via Git (a premium feature). Click on the Main Menu and there are GitHub, Git, and Dropbox integration. The Git option gives you the command to clone the current project offline, something like

git clone https://git.overleaf.com/xxxxxxxxxxx

On my local machine, there would be questions about how to render those files like I did online. Suppose the file is called wonderful.Rtex.

Rscript -e "knitr::knit(\"wonderful.Rtex\", output = \"wonderful.tex\")"

Like Rmarkdown, knitr::knit() executes the code chunks and inline R code and generates a clean \(\LaTeX\) file. And that \(\LaTeX\) file can be render by my favorite \(\LaTeX\) renderer. These days, I am getting lazy and I just use latexmk. I usually write a Makefile like this:

appendix:
	Rscript -e "knitr::knit(\"wonderful.Rtex\", output = \"wonderful.tex\")"
	latexmk online_wonderful.tex -pdf
	rm -f *.out *aux *bbl *blg *log *toc *.ptb *.tod *.fls *.fdb_latexmk *.lof *.fff *.run.xml *.bcf *.ttt
	rm wonderful.tex

Another issue is how to edit those .Rtex files offline. RStudio is just a matter of double click. On emacs, I just need to associate the file extension .Rtex to the poly-noweb+r-mode.

(add-to-list 'auto-mode-alist '("\\.Rtex" . poly-noweb+r-mode))

From offline to online

Actually, the Git integration allows me to edit the files offline and then push my edits back to Overleaf. However, this can be problematic because my collaborators might have edited the files via the web interface. And my edits via Git might overwrite my collaborators’ edits.

So, most of the time I just use the web interface. The emacs keybinding on the Overleaf web interface is a joke, don’t use it. Previously, I wrote about using GhostText with Overleaf and edit the text with emacs. Now, It works unreliably. I really hope that it can work again.

For writing from zero, I usually just write my text offline on emacs and then paste it into the file on Overleaf. For editing existing text, I use the web interface.

Conclusion

Despite all these limitations, it is still a usable literature programming online platform. If Overleaf can serve as a gateway drug to nudge people away from using Microsoft Word / Google Doc and all these US big-tech path-dependency bullshit, and embrace open source and computational reproducibility, it is already a good service. I also like the fact that my files are not locked in the platform. So, I think I will support this little uncomfy service. But, dear Overleaf: Please don’t sell your damn company to an evil conglomerate like Elsevier or Springer Nature. Thank you!

Previous on this blog:

1. On StumpWM, AwesomeWM, and xmonad
2. On Sway(WM)

In the previous post on Sway, I wrote:

An added benefit of Sway is that it is a Wayland compositor (not X11). So far, I am quite happy with Sway. Let’s see how long this happiness can hold.

Okay, exactly a week. And the fact that Sway being a Wayland compositor to me and at this time point is not a benefit. Being pure Wayland now (May 2023) is not a good time point because there are still many applications still run in X. Firefox runs fine in Wayland. My vanilla Gnome Terminal runs fine in Wayland. The problems are Spotify and most importantly, emacs. And yes, there is a emulation layer called XWayland. It runs fine for a short time. But if an XWayland application runs for too long, on my machine it goes like this:

If I am lucky, I can kill it. If I am not lucky, my machine go nuts and reboot randomly. In short, extremely annoying. There are many non-X replacements for Spotify (psst, ncspot etc.). It is not a big issue actually. The main issue is emacs. The upcoming emacs 29 has a pgtk (Pure GTK) branch and a pure GTK emacs is fully Wayland compatible. But I can’t get it run stably on my Ubuntu 22.04 LTS machine, either compiling it from source or using the snap package. The running emacs quits randomly. Again, super annoying.

So, I need to make the switch again. And this time, given the time invested in Sway, I go for its older sister i3, which is still an X-based system. As Sway is a i3-compatible WM, the transition to i3 is almost painless. Basically, the only difference is to change all swaymsg to i3-msg. Also, the management of output devices (monitors) is managed by the very familiar xrandr.

I decided that this is my last choice, at least for this year. If it is problematic like the ones I have tried so far (StumpWM, AwesomeWM, xmonad, Sway), I will not switch to another tiling window manager but go back to the regular GNOME. And actually, maybe something like Pop shell is enough.

After using xmonad for over a month, I know that I don’t know enough Haskell to customize it any further. I at least know some Common Lisp and lua to hack StumpWM and AwesomeWM. All of my xmonad “customizations” so far were stealing things off github or guess work. I can’t comprehend my configuration file. Honestly, I have zero intention to learn Haskell just to configure xmonad. Without any Haskell knowledge, it also means that I don’t understand xmonad at all (the API documentation is not easy to read without any knowledge in Haskell, for example). Overall, I am not 100% happy with xmonad. For example, I can never get things as fundamental as the darn xmobar to work on full screen. Also, there is a weird bug related to right click on Firefox (sometimes, the right click contextual menu disappears automatically; can “refresh” it by changing the xmonad layout). I am pretty sure it is an issue of xmonad, but I don’t know enough Haskell to fix it. See, I am such a bad software user.

So now, what’s next? My choice is Sway. I think it’s better to write it as SwayWM, because searching for “sway” will probably give you Microsoft Sway. But let’s say Sway more to purge Microsoft’s search engine optimization.

This choice was made mainly because of this insightful post by Troels Henriksen. It actually addresses my first requirement of using strange emacs-style key combinations. A quick summary is this: By default, Sway (and its predecessor i3) doesn’t support these emacs-(or Ratpoison-, or GNU Screen-, or Tmux-, or StumpWM-)style key combinations. Similar to AwesomeWM, it uses just one “modifier key” ($mod), usually gets mapped to the Super key. However, Sway has a VI-like modal configuration, which can be defined to do whatever one wants. Mode can be triggered by a two-key combination such as C-t (the default of StumpWM and Ratpoison). In order to make a mode works like StumpWM/Ratpoison, the trick is to do an action and then immediately switch back to the “default” mode. In the default configuration file, there is a defined mode called “resize”, which can be triggered by $mod+r. I can just modify that to make it works for me.

Another requirement is “run-or-raise”. Actually, I’ve come to realize that I actually don’t need to “run-or-raise”. What I need is just “raise” (or in Sway’s lingo: focus), if the program has been started by default. I also find that I only use “run-or-raise” for maybe just 4 things: emacs, firefox, terminal, and Spotify. However, it is still nice if I can have a working implementation of “run-or-raise”. Sway by default doesn’t have native “run-or-raise” support like StumpWM and xmonad. However, as Sway is mainly controlled through messages and there is a shell program called swaymsg to send those messages, I can emulate “run-or-raise”. For example, to “run or raise” Firefox, I can do this: exec swaymsg "[app_id=firefox] focus" || exec firefox. It is just like bash: If sending a message to focus the thing with app_id=firefox fails (i.e. with a non-zero exit code), execute the shell command firefox. Functionally, it is just run-or-raise.

I also like the fact that I can discover what I am doing myself. For example, non-Wayland software doesn’t have an app_id and emacs is one such software. swaymsg -t get_tree can show me all the relevant information as a json file, representing what Sway is seeing. And man 5 sway is easy to read (also available online). I am able to experiment things on my shell, like typing: swaymsg "[instance=emacs] focus". I have a REPL, similar to StumpWM’s swank.

In the end, I hack together a “stumpwm” mode in Sway like this and it works quite well for me:

mode "stumpwm" {
     bindsym Return mode "default"
     bindsym Escape mode "default"
     bindsym g mode "default"
     bindsym Control+g mode "default"
     bindsym c exec $term; mode "default"
     bindsym f fullscreen; mode "default"
     bindsym Shift+c reload; mode "default"
     bindsym bracketright exec rofi -modi drun -show drun; mode "default"
     bindsym n focus left; mode "default"
     bindsym p focus right; mode "default"
     bindsym b exec swaymsg "[app_id=firefox] focus" || exec firefox; mode "default"
     bindsym e exec swaymsg "[instance=emacs] focus" || exec emacsclient -c; mode "default"
}
bindsym Control+period mode "stumpwm"
workspace_layout tabbed

Of course, it is not perfect. Unlike StumpWM or xmonad, typing C-. and then pressing something not defined in the mode still keeps me in the “stumpwm” mode. But one nice thing is that I have some visual clue in the menu bar (thanks god, I have a working menu bar by default!) so that I know I am still in the “stumpwm” mode. I can just quit, by using the emacs panic button C-g (or g or Return or Escape).

An added benefit of Sway is that it is a Wayland compositor (not X11). So far, I am quite happy with Sway. Let’s see how long this happiness can hold.

22,000 words later, now I know: that is like writing two research papers in three weeks. At the same time, I know now that idea is cheap, implementation is king.

The following program produces a thank you note to the emacs community.

(defun danke ()
  (interactive)
  (mapc '(lambda (package)
		   (progn
			 (insert (concat "I thank the emacs community for " package "."))
		   (newline-and-indent)
		 (newline-and-indent)
		 ))
		'("package" "use-package" "magit" "quarto-mode" "rust-mode" "helm"
		  "org" "vterm" "ligature" "prettified-symbols-mode" "key-chord"
		  "info" "yasnippet" "helm-c-yasnippet" "yasnippet-snippets"
		  "tron-legacy-theme" "solo-jazz-theme" "tramp" "proced" "biblio"
		  "markdown-mode" "poly-mode" "helm-bibtex" "atomic-chrome"
		  "flyspell-mode" "ess" "rainbow-delimiters" "flycheck-mode" "eglot"
		  "deft" "elfeed" "mu4e" "nov" "visual-fill-column"
		  "eval-in-repl"))
(newline-and-indent)
(insert "Thank you for reading!"))

I thank the emacs community for package.

I thank the emacs community for use-package.

I thank the emacs community for magit.

I thank the emacs community for quarto-mode.

I thank the emacs community for rust-mode.

I thank the emacs community for helm.

I thank the emacs community for org.

I thank the emacs community for vterm.

I thank the emacs community for ligature.

I thank the emacs community for prettified-symbols-mode.

I thank the emacs community for key-chord.

I thank the emacs community for info.

I thank the emacs community for yasnippet.

I thank the emacs community for helm-c-yasnippet.

I thank the emacs community for yasnippet-snippets.

I thank the emacs community for tron-legacy-theme.

I thank the emacs community for solo-jazz-theme.

I thank the emacs community for tramp.

I thank the emacs community for proced.

I thank the emacs community for biblio.

I thank the emacs community for markdown-mode.

I thank the emacs community for poly-mode.

I thank the emacs community for helm-bibtex.

I thank the emacs community for atomic-chrome.

I thank the emacs community for flyspell-mode.

I thank the emacs community for ess.

I thank the emacs community for rainbow-delimiters.

I thank the emacs community for flycheck-mode.

I thank the emacs community for eglot.

I thank the emacs community for deft.

I thank the emacs community for elfeed.

I thank the emacs community for mu4e.

I thank the emacs community for nov.

I thank the emacs community for visual-fill-column.

I thank the emacs community for eval-in-repl.

Thank you for reading! ^{1 2}

He’s the one, who likes all our pretty songs. And he likes to sing along. And he likes to shoot his gun. But he knows not what it means, knows not what it means

This one is actually pretty difficult to write, because I need to tell you how I feel about emacs. But before I start, I need to stress it again: I am a mediocre researcher at best and an unskilled programmer. As I said, I am an emacs poseur. There are many emacs opinion leaders you can listen to and I am not one of those people. The content of this webpage is not an investment advice and does not constitute any offer or solicitation to offer or recommendation of any investment product. Go away and I wish you a merry Christmas. Pfiatdi!

If you don’t go —well— I am going to say something that is not pleasing to your ears.

First thing you might notice from all 23 previous posts is that my emacs lisp sucks. I don’t write in a way that is idiomatic and there must be “correct” slash “better” ways to achieve what I wanted to do. Sure enough, mea culpa. But I also wanted to say that those hacky emacs lisp snippets work for my purposes. I don’t need to write “correct” or “better” emacs lisp. I just need to write some useful emacs lisp that can facilitate what I do. As I said many times, my main job is doing research and writing academic papers; not even writing R code; and absolutely not writing emacs lisp.

I always like the motto “learning enough x to be dangerous”. I have something that I really want to focus on, say developing the next best automated content analytic method or making social sciences adhere better to the modern concept of open science. But writing “better” emacs lisp is not a thing I want to focus on. I just want to know enough emacs lisp to be dangerous. Or put it less flamboyantly, to know enough emacs lisp so that I can use emacs comfortably. Do I need to know how to write generators, macros, and recursive functions in emacs lisp? It would be nice if I am with all of these tricks. But I can do well enough without. Ignorance is not bliss. But ignorance sometimes helps me to focus.

Unlike many people, I know my attention is finite and there are many things want to steal my attention and time. Being able to focus is the only tool for me to excel at the things I want to be good at. I am in my 40s. In my language context, we say: “my one leg is already in coffin”. I am no longer a budding young person who can make infinite number of commitments to learn everything. I need to make compromises. ¹

Sure, I need some good tools to do my job but I am certainly not a toolsmith. Is writing emacs lisp fun? Of course it is. And therefore it is quite easy to fall into the trap of writing and rewriting one’s emacs configuration file. For me, investing too much time in toolsmithing is actually procrastination (unless I am a professional toolsmith). Good cooks want to have a good Santoku. But what makes good cooks good cooks is not which Santoku they have, certainly not which Santoku they forged themselves ². The same way Yukihiro Matsumoto, Donald Knuth, Rich Hickey, Peter Norvig, Jamie Zawinski are (Guido van Rossum was) emacs users, but they are not known for being emacs users. Even Richard Stallman, the author of GNU emacs, is not known for being an emacs user!

I am a scientist. I don’t say a thing is better because I believe in that thing. I am certainly not a fan boy or something like that. I use emacs because I can get my job done with it. The same way a biologist uses an electron microscope or a physicist uses The Large Hadron Collider. Of course, with many other tools I could also get my job done too. VS Code, Neovim, RStudio, JetBrains, you name it. Again, I don’t believe in things; but I evaluate things. From my evaluation, emacs is the most suitable tool. There must be the factor of path dependency here (I have been using emacs for almost 2 decades.) But I know the most important feature of emacs is the freedom it gives me. For example, no vendor of editors would say pressing C-q repetitively makes any sense. But I have that freedom. Also, not all the tools have the freedom for me to create a minimal interface. emacs provides me that freedom too.

I rarely address to you, my dearest readers. But if you really need my advice on “learning” emacs, my advice is to hack your emacs NOW with the “self-documentation” as your guide —Like I did in the previous 23 posts—, instead of pursuing the hypothetical adventure of “learning emacs (lisp)”. From my experience as an educator, learning a programming language for the sake of learning a programming language destines to futile ³. You won’t need to “learn emacs lisp” to start hacking emacs. You learn enough emacs (lisp) by hacking emacs. No one knows your need. The emacs configuration you hack together may not be “better” in someone else’s opinion, but that’s what suits you.

Before I go, I will talk about the background information for one last time. Mostly about the emacs lisp constructs which I have used but had no chance to explain.

Lists

Lists are often used in customizing emacs. Unlike many lisp books to talk about con cells, car, cdr, recursion or things like that, I just want to tell you two things about lists.

There are actually three types of lists in emacs lisp. But I just want to talk about regular list and alist. A regular list is what one would expect like the list in Python or array in Javascript.

(setq languages '("python" "r" "javascript" "elisp" "C++"))
(nth 2 languages) ;; javascript

Association list (alist) is a list but more like dict (hash table) in Python. It can record key-value pairs

(setq creators '((Python . "Guido van Rossum")
				 (C++ . "Bjarne Stroustrup")
				 (Perl . "Larry Wall")
				 (Ruby . "Yukihiro Matsumoto")))
(assoc 'Ruby creators) ;; give a key-value pair
(cdr (assoc 'Ruby creators)) ;; just "Yukihiro Matsumoto"

alist is being used a lot in configuration. This is an example:

(use-package atomic-chrome
  :config
  (atomic-chrome-start-server)
  (setq atomic-chrome-buffer-open-style 'full)
  (setq atomic-chrome-url-major-mode-alist
		'(("github\\.com" . poly-markdown+r-mode)
		  ("overleaf\\.com" . latex-mode)))
  )

The :bind syntax of use-package also uses an alist.

(use-package ess
  :bind (
	     :map ess-r-mode-map 
			  ("_" . 'ess-insert-assign)
			  ("C-q" . 'ess-eval-region-or-line-and-step)
			  ("C-c C-k" . 'ess-request-a-process)
			  :map inferior-ess-r-mode-map 
			  ("_" . 'ess-insert-assign))
  )

setq and let

I want to make sure you know the difference between setq and let, although you probably know it already. Both of them create variable bindings, whereas setq can also be used to mutate the value of a variable.

First, it is possible to make multiple bindings with one single setq.

(setq x 123 y 100)
(- x y) ;; 23
(setq x 100)
(- x y) ;; 0

let creates some local bindings that are valid only within the body (the local scope; or the block scope, if you prefer the Javascript term). Outside of the body (the closing paren of let), those bindings are not available.

(let ((pi-approx (/ 22 7)))
	(- pi-approx pi)) ;; -0.14 
pi-approx ;; error

Conditionals

There are several ways to do conditional jump. I’ve heard that true lispers use only cond. But I don’t buy it.

if is usually used when one wants to have “if - then - else”. A clause is one S-expression.

(let ((age 41))
	(if (< age 40) ;; predicate
		(message "You are young") ;; then clause
		(message "You are old"))) ;; else clause

when is used when one doesn’t want to have the else clause. The following returns nil.

(let ((age 41))
	(when (< age 40)
	(message "You are young")))

unless is the reverse of when.

(let ((age 41))
(unless (>= age 40)
	(message "You are young")))

True lispers may only use cond. But there are reasons why the above syntactic sugars (if, when, unless) of cond exist.

(let ((age 41))
	(cond ((< age 40) (message "You are young"))
		(t (message "You are old"))))

progn

In other programming languages, blocks are used to run multiple lines of code conditionally. For example, the curly braces in the following Rust program create blocks.

let age = 41;
let compensation =
    if age >= 40 {
        println!("You are old. I'll give you more compensation.");
            age * 20.0
        } else {
            println!("You are young. You don't need that much compensation.");
            age * 0.5
    };
println!("You receive {}€ in compensation.", compensation);

if in emacs lisp takes just one S-expression (sexp) as a clause, not a block. What is one sexp? This is one sexp: (message "hello"). This is also one sexp: (message "%f" (/ 22.0 7)). But here are two sexps: (setq approx-pi (/ 22.0 7)) (message "%f" approx-pi). If you enter it in ielm, the output is an error:

progn is used to create the equivalent of a block by combining multiple sexps into one. There are actually several of this kind of progn functions (progn, progn1, progn2…). Let’s focus on progn. This runs fine in ielm.

(progn (setq approx-pi (/ 22.0 7)) (message "%f" approx-pi))

progn runs all S-expressions but only return the last value.

(progn
  (/ 1.0 2 )
  (/ 9 3)
  (/ 22.0 7))

The above rust program can be expressed in emacs lisp as ⁴:

(let* ((age 41)
	(compensation 
		(if (>= age 40)
			(progn
				(message "You are old. I'll give you more compensation.")
				(* age 20.0))
			(progn
				(message "You are young. You don't need that much compensation.")
				(* age 0.5))
			)))
	(message "You receive %f€ in compensation." compensation))

Many default key configurations are transferable. For example, “dired-like” modes have similar key configurations (e.g. “g” for revert-buffer). I usually think along the same line when I assign my keys. I have a motto: For any given mode, find out the most frequently used command (besides cursor movement) and then assign the key combination C-q to that command.

You might ask: why C-q? First, C-q is close to C-w and C-a, both are frequently used key combinations. Second, I actually don’t understand what the command originally mapped to C-q (quoted-insert) does. Okay, I admit that I am lying. I know what quoted-insert does, but I actually don’t use the command.

Okay, okay, I am lying again. I actually read it somewhere that someone binds C-q to ess-eval-region-or-line-and-step. The Mandela Effect kicks in. I thought that I read it somewhere in the Emacs Speaks Statistics Config Share Space and specifically from Kara Woo’s configuration. But I was wrong. Actually, I “cargo-culted” key chords from her configuration (see day 7). Upon some searching on Github, I can only see that Github user mt-christo assigns C-q to ess-eval-region-or-line-and-step. I probably copied it from there.

ess-eval-region-or-line-and-step and eval-in-repl

By ESS’ default, C-RET maps to ess-eval-region-or-line-and-step. And it is similar to RStudio. But C-RET isn’t ideal because it clashes with many things ¹. And I really needed to remap it. And C-q is my choice.

I want to take this opportunity to praise the ESS team for coming up with the command ess-eval-region-or-line-and-step. It is an extremely effective command. For a long time, I used ess-eval-region (C-c C-r) and ess-eval-line (C-c C-j). But the step part of the command ess-eval-region-or-line-and-step makes it wunderbar. It jumps to the next line of code automatically! So, I can just repeatedly press C-q when I want to eval a whole page of R code one line at a time.

eval-in-repl by Kazuki Yoshida et al provides the same ess-eval-region-or-line-and-step experience to many different languages. For example, I can have the same experience to eval emacs lisp code in ielm. My key combination, well, of course is also C-q.

(use-package eval-in-repl
  :bind (
		 :map emacs-lisp-mode-map
			  ("C-q" . 'eir-eval-in-ielm)
			  :map lisp-interaction-mode-map
			  ("C-q" . 'eir-eval-in-ielm)
			  :map Info-mode-map
			  ("C-q" . 'eir-eval-in-ielm))
  :config
  (require 'eval-in-repl-ielm)
  :init
  (setq eir-ielm-eval-in-current-buffer t)
  )

One key combination to rule them all

Because my brain has been hardwired to pressing C-q, I add C-q to many modes. For many modes, there are just a few operations; directional operations and maybe one or two additional commands. For those modes, I just leave the directional operations intact and then the most important commands to C-q.

On day 3, you see that I assign C-q to vterm-send-next-key-verbose. On day 22, I assign C-q to toggling the cursor in nov.

For elfeed, I assign C-q to elfeed-update. For deft, deft-filter is assigned to —you guess it— C-q. ² C-q becomes my second panic button, after the first panic button C-g ³.

A normal emacs installation comes with a few thousand commands. By homogenizing the key combination like this, the complexity of emacs is reduced and hence the cognitive load to use it. Also, it makes the emacs experience truly my own.