I was big fan of Session Manager, small addon for Chrome and Chromium that will save all open tabs, assign the name to session and, when is needed, restore it.

Very useful, especially if you are like me, switching between multiple "mind sessions" during the day - research, development or maybe news reading. Or simply, you'd like to remember workflow (and tabs) you had few days ago.

After I decided to ditch all extensions from Chromium except uBlock Origin, it was time to look for alternative. My main goal was it to be browser agnostic and session links had to be stored in text file, so I can enjoy all the goodies of plain text file. What would be better for that than good old org-mode ;)

Long time ago I found this trick: Get the currently open tabs in Google Chrome via the command line and with some elisp sugar and coffee, here is the code:

(require 'cl-lib)

(defun save-chromium-session ()
  "Reads chromium current session and generate org-mode heading with items."
  (interactive)
  (save-excursion
    (let* ((cmd "strings ~/'.config/chromium/Default/Current Session' | 'grep' -E '^https?://' | sort | uniq")
           (ret (shell-command-to-string cmd)))
      (insert
       (concat
        "* "
        (format-time-string "[%Y-%m-%d %H:%M:%S]")
        "\n"
        (mapconcat 'identity
                   (cl-reduce (lambda (lst x)
                                (if (and x (not (string= "" x)))
                                    (cons (concat "  - " x) lst)
                                  lst))
                              (split-string ret "\n")
                              :initial-value (list))
                   "\n"))))))

(defun restore-chromium-session ()
  "Restore session, by openning each link in list with (browse-url).
Make sure to put cursor on date heading that contains list of urls."
  (interactive)
  (save-excursion
    (beginning-of-line)
    (when (looking-at "^\\*")
      (forward-line 1)
      (while (looking-at "^[ ]+-[ ]+\\(http.?+\\)$")
        (let* ((ln (thing-at-point 'line t))
               (ln (replace-regexp-in-string "^[ ]+-[ ]+" "" ln))
               (ln (replace-regexp-in-string "\n" "" ln)))
          (browse-url ln))
        (forward-line 1)))))

So, how does it work?

Evaluate above code, open new org-mode file and call M-x save-chromium-session. It will create something like this:

* [2019-12-04 12:14:02]
  - https://www.reddit.com/r/emacs/comments/...
  - https://www.reddit.com/r/Clojure
  - https://news.ycombinator.com

or whatever urls are running in Chromium instance. To restore it back, put cursor on desired date and run M-x restore-chromium-session. All tabs should be back.

Here is how I use it, with randomly generated data for the purpose of this text:

#+TITLE: Browser sessions

* [2019-12-01 23:15:00]...
* [2019-12-02 18:10:20]...
* [2019-12-03 19:00:12]
  - https://www.reddit.com/r/emacs/comments/...
  - https://www.reddit.com/r/Clojure
  - https://news.ycombinator.com

* [2019-12-04 12:14:02]
  - https://www.reddit.com/r/emacs/comments/...
  - https://www.reddit.com/r/Clojure
  - https://news.ycombinator.com

Note that hack for reading Chromium session isn't perfect: strings will read whatever looks like string and url from binary database and sometimes that will yield small artifacts in urls. But, you can easily edit those and keep session file lean and clean.

To actually open tabs, elisp code will use browse-url and it can be further customized to run Chromium, Firefox or any other browser with browse-url-browser-function variable. Make sure to read documentation for this variable.

Don't forget to put session file in git, mercurial or svn and enjoy the fact that you will never loose your session history again :)

What about Firefox?

If you are using Firefox (recent versions) and would like to pull session urls, here is how to do it.

First, download and compile lz4json, small tool that will decompress Mozilla lz4json format, where Firefox stores session data. Session data (at the time of writing this post) is stored in $HOME/.mozilla/firefox/<unique-name>/sessionstore-backups/recovery.jsonlz4.

If Firefox is not running, recovery.jsonlz4 will not be present, but use previous.jsonlz4 instead.

To extract urls, try this in terminal:

$ lz4jsoncat recovery.jsonlz4 | grep -oP '"(http.+?)"' | sed 's/"//g' | sort | uniq

and update save-chromium-session with:

(defun save-chromium-session ()
  "Reads chromium current session and converts it to org-mode chunk."
  (interactive)
  (save-excursion
    (let* ((path "~/.mozilla/firefox/<unique-name>/sessionstore-backups/recovery.jsonlz4")
           (cmd (concat "lz4jsoncat " path " | grep -oP '\"(http.+?)\"' | sed 's/\"//g' | sort | uniq"))
           (ret (shell-command-to-string cmd)))
...
;; rest of the code is unchanged

Updating documentation strings, function name and any further refactoring is left for exercise.

I was big fan of Session Manager, small addon for Chrome and Chromium that will save all open tabs, assign the name to session and, when is needed, restore it.

Very useful, especially if you are like me, switching between multiple "mind sessions" during the day - research, development or maybe news reading. Or simply, you'd like to remember workflow (and tabs) you had few days ago.

After I decided to ditch all extensions from Chromium except uBlock Origin, it was time to look for alternative. My main goal was it to be browser agnostic and session links had to be stored in text file, so I can enjoy all the goodies of plain text file. What would be better for that than good old org-mode ;)

Long time ago I found this trick: Get the currently open tabs in Google Chrome via the command line and with some elisp sugar and coffee, here is the code:

(require 'cl-lib)

(defun save-chromium-session ()
  "Reads chromium current session and generate org-mode heading with items."
  (interactive)
  (save-excursion
    (let* ((cmd "strings ~/'.config/chromium/Default/Current Session' | 'grep' -E '^https?://' | sort | uniq")
           (ret (shell-command-to-string cmd)))
      (insert
       (concat
        "* "
        (format-time-string "[%Y-%m-%d %H:%M:%S]")
        "\n"
        (mapconcat 'identity
                   (cl-reduce (lambda (lst x)
                                (if (and x (not (string= "" x)))
                                    (cons (concat "  - " x) lst)
                                  lst))
                              (split-string ret "\n")
                              :initial-value (list))
                   "\n"))))))

(defun restore-chromium-session ()
  "Restore session, by openning each link in list with (browse-url).
Make sure to put cursor on date heading that contains list of urls."
  (interactive)
  (save-excursion
    (beginning-of-line)
    (when (looking-at "^\\*")
      (forward-line 1)
      (while (looking-at "^[ ]+-[ ]+\\(http.?+\\)$")
        (let* ((ln (thing-at-point 'line t))
               (ln (replace-regexp-in-string "^[ ]+-[ ]+" "" ln))
               (ln (replace-regexp-in-string "\n" "" ln)))
          (browse-url ln))
        (forward-line 1)))))

So, how does it work?

Evaluate above code, open new org-mode file and call M-x save-chromium-session. It will create something like this:

* [2019-12-04 12:14:02]
  - https://www.reddit.com/r/emacs/comments/...
  - https://www.reddit.com/r/Clojure
  - https://news.ycombinator.com

or whatever urls are running in Chromium instance. To restore it back, put cursor on desired date and run M-x restore-chromium-session. All tabs should be back.

Here is how I use it, with randomly generated data for the purpose of this text:

#+TITLE: Browser sessions

* [2019-12-01 23:15:00]...
* [2019-12-02 18:10:20]...
* [2019-12-03 19:00:12]
  - https://www.reddit.com/r/emacs/comments/...
  - https://www.reddit.com/r/Clojure
  - https://news.ycombinator.com

* [2019-12-04 12:14:02]
  - https://www.reddit.com/r/emacs/comments/...
  - https://www.reddit.com/r/Clojure
  - https://news.ycombinator.com

Note that hack for reading Chromium session isn't perfect: strings will read whatever looks like string and url from binary database and sometimes that will yield small artifacts in urls. But, you can easily edit those and keep session file lean and clean.

To actually open tabs, elisp code will use browse-url and it can be further customized to run Chromium, Firefox or any other browser with browse-url-browser-function variable. Make sure to read documentation for this variable.

Don't forget to put session file in git, mercurial or svn and enjoy the fact that you will never loose your session history again :)

What about Firefox?

If you are using Firefox (recent versions) and would like to pull session urls, here is how to do it.

First, download and compile lz4json, small tool that will decompress Mozilla lz4json format, where Firefox stores session data. Session data (at the time of writing this post) is stored in $HOME/.mozilla/firefox/<unique-name>/sessionstore-backups/recovery.jsonlz4.

If Firefox is not running, recovery.jsonlz4 will not be present, but use previous.jsonlz4 instead.

To extract urls, try this in terminal:

$ lz4jsoncat recovery.jsonlz4 | grep -oP '"(http.+?)"' | sed 's/"//g' | sort | uniq

and update save-chromium-session with:

(defun save-chromium-session ()
  "Reads chromium current session and converts it to org-mode chunk."
  (interactive)
  (save-excursion
    (let* ((path "~/.mozilla/firefox/<unique-name>/sessionstore-backups/recovery.jsonlz4")
           (cmd (concat "lz4jsoncat " path " | grep -oP '\"(http.+?)\"' | sed 's/\"//g' | sort | uniq"))
           (ret (shell-command-to-string cmd)))
...
;; rest of the code is unchanged

Updating documentation strings, function name and any further refactoring is left for exercise.

Last week, I wrote about Perry Metzger’s reasons for not using Emacs to read his email. His take on email is something on the order of, “These days, email is HTML. Deal with it.” Many of us would rather not deal with it but Metzger’s point is well taken. An awful lot of email (maybe even most) comes to you as HTML.

Over at the Emacs subreddit, NukedTeas writes that he’s just had his first, “Gee, I wish I were writing this email in Emacs” moment and goes on to say that he’s going to have to figure out how to do that. The comments were of two types. First, there were the supporters who offered advice on how to do that—mostly mu4e or Notmuch along with offlineimap or mbsync to retrieve the mail.

There was another group of commenters, though, typified by kingpatzer who said that “It’s actually impossible to do email in Emacs”. That comes as a shock to the many of us who do just that everyday. Kingpatzer’s real point, of course, is the same as Metzger’s: Emacs doesn’t render HTML emails very well and most of our email is HTML. A surprising number of commenters agreed or made the same point.

I’m more inclined to agree with oantolin who suggests, “Just stop reading email that isn’t plaintext, I doubt anyone will notice”. That’s a bit smart-alecky, perhaps, but it hints at something that might be true: Most email that comes to you as HTML only is probably not worth reading. I’ve certainly found that true. Almost all of it is commercial messages of one sort or another. There are a few exceptions. The ACM, to its everlasting shame, sends its emails in a form that can’t be rendered in plain text and even EWW doesn’t do a great job with them. Of course, when that happens I just type a v and it pops me into the my browser and displays it there. That’s a bit of a pain but only a bit and it’s more than made up for by doing the majority of my email work in Emacs.

The other point worth making is that most non-spam email that comes as HTML has no reason to be HTML. If you’re an Emacs user, one would expect that most of the people you communicate with know that and send plain text. Sadly, that’s not the case. The only real answer is that given by Metzger: fix Emacs so it can render HTML well. That’s not easy, of course, but it’s definitely worthwhile.

EmacsConf 2019 videos out! (Reddit) – Videos, Invidio.us, Youtube

• Emacs configuration:
  • Wrote the second part in “Configuring Emacs from Scratch”. Please review and suggest improvements. Thanks! :)
• Emacs Lisp:
  • Learning Elisp
  • emacs-piper: Think commandline but for Emacs and unstructured data.
  • Manuel Uberti: The aesthetics of patching
  • emacs-sandbox.sh: Run Emacs in a clean, sandbox configuration
  • Natively compiled elisp: gccemacs (Reddit, HN)
• Emacs development:
  • EAF, extending Emacs with amazing GUI support using Python PyQt (Reddit)
  • Use run-with-idle-timer instead of debounce for responsive image scaling.
  • Improve documentation and UI of ‘C-x v L’
  • Improve errors & warnings due to fancy quoted vars (Bug#32939)
  • Stop signaling an error when reading “smart quotes” in symbols
  • Menu bar rearrangements, move Print menu items to submenu, etc. (bug#37594)
  • ‘C-1 C-x v L’ asks for revision and shows its log entry with diff (bug#38044)
  • * lisp/image-mode.el: Resize image on window resizing (bug#32672)
  • Mouse rectangular region selection (bug#38013)
  • Fine-grained NS modifier key settings (bug#38296)
  • message uses minibuffer-message in the active minibuffer (bug#17272 bug#19064)
  • Fix previous change to (next|previous)-buffer
  • (next|previous)-buffer no longer fail silently (bug#38384)
  • Mention switch from ‘switch-to-visible-buffer’ to ‘switch-to-prev-buffer-skip’
  • Extend network-interface-list to return IPv6 and network info
• Org Mode:
  • org demo – YouTube
  • An HTML template system for Emacs and org-mode (Reddit)
  • Literate Programming with Emacs Orgmode
  • EmacsConf2019: Restclient + org-mode for documentation and testing
• Coding:
  • Code folding with outline-minor-mode
  • Emacs has made my life as a Python developer much better.
  • Using iex’s open() command with Emacs multiterm
  • Emax: dante for reflex projects (stream) (Reddit)
  • Emacs as a lightweight Java IDE – 2 (Refactoring) (2:08)
  • EmacsConf2019: Example Chef cookbook and InSpec profile used in the live demo at EmacsConf 2019.
• Community:
  • Weekly tips/trick/etc/ thread
  • How is emacs funded?
  • Emacs: The Editor for the Next Forty Years (Reddit, HN, Irreal)
• Other:
  • A beginner’s guide to text editing with Emacs (Reddit)
  • Moving from Vim to Emacs (Irreal, Reddit)
  • Cloudmacs: Emacs in your web browser (Reddit, HN)
  • Emacs Everywhere (2017)
  • emacspeak: Emacspeak 51.0 (AsssistDog) Unleashed!
  • How to install the latest developmental version of Emacs (27.0.50) on Windows 10 – for dummies
  • OpenChaos am Donnerstag, 28. November: State of Retro Gaming in Emacs
  • Irreal: Scimax and Reproducibility
  • WIP package: lyx-formula
  • Anyone want to collaborate on music-making that involves Emacs?
  • SchemeMosaic Chop’n’Screw How-To (Part 1) (Reddit)
  • How to set up Emacs to best type Ancient Greek and Hebrew – for dummies
• New packages:
  • counsel-jq: Live preview of “jq” queries using counsel
  • khardel: Integrate with khard
  • modus-operandi-theme: Accessible light theme (WCAG AAA)
  • modus-vivendi-theme: Accessible dark theme (WCAG AAA)
  • org-scrum: org mode extensions for scrum planning and reporting

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, Hacker News, planet.emacslife.com, YouTube, the Emacs NEWS file and emacs-devel.

Paul Kuruvilla is a recent immigrant to Emacs from Vim. Of course, that’s a familiar story—along with those going in the opposite direction—and wouldn’t be worth commenting on except for Kuruvilla’s take on the three main Emacs “distributions:” Vanilla Emacs, Spacemacs, and Doom Emacs. His observations are interesting because those of us safely ensconced in the Emacs world become blind to the problems that these variations present to a new user.

As a long time Vim user, Kuruvilla decided against abandoning his Vim muscle memory and opted for packages with Vi emulation. He liked the descriptions he found of Spacemacs and decided to give it a go. Standard Spacemacs seemed too bloated and complicated for his needs so he tried Spacemacs-base. The problems began when he tried to add more functionality. It wasn’t as seamless a process as he would have liked so he tried standard Spacemacs instead.

He found standard Spacemacs to be too bloated and significantly slower for some tasks. He also found that it would sometimes freeze in the middle of editing files. That’s not acceptable, of course, so he took a look at Doom Emacs.

Doom is famously targeted specifically at former Vim users and Kuruvilla found that although it required more work to set up, it met his needs better than Spacemacs. He’s now a happy Emacs user in the camp of the Doom adherents.

As many of you know, I was also a long time Vim user but when I came to Emacs more than a decade ago, I decided to embrace Emacs entirely and chose Vanilla Emacs. I haven’t regretted that choice for an instant but I am aware that some Vanilla Emacs users have migrated to Spacemacs, Doom, or one of the Vi emulation modes to deal with repetitive stress issues.

I know some Irreal readers are ardent Spacemacs users and swear by it so I was a bit surprised at Kuruvilla’s problems with it. If you’re a Spacemacs user and have seen to same problems, leave a comment. Or if you’re a Spacemacs user and haven’t seen those problems, also leave a comment. In the mean time, welcome, Mr. Kuruvilla, to the Emacs family.

In describing my move to Helm, I quickly mentioned another package from Thierry Volpiatto: psession. psession is a light session saving mechanism and it comes with built-in integration for Helm among other things, which of course renders it a valuable improvement to my setup. The installation instructions are pretty clear, so there is no need to bother you with obvious code snippets.

Instead, I want to bother you with my obsessive-compulsive disorder. You see, I am fond of how my beloved text editor looks, especially after boot. I disabled every message, toolbar, scrollbar, menu, and buffer Emacs can throw at me on startup, and the theme is applied as late as possible to ensure nothing obstructs my way to another great day of text editing.

What’s “wrong” with psession then? In order to make the previous sessions available, psession loads some compiled files when Emacs starts. This is what I expect it to do, because there would be no point in saving sessions without restoring them. My only “problem” with this behaviour is the file loading itself.

(cl-defun psession--restore-objects-from-directory
    (&optional (dir psession-elisp-objects-default-directory))
  (let ((file-list (directory-files dir t directory-files-no-dot-files-regexp)))
    (cl-loop for file in file-list do (and file (load file)))))

The code is not hard to understand. What constitutes a rude attack at my delicate aesthetic feelings is that (load file) right before the good-looking closing parentheses. Calling load in this manner causes a bunch of messages to “interfere” with a clean Emacs boot: they show up in the echo area during the loading of my init.el and they hurt so bad!¹

Let’s examine the documentation of the function load:

load is a function defined in lread.c.

Signature

(load FILE &optional NOERROR NOMESSAGE NOSUFFIX MUST-SUFFIX)

Documentation

Execute a file of Lisp code named FILE.

[…]

Print messages at start and end of loading unless optional third arg NOMESSAGE is non-nil (but force-load-messages overrides that).

[…]

Perfect. Now I just have to hack psession--restore-objects-from-directory and make sure load is called with a non-nil value for NOMESSAGE. Usually when I want to silence a command I rely on inhibit-message. Let’s say I want to silence the activation of helm-adaptive-mode:

(let ((inhibit-message t))
  (helm-adaptive-mode +1))

However, psession--restore-objects-from-directory is sort of a private function, so I need something else to change it according to my plans. There are probably several good ways to patch psession--restore-objects-from-directory, but my go-to package in these situations is Radon Rosborough’s el-patch.

(el-patch-feature psession)
(with-eval-after-load 'psession
  (el-patch-cl-defun psession--restore-objects-from-directory
    (&optional (dir psession-elisp-objects-default-directory))
    (let ((file-list (directory-files dir t directory-files-no-dot-files-regexp)))
      (cl-loop for file in file-list do (and file (load file nil 'nomessage))))))

Only six lines of code to please my sense of aesthetic. Beauty is always within reach when we are dealing with Emacs.

Note that at the moment of this writing, el-patch-cl-defun is on the develop branch of el-patch. See here to know more about this and to laugh at my poor reading skills.

Footnotes

If you’ve watched Perry Metzger’s Emacs Conference 2019 talk, as I hope you have, you’ll know that Metzger believes that modern Email should be carried as HTML. He wants—needs, he says—to see his colleagues emails exactly as they were written and to let those colleagues see his emails exactly as he has written them. Here’s a quote from one of his slides explaining why he no longer reads emails in Emacs:

Modern email is HTML. I need to see HTML email the way my colleagues see it. I have no choice. It’s not 1992 any more.

I can sympathize. Metzger is a technical guy doing technical work and he can’t afford to have the ideas in his communications with his colleagues mangled by the email presentation layer. Still, I really, really hate HTML emails and I’m not alone. I’m aware that at this point that’s a rearguard reaction but it’s a view held by many, even—or perhaps especially—by those in the technical fields. Metzger’s probably right but I still hate it.

Paul Graham also has a view on the issue:

The more formatting your email has, the less I want to read it. A short, plain text email reads as a message to me. If you use bulleted lists and different typefaces, it looks like spam.

— Paul Graham (@paulg) June 19, 2019

I didn’t realize it until after I saw his tweet but that’s exactly how I feel. When I see an HTML email with multiple fonts and fancy formatting, I can be pretty certain it’s trash. Perhaps I need to start hanging out with Metzger’s colleagues. Or perhaps I’m just hopelessly reactionary.

The videos from the Emacs Conference 2019 are up at YouTube. As many of you know I’m a big fan of Perry Metzger’s 2014 talk on 31 years as an Emacs user so the first video I watched was what amounted to a follow up to that talk. In Emacs: The Editor for the Next Forty Years, Metzger looks at the future of Emacs, where he thinks it’s going, and what it needs to do to remain the premier editor that it is.

As Metzger says, it’s not 1992 anymore and many of the younger hackers aren’t adopting Emacs so we need to update it to meet modern needs. Of course, as Metzger also notes, Emacs has undergone continuous development and modernization throughout its lifetime. The question then—and the theme of the talk—is what changes do we need to make to Emacs? Much of what he has to say will probably ruffle some feathers or at least be controversial but whether you agree or not his arguments are well-formed and I found them cogent.

One of Metzger’s major points is that whatever we do, it must be done incrementally. One of the problems that every proposal for significant rewrites of Emacs has to face is the fact of the huge amount of existing code written for the Emacs ecosystem (Org-mode alone is 120K lines of code). That implies, for example, that implementing a new extension language means that it must interoperate seamlessly with Elisp and use the same run-time system.

Metzger’s summary at the end of the talk lists what he thinks the most important issues are:

• HTML rendering
• LSP support built into Emacs
• Modern email and PIM support
• A safe concurrency model
• A new extension language

The body of the talk builds the case for each of these changes and discusses how they might be achieved.

In a second video, Metzger takes questions on the talk. The questions are also worthwhile and expand on the talk. The two videos are 58 minutes and 23 minutes long so you’ll definitely need to set some time aside but if you care about Emacs this is an essential talk. The slides from the talk are also available.

The College of Engineering at Carnegie Mellon has an interesting article on their Web site about John Kitchin and his work on Scimax. I’ve written about Scimax several times (1, 2, 3, 4, 5, 6, 7) so longtime Irreal readers will be familiar with it. If you’re new to Scimax, it’s a package of Emacs applications to make writing scientific papers easier and, in particular, to enable reproducible research: Here’s Kitchin’s Web page on the package.

The CMU article mentions several of Irreal’s favorite topics: Emacs, Org-mode, Writing with Emacs, and reproducible research. In the article, Kitchin makes the point that if your research can’t be verified, no one can tell if it’s the truth or not. Without reproducibility, anyone can say anything and you have to take them at their word. Kitchin says that the point of Scimax is not just to make writing papers easier but to increase the level of research integrity by making its results replicable.

EmacsConf 2019 videos now out! (Reddit) – Videos, Invidio.us, Youtube

• Emacs configuration:
  • my-site-start/README.md at master · tripleee/my-site-start · GitHub
  • use-package-secrets: :secret keyword for use-package
  • Overview of better-defaults package for Emacs (9:01)
  • upm: �� Universal Package Manager – Python, Node.js, Ruby, Emacs Lisp.
  • Here’s the simplified mental view of Emacs keymap precedence I’ve come up with. How accurate is it?
• Emacs Lisp:
  • Emacs Lisp Challenge: flaky-if (Reddit)
• Emacs development:
  • Very long discussion about the difficulty of reporting or reopening bugs
  • Irreal: Emacs 27.1 Coming
  • Use new macro debounce-reduce to make mouse scaling of images more responsive
  • Default network-stream-use-client-certificates to nil
  • Have what-cursor-position optionally show character name
  • help-follow-symbol now complains if no symbol found (bug#38248)
  • * lisp/minibuffer.el (completions-common-part): Make it blue when possible
  • Support ‘vc-region-history’ for Mercurial
  • * etc/NEWS: Improve XDG_RUNTIME_DIR doc.
  • Add renaming of remote buffer file names to Tramp
• Appearance:
  • Selecting and trying out different fonts in Emacs (Reddit)
• Navigation:
  • Alvaro Ramirez: Emacs counsel default search switches
  • Jumping to files via hotkeys
• Org Mode:
  • Learning Org-mode with no experience whatsoever. Help?
  • Weekly /r/Orgmode Open Discussion – November 22, 2019
  • My org-mode workflow for studies.
  • Using orgmode to keep track of movies, tvshows and books?
  • org-sticky-header: Show off-screen Org heading at top of window (Reddit)
  • Automatic fragment toggling in org-mode (Reddit)
  • Is there a way to include an org file in another one and have the contents update in real time?
  • Introduction to “organice” – Using Org mode from the browser and smartphone – YouTube
  • Grasp: How to capture information from your browser and stay sane
  • Consistent Technical Documents Using Emacs and Org Mode (HN, previous Reddit)
  • ob-xslt: Org babel extension to apply xslt templates to xml source blocks or source block results.
  • org-recoll: A lightweight org-mode wrapper for the recoll full-text search engine
• Coding:
  • Effective “git blame” in Emacs (Reddit)
  • Mike Zamansky: Using Emacs 62 Magit Forge
  • Chen Bin (redguardtoo): Yin and Yang in Emacs – partial git blame with vc or magit
  • Using Plugins In Typescript Language Server · emacs-lsp/lsp-mode Wiki · GitHub
• Community:
  • Weekly tips/trick/etc/ thread
  • Emacs Meetup in San Francisco, on Saturday Nov 23, 2019 (Reddit)
  • How do you use Emacs?
  • The FSF’s EmacsConf 2019 satellite was an M-x success! — Free Software Foundation — working together for free software (Reddit)
  • Where is the emacs community?
• Other:
  • The miryoku layout is a keyboard layout in emacs for emacs. (Reddit)
  • Alvaro Ramirez: Wizard zines comics Emacs eshell util
  • Emacs Macro Tutorial: How to Record and Play
  • Chris Wellons: On-the-fly Linear Congruential Generator Using Emacs Calc
  • Emacs: Store music playlists (Dired+Bongo) (13:16)
  • A quick look at Emacs EXWM (an i3wm alternative) (17:25)
  • Una guía de referencia para Emacs – ochobitshacenunbyte
  • Moving from Vim to Emacs
  • Emacs: Fury Road (Reddit)
  • Fountain Mode
  • Getting Emacs Ready for Writin’, Part 1
• New packages:
  • anki-connect: AnkiConnect API
  • brazilian-holidays: Brazilian holidays
  • global-tags: Elisp API and editor integration for GNU global
  • org-working-set: Manage a working-set of org-nodes
  • uml-mode: Minor mode for ascii uml sequence diagrams
  • vdf-mode: Major mode for editing Valve VDF files.

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, Hacker News, planet.emacslife.com, YouTube, the Emacs NEWS file and emacs-devel.

Eli Zaretskii has issued what amounts to a last call for new features to appear in Emacs 27.1. He’s planning to create an Emacs-27 release branch in about a week. After that, only bug fixes for the release will be accepted.

There’s still a lot of testing and release candidates to be done, of course, but we’re getting close.

I joined the fediverse in early 2017. If you haven't heard of it, it's a distributed network providing social media type features without any one centralized authority. Users are in control of their data, and anyone can run their own servers with their own rules, including the ability to block all traffic from other servers if they tolerate abusive behavior, etc.

It took me a while to get to the point where I was comfortable on the Fediverse. I created an account on the oddly-named icosahedron.website in April, but it didn't stick immediately. It didn't feel like there was much going on because I hadn't found that many users to follow. After a few months of poking my head around, clicking around a bit, and then forgetting about it for another few weeks, I finally got enough momentum for it to be a compelling place for me, and by November I stopped using my Twitter account altogether. I had felt since the 2016 US election that Twitter had spiraled into a worse and worse condition; the site felt engineered to drive more and more "engagement" at the expense of human misery. So making a clean break dramatically improved my mental well-being.

Even tho it makes a few things more complicated (like finding new users to follow[1]), I deeply appreciate the emphasis on user empowerment that's inherent in the design of the fediverse. One of the cornerstones of this empowerment is the ability to run your own fediverse server, or instance. The most common fediverse server software is Mastodon, which could be considered the flagship of the fediverse. While it's very slick and full-featured, a big downside of Mastodon is that it's difficult to run your own server. Administering it requires running a Ruby on Rails application with Node.js, Postgres, Redis, Nginx, ElasticSearch, and more. For servers which serve a medium-to-large community, this overhead can be justifiable, but it requires a lot of mental energy to get started. There are a lot of places where things could go wrong.

The Pleroma project aims to reduce this by creating a dramatically simpler fediverse server. Running a Pleroma server requires just an Elixir application, a Postgres database, and Nginx to handle TLS. Since Elixir is a lot more efficient than Ruby, it's even possible to run it on a low-powered machine like a Raspberry Pi[2]. I set up my own Pleroma server a few weeks ago at hi.technomancy.us. It's running on the Pi in the photo.

One downside of Pleroma being simpler is that it's really just an API server. All your interaction in the browser goes thru a separate Javascript application called pleroma-fe, and mobile clients like Tusky just hit the JSON API. The API-first design makes sense when you're using the application to browse, post, search, etc, but a big downside is that when you want to share a post with someone else, they have to load all of pleroma-fe just to see it. If you share it with someone who has scripting turned off, then they'll just see a blank white page, which is very unfriendly[3].

I wanted to start using Pleroma, but I wasn't comfortable with this unfriendly behavior. I wanted it so that if I sent a link to a post to a friend, the server would send them the HTML of the post![4] So I took a course of action I never could have taken with a centralized, commercial social network: I fixed it myself. I found that there had been an attempt to start this 8 months ago which had more or less been forgotten, so I used that as my starting point.

Pleroma is written in Elixir, which I had never used before, but I had learned Erlang a few years ago, and many of the core concepts are the same. Since I based my work on the old initial sketch, I was able to make quick progress and add several features, like threading, media, content warnings, and more. I got some really helpful review about how to improve it and test it, and it got merged a couple weeks ago. So now you can see it in action. I'm thankful to the Pleroma developers for their helpful and welcoming attitude.

One of the reasons this is important to me is that I normally use a laptop that's a bit old. But I think it's important for software developers to keep some empathy for users who don't have the latest and greatest hardware. On my laptop, using the pleroma-fe Javascript application to view a post takes eight seconds[5] if you haven't already loaded pleroma-fe (which is the main use case for when you're sharing a link with a friend). If you have it loaded already, it's still 2-3 seconds to load in pleroma-fe. When you have the server generate the HTML, it takes between 200 and 500 milliseconds. But 500ms is nearly a worst-case scenario since it's running on a tiny Raspberry Pi server; on a high-end server it would likely be several times faster.

Running your own fediverse server is still much harder than it should be. I've glossed over the annoyances of Dynamic DNS, port forwarding, and TLS certificates. There's still a lot of opportunity for this to become better. I have a vision of a system where you could sign up for a fediverse server and it would pre-generate an SD card image with Pleroma, Postgres, and Nginx preinstalled and configured with the domain name of your choice, but right now shortcomings in typical consumer-grade routers and consumer ISPs make this impractical. But it's come a long way, and I think it's only going to get better going forward.

If you're interested in running your own fediverse server, you might find runyourown.social helpful, tho it focuses on Mastodon instead of Pleroma. If you're not interested in running your own server, check out instances.social for a listing of servers with open registration. There's never been a better time to ditch corporate social media and join the fediverse!

I’ve long been an admirer of Chris Wellons’ work and have written about him many times. I almost always learn something new and useful from his blog posts so of course I take notice when he publishes something new. His latest post is about building a linear congruential pseudo-random number generator. If you know anything at all about linear congruential PRNGs you might wonder what there is to say. Quite a bit, it turns out. Although they are very simple—just the recurrence relation \(x_{n+1} = x_{n} × C + A \bmod M\) where \(x_{0}\) is the seed—properly choosing the values of \(C\), \(A\), and \(M\) is important.

A good strategy is to choose prime numbers with certain properties for \(A\) and \(C\) and Wellons shows how easy this is to do using the excellent Calc utility built into Emacs. One of the things I learned from the post was that Calc has a function for the Miller–Rabin primality test. That’s not on the Calc Cheat Sheet so I’d long since forgotten about it and always cranked up my own Scheme version when I needed to check for the primality of large numbers. Having it available in Calc is a big win, especially since I’m probably making the calculations in Calc anyway.

Like all of Wellons’ posts this one is interesting and instructive and definitely worth your time.

Mike Zamansky has posted another great video in his Using Emacs Series. This video takes a look at Magit Forge. It’s available from Melpa and is easy to install. Zamansky shows how easy in the video.

Once installed, it just becomes part of the Magit status panel. From there you can make and respond to GitHub—or other Git Forges, such as GitLab—pull requests from the comfort of Emacs. Zamansky demonstrates making and responding to the PR from Emacs and from GitHub. The only thing he couldn’t do from Emacs was to merge code from the PR into the Master branch.

The video is just shy of 18 minutes so you’ll need to schedule some time but it’s definitely worth a few minutes to watch the video.

UPDATE [2019-11-19 Tue 20:50]: Tarsius provides a pointer to a reddit post on why there is no dedicated merge-pull-request.

I regularly make throwaway “projects” and do a surprising amount of programming in /tmp. For Emacs Lisp, the equivalent is the *scratch* buffer. These are places where I can make a mess, and the mess usually gets cleaned up before it becomes a problem. A lot of my established projects (ex.) start out in volatile storage and only graduate to more permanent storage once the concept has proven itself.

Throughout my whole career, this sort of throwaway experimentation has been an important part of my personal growth, and I try to encourage it in others. Even if the idea I’m trying doesn’t pan out, I usually learn something new, and occasionally it translates into an article here.

I also enjoy small programming challenges. One of the most abused tools in my mental toolbox is the Monte Carlo method, and I readily apply it to solve toy problems. Even beyond this, random number generators are frequently a useful tool (1, 2), so I find myself reaching for one all the time.

Virtually every programming language comes with a pseudo-random number generation function or library. Unfortunately the language standard PRNG often not ideal for my purposes. It’s probably not high quality, slower than it needs to be (also), lacks reliable semantics or behavior between implementations, or is missing some other property I want. So I’ve long been a fan of BYOPRNG: Bring Your Own Pseudo-random Number Generator. Just embed a generator with the desired properties directly into the program. The best non-cryptographic PRNGs today are tiny and exceptionally friendly to embedding. Though, depending on what you’re doing, you might need to be creative about seeding.

Crafting a PRNG

On occasion I don’t have an established, embeddable PRNG in reach, and I have yet to commit xoshiro256** to memory. Or maybe I want to use a totally unique PRNG for a particular project. In these cases I make one up. With just a bit of know-how it’s not too difficult.

Probably the easiest decent PRNG to code from scratch is the venerable Linear Congruential Generator (LCG). It’s a simple recurrence relation:

x[1] = (x[0] * A + C) % M

That’s trivial to remember once you know the details. You only need to choose appropriate values for A, C, and M. Done correctly, it will be a full-period generator — a generator that visits a permutation of each of the numbers between 0 and M - 1. The seed — the value of x[0] — is chooses a starting position in this (looping) permutation.

M has a natural, obvious choice: a power of two matching the range of operands, such as 2^32 or 2^64. With this the modulo operation is free as a natural side effect of the computer architecture.

Choosing C also isn’t difficult. It must be co-prime with M, and since M is a power of two, any odd number is valid. Even 1. In theory choosing a small value like 1 is faster since the compiler won’t need to embed a large integer in the code, but this difference doesn’t show up in any micro-benchmarks I tried. If you want a cool, unique generator, then choose a large random integer. More on that below.

The tricky value is A, and getting it right is the linchpin of the whole LCG. It must be coprime with M (i.e. not even), and, for a full-period generator, A-1 must be divisible by four. For better results, A-1 should not be divisible by 8. A good choice is a prime number that satisfies these properties.

If your operands are 64-bit integers, or larger, how are you going to generate a prime number?

Primes from Emacs Calc

Emacs Calc can solve this problem. I’ve noted before how featureful it is. It has arbitrary precision, random number generation, and primality testing. It’s everything we need to choose A. (In fact, this is nearly identical to the process I used to implement RSA.) For this example I’m going to generate a 64-bit LCG for the C programming language, but it’s easy to use whatever width you like and mostly whatever language you like. If you wanted a minimal standard 128-bit LCG, this will still work.

Start by opening up Calc with M-x calc, then:

1. Push 2 on the stack
2. Push 64 on the stack
3. Press ^, computing 2^64 and pushing it on the stack
4. Press k r to generate a random number in this range
5. Press d r 16 to switch to hexadecimal display
6. Press k n to find the next prime following the random value
7. Repeat step 6 until you get a number that ends with 5 or D
8. Press k p a few times to avoid false positives.

What’s left on the stack is your A! If you want a random value for C, you can follow a similar process. Heck, make it prime, too!

The reason for using hexadecimal (step 5) and looking for 5 or D (step 7) is that such numbers satisfy both of the important properties for A-1.

Calc doesn’t try to factor your random integer. Instead it uses the Miller–Rabin primality test, a probabilistic test that, itself, requires random numbers. It has false positives but no false negatives. The false positives can be mitigated by repeating the test multiple times, hence step 8.

Trying this all out right now, I got this implementation (in C):

uint64_t lcg1(void)
{
    static uint64_t s = 0;
    s = s*UINT64_C(0x7c3c3267d015ceb5) + UINT64_C(0x24bd2d95276253a9);
    return s;
}

However, we can still do a little better. Outputting the entire state doesn’t have great results, so instead it’s better to create a truncated LCG and only return some portion of the most significant bits.

uint32_t lcg2(void)
{
    static uint64_t s = 0;
    s = s*UINT64_C(0x7c3c3267d015ceb5) + UINT64_C(0x24bd2d95276253a9);
    return s >> 32;
}

This won’t quite pass BigCrush in 64-bit form, but the results are pretty reasonable for most purposes.

But we can still do better without needing to remember much more than this.

Appending permutation

A Permuted Congruential Generator (PCG) is really just a truncated LCG with a permutation applied to its output. Like LCGs themselves, there are arbitrarily many variations. The “official” implementation has a data-dependent shift, for which I can never remember the details. Fortunately a couple of simple, easy to remember transformations is sufficient. Basically anything I used while prospecting for hash functions. I love xorshifts, so lets add one of those:

uint32_t pcg1(void)
{
    static uint64_t s = 0;
    s = s*UINT64_C(0x7c3c3267d015ceb5) + UINT64_C(0x24bd2d95276253a9);
    uint32_t r = s >> 32;
    r ^= r >> 16;
    return r;
}

This is a big improvement, but it still fails one BigCrush test. As they say, when xorshift isn’t enough, use xorshift-multiply! Below I generated a 32-bit prime for the multiply, but any odd integer is a valid permutation.

uint32_t pcg2(void)
{
    static uint64_t s = 0;
    s = s*UINT64_C(0x7c3c3267d015ceb5) + UINT64_C(0x24bd2d95276253a9);
    uint32_t r = s >> 32;
    r ^= r >> 16;
    r *= UINT32_C(0x60857ba9);
    return r;
}

This passes BigCrush, and I can reliably build a new one entirely from scratch using Calc any time I need it.

Bonus: Adapting to other languages

Sometimes it’s not so straightforward to adapt this technique to other languages. For example, JavaScript has limited support for 32-bit integer operations (enough for a poor 32-bit LCG) and no 64-bit integer operations. Though BigInt is now a thing, and should make a great 96- or 128-bit LCG easy to build.

function lcg(seed) {
    let s = BigInt(seed);
    return function() {
        s *= 0xef725caa331524261b9646cdn;
        s += 0x213734f2c0c27c292d814385n;
        s &= 0xffffffffffffffffffffffffn;
        return Number(s >> 64n);
    }
}

Java doesn’t have unsigned integers, so how could you build the above PCG in Java? Easy! First, remember is that Java has two’s complement semantics, including wrap around, and that two’s complement doesn’t care about unsigned or signed for multiplication (or addition, or subtraction). The result is identical. Second, the oft-forgotten >>> operator does an unsigned right shift. With these two tips:

long s = 0;

int pcg2() {
    s = s*0x7c3c3267d015ceb5L + 0x24bd2d95276253a9L;
    int r = (int)(s >>> 32);
    r ^= r >>> 16;
    r *= 0x60857ba9;
    return r;
}

So, in addition to the Calc step list above, you may need to know some of the finer details of your target language.

• Emacs configuration:
  • Emacs configuration file
  • Best way to store init.el citations for long-term?
• Emacs Lisp:
  • Emacs is amazing – story about modifying pdf-view behavior
  • Is there a code challenge resource for elisp?
• Emacs development:
  • time-stamp: update support for time zone numeric offset
  • * lisp/dired.el (dired-dwim-target): Add new choices (bug#35385)
• Appearance:
  • highlight-indentation-mode: Highlighting indentation for Emacs
  • ThemeCreator: create themes for intellij, textmate, atom, emacs, vim and gnome terminal.
  • herald-the-mode-line.el: Show the modeline in the minibuffer
  • Emacs mode for hiding the mode-line · Bastien Guerry – Liberté, informatique, choucroute.
  • darkplus-emacs: VS Code’s Dark+ theme for Emacs
• Navigation:
  • Projects – Projectile: The Project Interaction Library for Emacs
  • Manuel Uberti: At the helm of my configuration
• Org Mode:
  • Org-mode and a Reading Schedule
  • Embedding Youtube videos with org-mode links · Endless Parentheses
  • Ricing up Org Mode (Reddit)
  • Using Emacs 61 – org-msg (Reddit)
  • public voit: UOMF: Linking Org mode Headings (my workflow and best practice)
  • All Things Org Mode: PIM, Scientific Writing, Presentation, Programming
  • Running SQL on org-mode tables
  • Self-contained Org files (Reddit)
  • org-html-sass: Template for org-mode HTML export that uses Compass/Sass for styling
  • Consistent Technical Documents Using Emacs and Org Mode (Reddit, Irreal)
  • Send your Garmin activities to OrgMode (Reddit)
  • ob-restclient.el: An org-mode extension to restclient.el
  • Have some code: make ediffing folded org files better
  • Release v1.8 · orgzly/orgzly-android · GitHub
  • Org-mode related ResearchGate Publications (Reddit)
  • An Effective Git And Org-Mode Based Workflow For Reproducible Research | ACM Digital Library
  • Mi entorno de trabajo en Emacs
• Coding:
  • Trying to make the switch from Pycharm
  • Can anyone please suggest a good setup for lsp-mode for Angular development?
  • pest-mode.el — Major mode for editing Pest files
  • Wrote a flycheck checker for standardrb
  • counsel-etags 1.9.0 is out | Chen’s blog (Reddit)
  • Remote Debugging With Tramp
  • Smart Dash: Use dash key to insert an underscore within C identifiers and a dash otherwise.
  • Version control:
    • List Commits to Dired-Marked Files
    • Emacs is the best merge tool for Git (Reddit)
    • github-agent: Sync issues to your local directory as a git repo
    • Using GitHub issues to communicate with your students
• Community:
  • Weekly tips/trick/etc/ thread
  • Paris meetup – 19 Oct 2019 – Come on !
  • Which annoyances would you hope to fix one day?!
  • linuxdatabases – EmacsConf 2019
  • The history of Emacs – primary and secondary source materials (Software Preservation Group)
  • Symbolics Lisp Machine Summary, 3600 Edition (PDF) (Reddit)
• Other:
  • spray: an elisp implementation of OpenSpritz, a speedreader.
  • Managing bibliographies from Emacs (v2)
  • Writing with Emacs: Tips, Examples, and Resources for Writing with Emacs (Reddit)
  • Diffing buffer fragments – diffing last two entries in kill ring, also continued
  • maccadet: Use all of Emacs modifiers on macOS with various keyboards.
• New packages:
  • company-stan: A company-mode completion backend for stan
  • eldoc-stan: Eldoc support for stan functions
  • flycheck-stan: Add Stan support for Flycheck

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, Hacker News, planet.emacslife.com, YouTube, the Emacs NEWS file and emacs-devel.

Mike Hamrick has put up an excellent video on using Emacs and Org-mode to publish nice looking and consistent technical documents. In preparing a document, Hamrick uses literate programming and—although he doesn’t mention it—reproducible research techniques. That’s important, because as he notes, if the code or data used in the document changes, things that depend on that code or data will change as well and it’s important to keep them in sync.

This is exactly the problem—or at least one of the problems—that Org-mode’s Babel was designed to solve. By having Babel embed the results of running the document’s code against its data into the document itself, you’re guaranteed that everything will stay consistent.

Hamrick has a few tricks that he uses to get a nice looking document and keep it consistent. For HTML, he uses Fabrice Niessen’s ReadTheOrg theme, which I’ve written about before, to produce beautiful HTML documents. The other trick he uses that I really liked is to have a file of helper functions that he can call from the text he’s writing. These do things like return the length of a string or the first 2 characters of a string. By using them, he ensures that his document remains consistent even if the data the string is from changes.

Don’t worry about trying to absorb the source code from the video. He’s put all the code and data for the video on GitLab. Similarly, his configuration files are on GitLab so you can see his publishing setup.

The video is 22 minutes, 42 seconds long so you’ll need to block out some time but it’s very much worth it. If you use Org-mode in your writing, you really need to watch this video.

Mike Zamansky has another video up in his Using Emacs Series. This time he looks at writing mu4e emails in Org-mode. Like me, he mostly wants to send plain text emails but sometimes he’d like to send tables, source code, or other rich text. He tried using the built-in org-mu4e-compose-org-mode but it’s deprecated and didn’t do everything he wanted. I’ve had the same experience. I tried org-mu4e-compose-org-mode but it didn’t do many of the things I cared about so I stopped using it.

Happily, Zamansky has found another solution: org-msg. It does a much better job of allowing you to use Org markup in your emails and rendering the results nicely. Of course, to do that it sends your mail as HTML so if you don’t like that, org-msg is not for you.

Take a look at Zamansky’s video to see both org-mu4e-compose-org-mode and org-msg in action. You can see right away why org-msg is the superior solution. In addition to its better rendering, org-msg is more configurable. You can, for example, set it to automatically add a signature or to extract the sender’s name from an email you’re replying to and use it to add a salutation.

If you’ve been looking for a way to use Org-mode with mu4e, be sure to spend a few minutes to watch this video. The video is just short of 15 minutes so it should be easy to find some time for it.

It was a cold winter back in December 2014. If memory serves me well, it was time spent at tinkering with old hardware and obscure window managers, reading my first books on functional programming, and dealing with something about text editors I can’t quite put my finger on.

I was also reading about Helm and the praises everywhere in the Emacs community for this package: it can do this, it improves that, it will take you closer to Emacs Nirvana. So yeah, I believed the hype, because it came from trusted sources, especially the Nirvana-guy. Soon Helm took over my configuration and I was using it for everything: switching buffers, selecting bookmarks, in-buffer and per-project searches. Anything involving candidates completion was in the wise hands of Helm.

After a while Ivy came along, and the rest is history. I have been using Ivy/Counsel for such a long a time I might as well say they have become the central drivers of my Emacs setup. Along with the likes of counsel-projectile, these are the packages I use the most during the day.

Lately I’ve been following some conversations about completion-styles, and when I learned that Thierry Volpiatto was working on leveraging Helm for this I just could not resist. Note that Thierry is still devising the implementation, so there is no need to rush at opening issues and scream at him. Anyway, Helm was back in my radar now, and so I took the chance to see if I could come up with a setup which would mirror my everyday workflow with Ivy/Counsel.

I immediately noticed that the theme I use lacked proper support for some Helm faces, but nothing stopped me to do something about it. Much like Ivy/Counsel, Helm provides its own version for common operations such as helm-M-x, helm-find-files, helm-mini, helm-recentf, helm-bookmarks, helm-show-kill-ring, and helm-resume. These are the core features for me, and they work as expected. I also enabled helm-adaptive-mode and helm-autoresize-mode, fixing the Helm window height to my preferences.

As I did with Ivy/Counsel, I made buffer switching (i.e., helm-mini) ignore some files:

(require 'helm-buffers)
(setq helm-ff-skip-boring-files t)
(dolist (regexp '("\\`\\*direnv" "\\`\\*straight" "\\`\\*xref"))
  (cl-pushnew regexp helm-boring-buffer-regexp-list))

My projects are all Git-versioned, hence I installed helm-ls-git, which superseded Projectile and the related helm-projectile in an instant. In order to make per-project lookups with Helm as easy as they were with Ivy/Counsel, I went with helm-ag and helm-xref. To make it even better, I added psession and configured it to persist the things I need from my Emacs sessions. The only goodies I put on top of this setup are helm-bibtex and helm-tramp.

Back in the day, Helm felt heavier and more bloated than Ivy/Counsel, but that is nonsense and was probably due to me being still young and inexperienced at Emacs tweaking. In fact, it still takes less than one second for my Emacs to boot, and so far there is nothing in terms of functionalities I have been missing from my previous configuration. We could argue about UI minimalism and design choices as long as we want, or we could simply try what the Emacs ecosystem offers and decide for ourselves what suits our text editor best.

Perhaps because I’ve always worked for smaller organizations, I’ve never had to deal with Gantt charts. I’ve always considered them yet another management fad but that may be due to ignorant prejudice. In any event, lots of people use them and find them useful.

The other day I saw a pointer to a recent video on generating Gantt charts with Org-mode. It turns out to be pretty easy. Once you get the start and end dates into an Org table it’s just a matter of invoking a bit of gnuplot code from a source block to generate the chart.

As I said, I don’t have much interest in Gantt charts but I do like reading about leveraging Org-mode to accomplish tasks that used to take dedicated applications. The video is 13 minutes, 11 seconds so it should be easy to fit it in. It’s worth taking a look at if only to see how versatile Org-mode and Emacs can be.

Recently, James Gill tweeted about a collection of Emacs resources for writers that he’s curated into a GitHub repository. There are two parts to the collection:

1. Tips and examples for writing with Emacs, and
2. Writing a book with Emacs.

As you’d expect, most of the articles are about leveraging Org-mode for writing. That’s no surprise, of course, because Org excels at that. Indeed, almost any type of writing from memos or blog posts—such as Irreal’s—to journal articles or books is easily accomplished with Org. I’ve reached the point were virtually everything I write is done with Org-mode.

Sadly, the literary writing market runs on Word so if that’s your niche, you’re going to have to deal with conversion. Org, of course, has built in tools for that and if those don’t meet your needs, the excellent Pandoc almost certainly will.

If you’re a writer who’d like to escape from the pain that is Word and give Emacs a try, be sure to read the articles in Gill’s list. I’ve discussed several of them in Irreal previously but a few are new to me. A handful of the resources are videos but most are short blog posts or articles that are easy and quick to read.

It’s not always obvious how to use Emacs for writing effectively so the articles and videos collected by Gill, which distill a lot of hard won wisdom, can be a real help.

Matt Ray gave a very nice presentation to EmacsConf 2019 on Interactive Remote Debugging and Development with TRAMP Mode. One of the frequent complaints about Emacs is that it’s hard to work with remote files. Mostly that’s because the person complaining doesn’t know about Tramp. There are, of course, some situations where Tramp is not the best solution but it’s usually an excellent way of working with remote files.

It’s easy to think of Tramp simply as a way of editing remote files but it’s actually much more powerful than that. Ray demonstrates some of that power first by using Tramp to open a shell on a remote system and then by showing how he uses it to work with virtual machines on his own workstation. He uses the freely available tools Chef, Vagrant, and Kitchen to spin up a virtual instance of Debian and work with it all from the comfort of Emacs.

Even command-line aficionados will enjoy his video because although he stays in Emacs, he does a lot of the work using the shell command. He begins the video by showing why using the shell from Emacs can be a win over firing up a separate terminal. During the rest of the presentation, he just opens a shell on the remote machine—or virtual machine—when he needs to make a change to the remote environment.

The video is about 35 and half minutes so you’ll probably have to schedule some time but I found it worth the time.

• Emacs configuration:
  • Grant Rettke: Some Pretty Good Configuration Options To Copy
  • Marcin Borkowski: Starting Emacs with custom configuration directory
  • Configuring Emacs from Scratch — Intro – Suvrat Apte – Medium
  • mrbig033’s Emacs & i3 config files
  • .emacs golf
  • Standard Emacs keybindings vs Personal keybindings
  • armacs: An Emacs based distribution to help novice users learn emacs and configure it themselves.
  • Who never heard about the desktop-save-mode?
• Emacs Lisp:
  • find-local-executable: Find locally installed executables by npm, composer, gem, pip, stack, …
  • emacs lisp live coding + tutorial, open-buffer-in-firefox, open-link-in-firefox, typing speed test (1:37:25)
• Emacs development:
  • Long discussion re: VOTE: Changing completions-common-part face’s default
  • Move read-char-from-minibuffer from simple.el to subr.el and document it.
  • hack-local-variables-confirm uses the minibuffer to read answer (bug#38076)
  • ‘y-or-n-p’ now uses the minibuffer to read ‘y’ or ‘n’ answer (bug#38076)
  • Run scroll/recenter commands from minibuffer in original window (bug#38076)
  • CC Mode. Allow fontification of “wrong” style comments with warning face.
  • python.el: Pdbtracking improvements
  • * lisp/dired-aux.el (dired-vc-rename-file): New defcustom.
  • Make ‘g’ refresh package data in package menu
  • Rename *-multiframe-window to *-window-any-frame
  • Add prefix arg to more isearch commands (bug#14563)
  • Document fido-mode
  • Always check for client-certificates
  • Overflow errors are range errors
• Appearance:
  • Amit’s Thoughts: Emacs: prettier tabbar
  • How to use FiraCode on Emacs
  • column-enforce-mode: Highlight text that extends beyond a certain column. Can be used to enforce 80 column rule (well more like suggest, not enforce)
  • Font size and Zooming · Clojure development with Spacemacs & Cider
• Navigation:
  • projectile-extras: A few extra functions for projectile
• Org Mode:
  • org2blog v1.1.0 “Inky Hand” is out
  • Emacs packages: org-sticky-header
  • Python-library “orgformat” with utility functions for generating Org mode syntax elements
  • Non-programmers who make heavy use of org-mode for information and task management: what apps/programs do use to complement org-mode?
  • Lazyblorg Now Links Larger Images
  • UOMF: On How to Define Projects in Org Mode
  • Literate Programming with Org Mode (1:48:21)
  • GANTT Chart in Emacs (13:12)
• Coding:
  • Wip Modes (Magit User Manual)
  • emacs-multi-compile: Multi target interface to compile.
  • sqlcmdline: ODBC-based command line querying, with Emacs sqli-mode in mind.
  • Indium — Indium 2.1.4 documentation
  • The lsp-mode multirepo->monorepo movement
  • Magit and Forge for Issuing Pull Requests from Emacs · Emacs Doomcasts 20 (Reddit)
  • What diagramming tools besides Graphviz are there for emacs?
  • EmacsConf 2019: Interactive Remote Development and Debugging with TRAMP (35:25)
  • Commanding Emacs from Coq (14:34)
• Community:
  • Richard Stallman Answers Your Questions (ca. 2013) – Slashdot
  • Raimon Grau: Emacsconf 2019!
  • My Thoughts on EmacsConf 2019
  • Weekly tips/trick/etc/ thread
  • When you press Ctrl-y in your browser and nothing happens…
• Other:
  • Emacs and Windows Subsystem for Linux
  • IEEE Journals & Magazine: The design and evaluation of online help for Unix EMACS: capturing the user in menu design
  • Emacs in Termux: Termux + Emacs + Tab S6 + Lisp (Reddit)
  • {HOWTO} Installing Emacs 26.3 on Ubuntu or XUbuntu 19.04 – The Lone C++ Coder’s Blog
  • EmacsCast 10: Obsession, small tweaks and Hyper key (Reddit)
  • kindle-highlight-parser: Parse the highlights file from your Kindle and display it in JSON or Markdown
  • BreakPoint › Emacs and Hunspell on MS Windows for Beginners
  • Is there any way I can integrate emacs with Grammarly (writing tool)?
  • Using the Emacs Deft package for topic journals – Jack Baty’s weblog (Reddit)
  • dired-rsync 0.5 released (Reddit)
• New package:
  • bluetooth: A Major mode for Bluetooth devices

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, r/planetemacs, Hacker News, planet.emacslife.com, YouTube, the Emacs NEWS file and emacs-devel.

Via Wilfred Huges we have this useful tip:

Uhm. No, I didn’t. https://t.co/eUQesn9ACk

— Jonas Bernoulli (@magit_emacs) November 9, 2019

Apparently, it’s not widely known.

I just tried it—I’m running dired+—and it worked perfectly. It’s easy to see how the magit-dired-log command could be very useful.

If you’ve been running from MELPA you will have had all these features already but it was certainly overdue a stable tagging. The commit history shows a lot of faffing around getting the CI working again. However there are a bunch of customisation tweaks exposed as well as support for remote-to-remote rsync support (with a very ugly port-forward hack). From the NEWS file:

• Big CI clean-ups (dropped emake, added Cask)
• smarter modeline status (show R:n% when one job running)
• make dired-rsync process dest with expand-file-name
• we now support remote to remote with an ugly port forward hack
• prompt the user for a passphrase if we detect stall in process
• add some basic ert tests
• new customisation option dired-rsync-source-files
• new customisation hook dired-rsync-failed-hook

Happy file syncing

Karl Voit has an interesting post in which he explores ways of defining projects in Org-mode. Note that by “project” Voit doesn’t mean the type of object handled by an app such as Projectile, but a set of tasks meant to achieve a common goal. If you’re like me, the answer seems obvious: add a project tag to the header defining the project.

Of course, things aren’t that simple, especially for someone like Voit who on the one hand has exacting standards for how things should appear in, say, his agenda but on the other hand wants very fluid Org files. By “fluid” I mean that projects aren’t necessarily top level items or even second level items. They can appear anywhere in the tree. I’m inclined to be more rigid in my Org file layout so I avoid some of the problems that Voit has.

Voit discusses several possibilities along with their pros and cons. I’ll let you read his post to see what solution he finally settled on. If you’re trying to impose a project structure on top of Org, it’s definitely worth taking a look at his discussion.