AI assistants in Emacs. Don't use ChatGPT. Help Open Science.

Everybody seems to be very excited about generative AI models these days. The availability of the Large Language Models (LLMs) through conversational interfaces like ChatGPT and of image generation tools like Dall-E or Stable Diffusion have brought generative AI to the masses. Although Github Copilot, also based on the GPT family of models, has been available for a while now, this was a niche tool, for programmers only.

Of course, Emacs being the best text-based interface to a computer, it is also the best interface to the generative AI models which are driven through textual prompts. Everything being a text buffer in Emacs, sending and receiving text via an API is straightforward (if you know Emacs Lisp).

It is therefore not a surprise that there are many Emacs packages allowing to use ChatGPT and Copilot. Just to list a few¹:

• gptai
• gptel
• org-ai
• chatgpt-shell
• copilot.el

Recently, David Wilson at System Crafters did a live stream showing some of the capabilities of these packages. To be honest, I was not impressed by the results of the code generated by the LLMs, but I can understand that many people may find them useful.

At the end of the stream, David wanted to address the question of the problems and issues with using these models. Of course, being a programmer, David likes recursion, and he asked ChatGPT about that. The LLM answered, as usual, with a balanced view with pros and cons. It is also usual for these models, in my opinion, to give awfully banal answers. There can be legal issues, copyright ones (in both senses, that is, that the models are trained with copyrighted material, and that the copyright of their outputs is not well defined), ethical problems, etc.

As always, the Silicon Valley tech firms have not waited for these issues to be settled before deploying the technology to the public. They impose their vision regardless of the consequences. Unfortunately, most programmers like the tech so much that they don't stop thinking before adopting and participating in spreading it.

Emacs being one of the most important contributions of the Free Software community, it may be surprising that some of its users are so keen to ride the latest Trojan horse of technofeudalism. Fermin pointed out a similar kind of issue with the Language Server Protocol, but that was not a real problem, since LSP servers run locally and we have free software implementations of them. This is not the case for ChatGPT or Copilot. We only have an API that can be taken down at any moment. But worse than that, as pointed out, using these LLMs means that we are working in training them. Every time that David, in his demo, wrote "… the code is wrong because of …, can you fix it?", he was giving feedback for the reinforcement learning of ChatGPT.

So what can we do? Stop using these tools and loose our programming or writing jobs because we will be less productive than those that use them?

Maybe we can do what GNU hackers and other Free Software activists have always done: implement libre tools that are digital common goods that free and empower users. Building and training big AI models is very costly and may be much more difficult than building an OS kernel like Linux, GCC or Emacs, but fortunately, there are already alternatives to ChatGPT.

The best starting point could be helping the BigScience Project by using their Bloom model from Emacs to train it and improve it. Hints on how to install Bloom locally and use it with Python can be found in this blog post. There are also initiatives to use federated learning² to improve Bloom. The BigCode project targets code generation, and is to BigScience what Copilot is to ChatGPT. You can play with it here. There is a VSCode plugin for their StarCoder model, but no Emacs package yet. Isn't that a shame?

BigScience is Open Science, while OpenAI's is not open, but proprietary technology built from common digital goods harvested on the internet. It shouldn’t be difficult for us, Emacs users, to choose who we want to help.

A workaround for an annoying EXWM behavior

I have been using the Emacs X Window Manager, EXWM, for a couple of years now and I have come to depend on it for an efficient and friendly workflow for most of what I do at the computer. Before that, I had been using StumpWM for 4 or 5 years and I was already sold on tiling window managers. For someone like me who does everything in Emacs except for browsing sites that need Javascript or watching videos, EXWM seems to be the perfect setup.

The pain point with EXWM is that its development and maintenance suddenly stopped after the creator and maintainer went AWOL. There have been discussions here and there to continue the development, but, to the best of my knowledge, no initiative has really taken off.

Some well known EXWM users in the community started migrating to other WMs, like StumpWM, Herbstluftwm or or QTile. I also tried to get back to StumpWM, since I had used it for a long time, but I found the experience inferior to EXWM: having M-x everywhere and not having to use different key bindings when talking to the WM or to Emacs is a real comfort.

However, some time ago, floating windows started behaving annoyingly. For instance, when saving a file in Firefox, the file chooser application would be too high and the Save button would be below the bottom of the screen. I then would have to move the window up so that I could click. Not knowing anything about X, I wasn't able to diagnose the issue.

I ended writing a little function to resize a floating window:

(defun my/resize-floating-frame (width height)
  "Resize a floating exwm frame to WIDTHxHEIGHT"
  (interactive "nWidth: \nnHeight: ")
    (let ((floating-container (frame-parameter exwm--floating-frame
                                               'exwm-container)))
      (exwm--set-geometry floating-container nil nil width height)
      (exwm--set-geometry exwm--id nil nil width height)
      (xcb:flush exwm--connection)))

and bound it to a key to call it with a size that would fit:

(exwm-input-set-key (kbd "s-x r") (lambda () (interactive) (my/resize-floating-frame 600 800)))

So now, instead of grabbing the mouse and manually moving the window, I could just use s-x r and hit enter, since the Save button is selected by default. This is a big win, but after a couple of days, I became tired of this and thought that this could be automated. Also, the arbitrary fixed size may not be appropriate depending on the monitor I am using.

So with a little more elisp, I wrote a function that computes the size of the window and works with a hook which is called by EXWM and the end of the setup of the floating window:

(defun my/adjust-floating-frame-size ()
  "Ensure that the current floating exwm frame does not exceed the size of the screen"
  (let* ((frame (selected-frame))
         (width (frame-pixel-width frame))
         (height (frame-pixel-height frame))
         (w1 (elt (elt exwm-workspace--workareas 0) 2))
         (h1 (elt (elt exwm-workspace--workareas 0) 3))
         (w2 (elt (elt exwm-workspace--workareas 1) 2))
         (h2 (elt (elt exwm-workspace--workareas 1) 3))
         (max-width (round (* 0.75 (min w1 w2))))
         (max-height (round (* 0.75 (min h1 h2))))
         (final-height (min height max-height))
         (final-width (min width max-width)))
    (set-frame-size frame final-width final-height t)))
(add-hook 'exwm-floating-setup-hook #'my/adjust-floating-frame-size 100)

All this may seem complex and one could think that too much elisp-foo is needed to do all this. This is absolutely not the case. With a little effort and time, it is not difficult to navigate the source code and test things interactively to see how they behave. In this particular case, searching for hooks in the EXWM package (M-x describe-variable) and trying little code snippets on the *scratch* buffer got me there rather quickly.

This is yet another demonstration of the power of Emacs: you can modify its behavior interactively and all source code and documentation is immediately accessible. You don't need to be a skilled programmer to do that.

That's user freedom, the real meaning of software freedom.

Read e-books from your Calibre library inside Emacs

I read many books in electronic format. I manage my e-book library with the great Calibre software. For non fiction books (science, philosophy, productivity, computer science, etc.) I like to read on my laptop, so I can easily take notes, or actually generate Zettels. Since I create new zettels with org-capture, reading inside Emacs is very handy. For EPUB format, I use the excellent nov.el and for PDF files I use pdf-tools. Both of these packages provide org links, so I don't have to do anything special to capture notes and have a back-link to the point in the e-book where the note was taken from. This is standard org-capture.

I also use org links as bookmarks between reading sessions. Yes, that is bookmarks as marks in the book, like real, paper books.

The part in my reading workflow where Emacs wasn't used was managing the e-book library. Usually, when I got a new book, I would open Calibre, add the book, fetch missing meta-data and cover if needed and then close Calibre. After that, I would use calibre-mode.el to call calibre-find to search for the book and insert an org link into my reading list.

I have been aware of calibredb.el for a couple of years (or maybe a little less), but I had not used it very much. After a recent update of my packages, I had a look at it again and I discovered that it provides all the features I use in the Calibre GUI, so I have started to use it to add books and curate meta-data and covers.

calibredb has a function to open a book from the list: calibredb-open-file-with-default-tool which in my case runs ebook-viewer for EPUB and evince for PDF. I did not find an option or a variable to change that, so I looked at the code of the function:

(defun calibredb-open-file-with-default-tool (arg &optional candidate)
  "Open file with the system default tool.
If the universal prefix ARG is used, ignore `calibredb-preferred-format'.
Optional argument CANDIDATE is the selected item."
  (interactive "P")
  (unless candidate
    (setq candidate (car (calibredb-find-candidate-at-point))))
  (if arg
      (let ((calibredb-preferred-format nil))
        (calibredb-open-with-default-tool (calibredb-get-file-path candidate t)))
    (calibredb-open-with-default-tool (calibredb-get-file-path candidate t))))

This function calls calibredb-open-with-default-tool, which looks like this:

(defun calibredb-open-with-default-tool (filepath)
  "TODO: consolidate default-opener with dispatcher.
Argument FILEPATH is the file path."
  (cond ((eq system-type 'gnu/linux)
         (call-process "xdg-open" nil 0 nil (expand-file-name filepath)))
        ((eq system-type 'windows-nt)
         (start-process "shell-process" "*Messages*"
                        "cmd.exe" "/c" (expand-file-name filepath)))
        ((eq system-type 'darwin)
         (start-process "shell-process" "*Messages*"
                        "open" (expand-file-name filepath)))
        (t (message "unknown system!?"))))

So in GNU/Linux, it calls xdg-open, which delegates to the appropriate applications. But of course, I want to use Emacs.

I could use xdg-settings to change the behavior, but that would mean using emacsclient which seems weird given that I am already inside Emacs (actually, I use EXWM, so it is still weirder). Furthermore, since my Emacs is configured to open EPUB files with nov.el and PDF with pdf-view, I only need to call find-file on the selected file.

So I just adapted calibredb-open-file-with-default-tool and bound it to the same key as the original function:

  (defun my/calibredb-open-file-with-emacs (&optional candidate)
    "Open file with Emacs.
Optional argument CANDIDATE is the selected item."
    (interactive "P")
    (unless candidate
      (setq candidate (car (calibredb-find-candidate-at-point))))
    (find-file (calibredb-get-file-path candidate t)))
  (define-key calibredb-search-mode-map "V" #'my/calibredb-open-file-with-emacs)

This is yet another demonstration of the power of Emacs: packages that were not designed to work together can be combined exactly as you want. You don't need to be a skilled programmer to do that.

That's user freedom, the real meaning of software freedom.

Install Emacs with Conda

At work, I frequently use a high performance computing cluster (300 nodes, 1000 CPU, 44 TB of RAM). It is an amazing environment. Many users access the system via Jupyter Hub and Virtual Research Environments where many tools for development are available. However the recommended editor is VSCode and I need Emacs.

I access the system via ssh on a terminal and run Emacs without the GUI. This is enough for me, since I have all I need:

1. Window multiplexing using Emacs windows
2. Virtual desktops thanks to tab-bar-mode
3. Persistence across sessions using desktop-save-mode
4. IDE features with eglot
5. A data science environment with org-mode's babel

This is great, since I can use the same tools I use on my laptop, with the same configuration and be really efficient.

Unfortunately, a couple of months ago, the web proxy that we have to go through to access the internet from the cluster was upgraded and the old Emacs version available on the system was not able to fetch packages.

Doing some research, I found that Emacs 27 could be configured to work. Since I did not want to bother the sysadmins without being sure that it would work, I decided to compile Emacs from source as I do on my laptop.

Unfortunately, I couldn't manage to get all dependencies working. So I needed to find another way to have a recent Emacs on the system.

On the cluster, we use Conda to build virtual environments for scientific computing. With Conda, we can install whatever package we want at the user level without any particular privilege.

So I just did:

conda install emacs

and I got the last stable Emacs release, which is 27.2 at the time of this writing.

So if you need to use Emacs in a system where you can't install system wide packages and you don't want or can't build it yourself, Conda can be a good solution. Installing Conda does not need particular privileges.

Some Org Mode agenda views for my GTD weekly review

(setq org-todo-keywords 
      (quote ((sequence "TODO(t!/!)" "NEXT(n!/!)" 
                        "STARTED(s!)" "|" "DONE(d!/!)")
              (type "PROJECT(p!/!)" "|" "DONE_PROJECT(D!/!)")
              (sequence "WAITING(w@/!)" "SOMEDAY(S!)"  "|"
                        "CANCELLED(c@/!)"))))

(define-key global-map "\C-ca" 'org-agenda)

(setq org-agenda-custom-commands
      (quote
       (("D" "Daily Action List"
         ((agenda ""
                  ((org-agenda-span 1)
                   (org-agenda-sorting-strategy
                    (quote
                     ((agenda time-up category-up tag-up))))
                   (org-deadline-warning-days 7))))
         nil)
        ;; [....] 
        )))

(setq org-agenda-custom-commands
      (quote
       (
        ;; [....]
        ("n" . "Next Actions List")
        ("nn" tags "+TODO=\"NEXT\"|+TODO=\"STARTED\"")
        ("na" tags "+home+admin+TODO=\"NEXT\"|+home+admin+TODO=\"STARTED\"")
        ("nh" tags "+home+TODO=\"NEXT\"|+home+TODO=\"STARTED\"")
        ;; [....]
        )))

(defun my/show-next-without-effort ()
  (interactive)
  (org-ql-search (org-agenda-files)
    '(and (todo "NEXT")
          (not (property "Effort")))))

(defun my/generate-agenda-weekly-review ()
  "Generate the agenda for the weekly review"
  (interactive)
  (let ((span-days 24)
        (offset-past-days 10))
    (message "Generating agenda for %s days starting %s days ago"
             span-days offset-past-days)
    (org-agenda-list nil (- (time-to-days (date-to-time
                                           (current-time-string)))
                            offset-past-days) 
                     span-days)
    (org-agenda-log-mode)
    (goto-char (point-min))))

(setq org-agenda-custom-commands
      (quote
       (
        ;; [....]
        ("P" "Stuck Projects"
         ((org-ql-block '(and (todo "PROJECT")
                              (or (not (descendants))
                                  (and (not (descendants 
                                             (or (todo "STARTED") (todo "NEXT"))))
                                       (descendants 
                                        (and (or (todo "TODO") (todo "WAITING")) 
                                                         (not (deadline)) 
                                                         (not (scheduled)))))
                                  (not (descendants (or (todo "NEXT") (todo "TODO") 
                                                        (todo "WAITING") 
                                                        (todo "STARTED")))))))))
        ;; [...]
        )))

(setq org-agenda-custom-commands
      (quote
       (
        ;; [....]
        ("p" . "Projects List")
        ("pp" tags "+TODO=\"PROJECT\"")
        ("pw" tags "+TODO=\"PROJECT\"+work")
        ("ph" tags "+TODO=\"PROJECT\"+home")
        )))

(defun my/search-random-someday ()
  "Search all agenda files for SOMEDAY and jump to a random item"
  (interactive)
  (let* ((todos '("SOMEDAY"))
         (searches (mapcar (lambda (x) (format "+TODO=\"%s\"" x)) todos))
         (joint-search (string-join searches "|") )
         (org-agenda-custom-commands '(("g" tags joint-search))))
      (org-agenda nil "g")
      (let ((nlines (count-lines (point-min) (point-max))))
        (goto-line (random nlines)))))