The Emacs Cat

Emacs, Software Development, and LLM

Wed, 04 Mar 2026 09:16:11 +0100

Part 1. Emacs and Software Development

Just a couple of days ago, I published on GitHub my first open-source project, the TEC library, a lightweight and fast C++ framework designed for efficient performance in resource-constrained concurrent environments.

This project marks an important milestone for me as a die-hard Emacs user because the entire development was carried out completely in Emacs without using any specialized IDE.

The following Emacs packages and tools were used:

Writing code: eglot for code completion, built-in ibuffer for buffer grouping and navigation, and imenu-list for code navigation in the current buffer (see my post on C++ Programming in Emacs).
Keeping notes, ideas, ToDo lists, and any project-related textual information in Org Mode.
Debugging with dap-mode.
Testing samples with tracing output in Eshell.
Writing various Markdown documents for publishing on GitHub.
Many other things, like planning in Agenda.

This has proved that it is possible to effectively manage all the stages of the software development process without leaving Emacs. I’m really happy with that.

Part 2. Software Development and LLM

My TEC project announcement at Reddit’s r/cpp has been rejected.

The reason: the entire project is LLM-generated.

No doubt, I was using an LLM to generate detailed Doxygen comments in my existing manually written C++ code for the following reasons: 1) I’m too lazy to write such detailed comments; 2) I’m sure that the API documentation should be as detailed as possible because it will be used by other people, not just me.

I thought it would be obvious that the source code is manually crafted—the repository contains 124 commits since 2022 (before the LLM epoch) with all my mistakes, bugs, and rejected ideas that anyone can trace easily—and it should be clear that no LLM has been used.

I was wrong. The entire project, including the source code, is an LLM slop, they say.

I’m afraid this situation entails unpleasant consequences and raises serious questions.

Should developers now prove that their code is not LLM-generated? In what way?

LLMs can—and do—get trained on public repositories. How can someone prove that their code is manually crafted if an LLM has already been trained on it?

We are living in tough times.

— The Emacs Cat.

My Emacs IBuffer Configuration

Thu, 28 Aug 2025 15:11:15 +0100

I recently came across a Reddit post titled How to group buffers that are important to visit later which discusses various methods for buffer grouping in Emacs.

In the comments, which are typically engaging, some users mentioned using the built-in bookmarks package, while others recommended the easysession package or alternative approaches for effective buffer grouping.

Additionally, there were mentions of the built-in ibuffer package, which I personally use for buffer grouping. In this post, I’ll share my IBuffer configuration to demonstrate how I leverage it for this purpose.

Some ideas in my configuration are inspired by an excellent post, GNU Emacs configuration by Protesilaos Stavrou, a renowned Emacs expert. All of his posts are well worth reading for their insightful and practical Emacs advice.

Prettifying the IBuffer Window

To make my IBuffer window visually appealing, I use an icon set provided by the external all-the-icons-ibuffer package.

;; Prerequisites
(use-package all-the-icons-ibuffer :ensure t
  :hook (ibuffer-mode . all-the-icons-ibuffer-mode))

IBuffer Configuration

(use-package ibuffer :ensure nil
  :config
  (setq ibuffer-expert t)
  (setq ibuffer-display-summary nil)
  (setq ibuffer-use-other-window nil)
  (setq ibuffer-show-empty-filter-groups nil)
  (setq ibuffer-default-sorting-mode 'filename/process)
  (setq ibuffer-title-face 'font-lock-doc-face)
  (setq ibuffer-use-header-line t)
  (setq ibuffer-default-shrink-to-minimum-size nil)
  (setq ibuffer-formats
        '((mark modified read-only locked " "
                (name 30 30 :left :elide)
                " "
                (size 9 -1 :right)
                " "
                (mode 16 16 :left :elide)
                " " filename-and-process)
          (mark " "
                (name 16 -1)
                " " filename)))
  (setq ibuffer-saved-filter-groups
        '(("Main"
           ("Directories" (mode . dired-mode))
           ("C++" (or
                   (mode . c++-mode)
                   (mode . c++-ts-mode)
                   (mode . c-mode)
                   (mode . c-ts-mode)
                   (mode . c-or-c++-ts-mode)))
           ("Python" (or
                      (mode . python-ts-mode)
                      (mode . c-mode)
                      (mode . python-mode)))
           ("Build" (or
                     (mode . make-mode)
                     (mode . makefile-gmake-mode)
                     (name . "^Makefile$")
                     (mode . change-log-mode)))
           ("Scripts" (or
                       (mode . shell-script-mode)
                       (mode . shell-mode)
                       (mode . sh-mode)
                       (mode . lua-mode)
                       (mode . bat-mode)))
           ("Config" (or
                      (mode . conf-mode)
                      (mode . conf-toml-mode)
                      (mode . toml-ts-mode)
                      (mode . conf-windows-mode)
                      (name . "^\\.clangd$")
                      (name . "^\\.gitignore$")
                      (name . "^Doxyfile$")
                      (name . "^config\\.toml$")
                      (mode . yaml-mode)))
           ("Web" (or
                   (mode . mhtml-mode)
                   (mode . html-mode)
                   (mode . web-mode)
                   (mode . nxml-mode)))
           ("CSS" (or
                   (mode . css-mode)
                   (mode . sass-mode)))
           ("JS" (or
                  (mode . js-mode)
                  (mode . rjsx-mode)))
           ("Markup" (or
                   (mode . markdown-mode)
                   (mode . adoc-mode)))
           ("Org" (mode . org-mode))
           ("LaTeX" (name . "\.tex$"))
           ("Magit" (or
                     (mode . magit-blame-mode)
                     (mode . magit-cherry-mode)
                     (mode . magit-diff-mode)
                     (mode . magit-log-mode)
                     (mode . magit-process-mode)
                     (mode . magit-status-mode)))
           ("Apps" (or
                    (mode . elfeed-search-mode)
                    (mode . elfeed-show-mode)))
           ("Fundamental" (or
                           (mode . fundamental-mode)
                           (mode . text-mode)))
           ("Emacs" (or
                     (mode . emacs-lisp-mode)
                     (name . "^\\*Help\\*$")
                     (name . "^\\*Custom.*")
                     (name . "^\\*Org Agenda\\*$")
                     (name . "^\\*info\\*$")
                     (name . "^\\*scratch\\*$")
                     (name . "^\\*Backtrace\\*$")
                     (name . "^\\*Messages\\*$"))))))
  :hook
  (ibuffer-mode . (lambda ()
                    (ibuffer-switch-to-saved-filter-groups "Main")))
)

IBuffer. Click or tap to view the full-size picture.

Since I use the ibuffer command frequently, I’ve bound it to the <F5> key for quick access.

(global-set-key [(f5)]  #'ibuffer)

Casual IBuffer

Another valuable resource for enhancing IBuffer is the Casual project, a suite of excellent Emacs packages developed by Charles Choi. As outlined in the Casual User Guide, its goals are to provide a keyboard-driven menu UI toolkit for common Emacs commands, to enable casual discovery and use of infrequently used commands, and to serve as a frequently used interface for supported modes.

The Casual IBuffer package specifically provides an intuitive user interface for Emacs IBuffer, enhancing its functionality and ease of use.

;; Requires `transient' package.
;; https://kickingvegas.github.io/casual/
(use-package casual :ensure t)

;; IBuffer
(keymap-set ibuffer-mode-map "C-o" #'casual-ibuffer-tmenu)
(keymap-set ibuffer-mode-map "F" #'casual-ibuffer-filter-tmenu)
(keymap-set ibuffer-mode-map "s" #'casual-ibuffer-sortby-tmenu)

Casual IBuffer. Click or tap to view the full-size picture.

Happy emacsing!

— The Emacs Cat.

My Emacs Org Configuration

Thu, 24 Jul 2025 10:41:06 +0100

These days, I’ve come across numerous posts and Reddit threads praising Org mode as one of the most compelling features of Emacs. There’s no doubt this is true, and I’m amazed by how many people use Emacs solely for Org-mode. As a software developer, I rely on Org every day for note-taking, maintaining my knowledge database (org-roam), agenda management (org-agenda, synchronized with beorg on my iPhone and iPad via Dropbox), and, of course, blogging.

So, I’ve decided to share my Org configuration in the hope that it will be useful to someone.

Org-mode

Org-mode is now included with Emacs, so we don’t need to install it separately—except for org-roam, which is an external package.

Common Settings

;; When at a URL, pressing the <Enter> opens the link in a browser.
(setq org-return-follows-link t)

;; To prevent M-RET splitting the line.
;; https://irreal.org/blog/?p=6297
(setq org-M-RET-may-split-line '((item . nil)))

;; To hide drawers, e.g. PROPERTIES.
(setq org-startup-folded 'fold)

Hide Emphasis Characters

From Org as a Word Processor.

;; Non-nil means font-lock should hide
;; the emphasis marker characters.
(setq org-hide-emphasis-markers t)

Keep in mind that the slash characters (and asterisks for bold, etc) are still there, but aren’t displayed.

;; Make invisible parts of Org elements appear visible.
(use-package org-appear :ensure t
  :init
  (setq org-appear-delay 0.2)
  :hook
  org-mode
)

The org-appear package is very helpful when using org-hide-emphasis-markers, as described above. Hidden element parts appear when the cursor enters an element and disappear when it leaves—with some delay.

Better List Bullets

From Org as a Word Processor.

;; Better list bullets.
(font-lock-add-keywords
 'org-mode
 '(("^ +\\([-*]\\) "
    (0 (prog1 () (compose-region (match-beginning 1) (match-end 1) "•"))))))

Replace the initial - with a Unicode bullet symbol •.

Better Header Bullets

I prefer using Unicode circled digit symbols as header bullets to indicate the header level.

(use-package org-bullets :ensure t)
(add-hook 'org-mode-hook (lambda () (org-bullets-mode 1)))
(setq org-bullets-bullet-list
  '("①" "②" "③" "④" "⑤" "⑥" "⑦" "⑧" "⑨" "⑩"))

;; Indent levels.
(add-hook 'org-mode-hook 'org-indent-mode)

;; Use this character(s) for ellipsis.
(setq org-ellipsis "...")

Source Code Blocks

;; Pretty fontification of source code blocks.
(setq org-src-fontify-natively t)

;; Use `bash' instead of `sh' in the `shell' code block.
(setq org-babel-sh-command "bash")

;; Use C++17.
(setq org-babel-C++-compiler "g++ -std=c++17")

;; `org-babel' languages.
(require 'ob-tangle)
(org-babel-do-load-languages
 'org-babel-load-languages
 '(
   (shell . t)
   (python . t)
   (C . t)         ; C and C++
   (calc . t)
   (latex . t)
   (gnuplot . t)
   (sqlite . t)))

;; No confirmation on block execution.
(setq org-confirm-babel-evaluate nil)

Org Agenda

;; Open the current agenda.
(global-set-key (kbd "C-c a") 'org-agenda)

;; View the agenda in the current window.
(setq org-agenda-window-setup 'current-window)

;; A file to store the agenda. I use Dropbox to be able to view/edit
;; the agenda on other devices (phones, tablets).
;; In particular, I use the `beorg' app on both iPhone and iPad.
(setq org-agenda-files '("~/Dropbox/org/refile-beorg.org"))

;; View diary for the current week.
(setq org-agenda-include-diary t)

;; Set priority range from A to C with default A.
(setq org-highest-priority ?A)
(setq org-lowest-priority ?C)
(setq org-default-priority ?A)

;; Optional. Set custom colors for priorities (for Solarized Dark theme).
;; Your theme may require a different color set.
(setq org-priority-faces
      '((?A . (:foreground "#F0DFAF" :weight bold))
        (?B . (:foreground "LightSteelBlue"))
        (?C . (:foreground "OliveDrab"))))

;; Capture items using <C-c c>.
(define-key global-map (kbd "C-c c") 'org-capture)
(setq org-capture-templates
      '(
        ("t" "TODO item in refile-beorg"
         entry (file "~/Dropbox/org/refile-beorg.org")
         "* TODO %?\n%U"
         )
        ("n" "Notes in notes.org"
         entry (file "~/Dropbox/org/notes.org")
         "\n* %T %?\n%i"
         )))

;; https://github.com/harrybournis/org-fancy-priorities
(use-package org-fancy-priorities
  :ensure t
  :hook
  (org-mode . org-fancy-priorities-mode)
  :config
  (setq org-fancy-priorities-list '("⚡" "⏰" "☕")))

;; A timestamp or a note will be recorded when an entry has been refiled.
(setq org-log-refile t)

;; Add "CLOSED: [timestamp]" when a task is marked as DONE.
(setq org-log-done t)

(defun my/notes-open ()
  (interactive)
  (switch-to-buffer (find-file-noselect "~/Dropbox/org/notes.org")))
(global-set-key (kbd "C-c n") #'my/notes-open)

Theme Specific Settings

I use the Solarized Dark theme; it has some tweaks for Org-mode.

;; Don't change size of Org-mode headlines (but keep other size-changes)
(setq solarized-scale-org-headlines nil)

;; Avoid all font-size changes
(setq solarized-height-minus-1 1.0)
(setq solarized-height-plus-1 1.0)
(setq solarized-height-plus-2 1.0)
(setq solarized-height-plus-3 1.0)
(setq solarized-height-plus-4 1.0)

Some Custom Face Settings for Org-mode

I prefer to have a very dark background in code blocks. Your theme may require a different color set.

(custom-set-faces
 '(org-block ((t (:background "gray10"))))
 '(org-document-title ((t (:foreground "red" :weight bold))))
 '(org-level-1 ((t (:inherit outline-1 :weight bold))))
 '(org-level-2 ((t (:inherit outline-2 :weight normal :slant italic))))
 '(org-level-3 ((t (:inherit outline-3 :slant italic))))
 '(org-level-4 ((t (:inherit outline-4 :slant italic)))))

Screenshots

Org mode w/ code blocks. Click or tap to view the full-size picture.

Org agenda w/ diary. Click or tap to view the full-size picture.

Happy emacsing!

— The Emacs Cat.

Making a Multiplatform Emacs Configuration

Fri, 20 Jun 2025 11:15:16 +0100

These days, I use three different operating systems at work and home: Ubuntu Linux (Dell Latitude 7490 13" laptop), Microsoft Windows (Dell Latitude 7400 13" laptop), and macOS (27" iMac). My primary tool across these platforms is Emacs, which I use for nearly everything—coding (C++, Python), blogging (Hugo), reading (Elfeed), note-taking (Org Mode, org-roam), diary, and agenda management (beorg on iPhone, synchronized via Dropbox across all computers), among other tasks.

Naturally, I want a single Emacs configuration file—.emacs or, if you prefer, init.el—to work seamlessly across all these platforms.

Emacs is arguably the most platform-agnostic software available. However, some OS-specific differences must be addressed. These can be grouped into several categories:

Paths for external executables, particularly on Windows.
OS-specific key bindings, especially on macOS.
Various OS-specific tweaks, particularly for Windows.
Font sizes, which depend on screen size and resolution.

Below, I explore these issues in greater detail.

Introduction

First, we need to determine the operating system type.

;;;; OS Detection
(defvar os-windows (string-equal system-type "windows-nt") "Running on Windows.")
(defvar os-linux (string-equal system-type "gnu/linux") "Running on Linux.")
(defvar os-macos (string-equal system-type "darwin") "Running on macOS.")

Paths

;;; Environment Variables.
(defvar my/home (getenv "HOME"))

(when os-linux
  (setenv "PATH"
          (concat
           my/home "/lib/grpc/bin" path-separator ; gRPC binaries
           (getenv "PATH")))
  (setenv "PKG_CONFIG_PATH"
          (concat
           my/home "/lib/grpc/lib/pkgconfig")))

;; Add Cygwin path on Windows.
(when os-windows
  (setq exec-path (cons "C:/cygwin64/bin" exec-path)))

;; Clang/clangd compiler on Windows.
(when os-windows
  (setq exec-path (append exec-path '("C:/bin/LLVM/9.0.0/bin"))))

;; Clang/clangd compiler on macOS.
(when os-macos
  (setq exec-path (append exec-path '("/usr/local/Cellar/llvm/11.0.0_1/bin"))))

The exec-path built-in variable contains a list of directories Emacs searches to run programs in subprocesses. Each element is either a string (directory name) or nil (indicating the default directory).

OS-Specific Key Bindings

macOS

Disable the Command key as Meta and enable Option as Meta (Alt).

;;;; `macOS' keyboard
(when os-macos
    (setq mac-command-key-is-meta nil
          mac-command-modifier 'super
          mac-option-key-is-meta t
          mac-option-modifier 'meta))

Prevent accidentally closing the frame or Emacs app by disabling ⌘-w and ⌘-q.

(when os-macos
  (global-unset-key (kbd "s-w"))
  (global-unset-key (kbd "s-q")))

OS-Specific Tweaks

Microsoft Windows

Increase the default Windows pipe buffer size. (Note: This may no longer be necessary, but I include it for compatibility.)

(when os-windows
  (setq w32-pipe-read-delay 0)
  (setq irony-server-w32-pipe-buffer-size (* 64 1024)))

Configure Dired to resemble its appearance on Linux/macOS.

(if os-windows
    (setq dired-listing-switches "/A:H /O:NG")
  ;; Linux/macOS
  (setq dired-listing-switches "-laGgh1v --group-directories-first --time-style=long-iso"))

Linux

Set the default browser on Linux.

(when os-linux
  (setq browse-url-browser-function 'browse-url-firefox))

(cond
 (os-linux (defvar my/font-height 140 "The default font height for Emacs on Linux (in 1/10th points)."))
 (os-macos (defvar my/font-height 180 "The default font height for Emacs on macOS (in 1/10th points)."))
 (t (defvar my/font-height 140 "The default font height for Emacs on Windows and other systems (in 1/10th points).")))

Set the default font size based on the OS type.

(custom-set-faces
 `(default ((t (:height ,my/font-height :width normal :family "Aporetic Sans Mono"))))
)

Note the use of the backquote macro for dynamic font height.

Summary

With these configurations, I can use a single .emacs file across all my machines, ensuring a consistent Emacs experience regardless of the operating system.

Happy emacsing!

— The Emacs Cat.

Windows Navigation in Emacs

Fri, 16 May 2025 10:11:27 +0100

Last week there were some quite interesting posts about windows management in Emacs — Emacs’ windows navigations and some Emacs zen (a review by Irreal), Emacs window management tweaking, for instance.

In this regard, I’ve decided to share my configuration for the issue.

For switching between windows in Emacs I use the ace-window package by Oleh Krehel aka abo-abo, a renowned author of such gems as Hydra, avy, Swiper, and others. Most of these packages have found their place in my .emacs.

My configuration is quite simple.

(use-package avy :ensure t)
(use-package ace-window :ensure t
  :after avy
)

(global-set-key [(f2)]  #'ace-window)

The main function, ace-window is meant to replace other-window by assigning each window a short, unique label. When there are only two windows present, other-window is called… If there are more, each window will have its first label character highlighted. Once a unique label is typed, ace-window will switch to that window.
…
By default, ace-window uses numbers for window labels so the window labeling is intuitively ordered.

I’ve bound ace-window to <F2>. Why <F2>? For ergonomic reasons. On most keyboards, the numeric keys (1-2-3-…) are located right under the <F2> key. It would be easy to press <F2> then, for example, 2 using the same finger.

Window labels are in the top left corner of each window (shown in red). The frame is dimmed when activating `ace-window`.

The ace-window package has many other options; you can find more detailed information at the ace-window GitHub repository.

Happy emacsing!

— The Emacs Cat.

Emacs Time Stamp

Thu, 24 Apr 2025 10:44:10 +0100

I do almost all my text editing in Emacs, and it would be worth to store the last modified date/time of a file — org/plain text/source code/whatever — in the file, without consulting the file system.

Fortunately, that is Emacs, and it always extends a helping hand. In our case this is the time-stamp Emacs built-in function that provides automatic time-stamping for a file.

All you need to do is to place a time-stamp template near the beginning of the file, and enable automatic time-stamping in your config.

;; When there is a "Time-stamp: <>" string in the first 10 lines of the file,
;; Emacs will write time-stamp information there when saving the file.
;; (Borrowed from http://home.thep.lu.se/~karlf/emacs.html)
(setq time-stamp-active t          ; Do enable time-stamps.
      time-stamp-line-limit 10     ; Check first 10 buffer lines for Time-stamp: <>
      time-stamp-format "Last changed %Y-%02m-%02d %02H:%02M:%02S by %u")
(add-hook 'write-file-hooks 'time-stamp) ; Update when saving.

See more about the time-stamp-format variable in Emacs built-in Help (M-x describe-variable).

Examples

ELisp

;;; package --- .emacs
;; Time-stamp: <Last changed 2025-04-18 12:54:28 by magnolia>
;;; Commentary:
;; Emacs startup file (macOS, Linux, Windows).

(defvar os-windows (string-equal system-type "windows-nt") "OMG, that's Windows!")
(defvar os-linux (string-equal system-type "gnu/linux") "I'm on Linux")
(defvar os-macos (string-equal system-type "darwin") "Oh, I'm on macOS")

(defvar my/home (getenv "HOME"))

Org Mode

:PROPERTIES:
:ID:       a483c173-162d-44fb-8c10-fec0f24eafc9
:END:
#+TITLE: Hugo
#+DATE: Time-stamp: <Last changed 2025-04-22 14:40:44 by magnolia>
#+FILETAGS: :blog:web:

* Issues
** 2025-04-01 Newest Hugo version publishes local links
   Fixed: Rolled back to v.0.123.7 from Ubuntu 24.04 repository.

C++ source code

// Time-stamp: <Last changed 2025-03-31 15:36:04 by magnolia>

#pragma once

#include <queue>
#include <mutex>
#include <condition_variable>

class SafeQueue {

Happy emacsing!

— The Emacs Cat.

Elfeed-optimized Blogging

Wed, 02 Apr 2025 13:16:58 +0100

To read my newspapers I load my RSS feed via the elfeed package.
…
Also, I identify any RSS feed entry that does not provide the full text. And those live in provisional status. My reflexes are to ask “there’s lots of full-text feeds, why bother with this truncation?”

Jeremy Friesen, A Walk Through My Digital Neighborhood

Jeremy is totally right! – it came to my mind immediately.

I’m using the Hugo static site generator to build this blog. Hugo uses content summaries to display a list of blog entries on the main page. As a result, the Elfeed entry shows a summary of the post instead of the full text.

Many of us – including me – are using Elfeed as an RSS reader, and I have realized that the truncated Elfeed entry may cause inconvenience to the Elfeed users.

Applying some tricks I was able to disable the automatic displaying of summaries on the main page. I hope it has become more comfortable for those who use Elfeed for reading RSS feeds.

Happy elfeeding!

– The Emacs Cat.

P.S. Thanks to Jeremy Friesen for the heads up.

Using Emacs Org Mode for Reproducibility Testing

Fri, 07 Mar 2025 10:33:34 +0100

Software reproducibility testing is a critical aspect of software development and maintenance. It ensures that software is reliable, consistent, and predictable and that it can be easily replicated and verified by others.

Ana Pustan, Reproducibility Testing: A Complete Guide

For many of us, it won’t be a surprise that the Emacs Org mode is perfectly suited for reproducibility testing.

In some of my projects I’m using gRPC, a modern open source high performance Remote Procedure Call (RPC) framework that can run in any environment. The gRPC framework is evolving very rapidly so I have to update it to the most recent stable version time to time. No doubt, I want to make sure that everything is working properly after the update.

I’ve built a tiny hello-world gRPC server for testing the update. I use grpcurl, a command-line tool that interacts with gRPC servers, as a client.

Now Emacs has to go be onstage.

The Server

I don’t like having to leave Emacs for too long so I run my server in Eshell.

Click or tap to view the full-size picture.

The Client

The Org mode code blocks – that’s all we need now.

Listing of available services at localhost port 50051

#+begin_src bash :results verbatim
  grpcurl -plaintext localhost:50051 list
#+end_src

#+RESULTS:
: grpc.reflection.v1.ServerReflection
: grpc.reflection.v1alpha.ServerReflection
: helloworld.Greeter

Pressing C-c C-c when the point (cursor) is inside the code block shows 3 services available at localhost:50051 – 2 builtin services and our helloworld.Greeter service, the last one.

Inspecting helloworld.Greeter service

#+begin_src shell :results verbatim
  grpcurl -plaintext localhost:50051 describe helloworld.Greeter
#+end_src

#+RESULTS:
: helloworld.Greeter is a service:
: service Greeter {
:   rpc SayHello ( .helloworld.HelloRequest ) returns ( .helloworld.HelloReply );
: }

OK, everything seems to be in order.

Inspecting helloworld.Greeter.SayHello method

#+begin_src bash :results verbatim
  grpcurl -plaintext localhost:50051 describe helloworld.Greeter.SayHello
#+end_src

#+RESULTS:
: helloworld.Greeter.SayHello is a method:
: rpc SayHello ( .helloworld.HelloRequest ) returns ( .helloworld.HelloReply );

Querying the server

Finally, let’s query the server.

#+begin_src bash :results verbatim
  grpcurl -plaintext -d '{"name": "world"}' localhost:50051 helloworld.Greeter.SayHello
#+end_src

#+RESULTS:
: {
:   "message": "Hello world!"
: }

That is the expected outcome – the server replied accordingly.

Click or tap to view the full-size picture.

Now I can perform gRPC reproducibility testing every time after the update.

Happy emacsing!

– The Emacs Cat.

C++ Programming in Emacs

Sat, 22 Feb 2025 10:36:27 +0100

C++ is my primary programming language since – I can’t believe it myself – 1991 (yes, it was Turbo C++). As I’m going to do almost everything within Emacs 29.4 now – no doubt I want to have the C++ IDE in Emacs, in the same way I’m using Emacs as the Python IDE.

Thankfully, eglot, the Emacs client for the Language Server Protocol (LSP), is now – since version 29 – the part of Emacs. It remains to choose the appropriate LSP.

Choosing a Language Server

I’ve settled on clangd, a powerful LSP for C++ based on the Clang C++ compiler. It provides an impressive set of features including error checking, code completion, cross-references, navigation, and others.

clangd is the part of the LLVM project and it can be downloaded from LLVM Download Page. Which version to download? It depends on OS/version you are using. I’m using Pop!_OS 22.04 (Ubuntu 22.04 fork); after researching, I came upon clang+llvm-17.0.6-x86_64-linux-gnu-ubuntu-22.04.tar.xz from this repository that contains pre-build binaries for my OS. It supports C++17 standard – that’s good enough for me.

I’ve unpacked the archive to ~/bin/LLVM-17.0.6/ then added $HOME/bin/LLVM-17.0.6/bin to the $PATH envvar.

$ clangd --version
clangd version 17.0.6 (https://github.com/llvm/llvm-project 6009708b4367171ccdbf4b5905cb6a803753fe18)
Features: linux
Platform: x86_64-unknown-linux-gnu

Configuring clangd

Clangd stores its configuration in YAML files. I’m using per-project configuration file .clangd – clangd searches for it in all parent directories of the active file.

Below is my simple and straightforward .clangd for some of my projects.

# Enable all warnings, use C++17 standard, specify include directories.
CompileFlags:
  Add: [-xc++,
       -Wall,
       -std=c++17,
       -I/home/magnolia/workspace/devel,
       -I/home/magnolia/lib/grpc/include,
       -I/home/magnolia/lib/spdlog/include]
  Compiler: clang++  # Always use `clang++'

It is placed in the top level directory of my project. You can find more about clangd configuration here.

Now we can return back to the Emacs configuration.

Emacs Configuration for C++

Using Eglot

(require 'eglot)
(add-hook 'c-mode-hook 'eglot-ensure)
(add-hook 'c++-mode-hook 'eglot-ensure)
(add-hook 'c-or-c++-mode-hook 'eglot-ensure)

The Eglot session will start automatically every time you open the C/C++ file in a buffer. If the Eglot session for the current C/C++ buffer has started successfully it displays the following message in the Emacs minibuffer:

[eglot] Connected! Server `clangd' now managing `(c++-mode c-mode)' buffers in project ...

Visual Improvements

Highlighting symbols and numbers in the source code.

;; Highlights the word/symbol at point and any other occurrences in
;; view. Also allows to jump to the next or previous occurrence.
;; https://github.com/nschum/highlight-symbol.el
(use-package highlight-symbol
  :ensure t
  :config
  (setq highlight-symbol-on-navigation-p t)
  (add-hook 'prog-mode-hook 'highlight-symbol-mode))

;; Emacs minor mode that highlights numeric literals in source code.
;; https://github.com/Fanael/highlight-numbers
(use-package highlight-numbers
  :ensure t
  :config
  (add-hook 'prog-mode-hook 'highlight-numbers-mode))

C++ Headers

Please, treat C headers as C++ ones.

;; .h files to open in c++-mode rather than c-mode.
(add-to-list 'auto-mode-alist '("\\.h$" . c++-mode))

Code Styles

(setq c-default-style "stroustrup")
(setq c-basic-indent 4)
(setq c-basic-offset 4)

I’m using the Stroustrup C++ code style that is very similar to the K&R (Kernighan & Ritchie) code style.

The c-style-alist Elisp variable contains a list of all predefined code styles. Pick a style that suits you.

Indentation Inside of Namespaces

;; emacs-fu: don’t indent inside of C++ namespaces
;; http://brrian.tumblr.com/post/9018043954/emacs-fu-dont-indent-inside-of-c-namespaces
(c-set-offset 'innamespace 0)

I prefer to have the code unindented inside of a namespace as shown below,

namespace tec {

class Client {
public:
    Client() {
        // ...
    }

    int get_id() {
        // ...
    }
}; // ::Client

} // ::tec

rather than

namespace tec {

    class Client {
    public:
        Client() {
            // ...
        }

        int get_id() {
            // ...
        }
    }; // ::Client

} // ::tec

Spaces vs Tabs

Yes, I’m using spaces instead of tabs for indentation.

;; Spaces instead of tabs when indenting.
(setq-default indent-tabs-mode nil)

Trailing Tabs and Spaces

A builtin package that shows/deletes useless trailing tabs and spaces. You can also use M-x delete-trailing-whitespace to remove all trailing white-spaces in a buffer interactively.

;; http://www.reddit.com/r/emacs/comments/2keh6u/show_tabs_and_trailing_whitespaces_only/
(use-package whitespace
  :config
  ;; Commented since there are too many 'valid' whitespaces in some modes.
  ;; (setq-default show-trailing-whitespace t)
  (setq whitespace-style '(face tabs trailing))
  (set-face-attribute 'whitespace-tab nil
      :background "red"
      :foreground "yellow"
      :weight 'bold)
  (add-hook 'prog-mode-hook 'whitespace-mode)
  ;; Delete trailing tabs and spaces on save of a file.
  (add-hook 'before-save-hook 'whitespace-cleanup)
)

Clangd with Flymake

This chapter is identical to the corresponding chapter in my previous post Python Programming in Emacs. I put it here for clarity.

Flymake is a minor Emacs mode performing on-the-fly syntax checks. I’m using the flymake built-in Emacs package as an Eglot front-end for syntax checks.

(require 'flymake)

My custom my/flymake-toggle-diagnostics-buffer function toggles the Flymake diagnostics buffer window.

If there is the Flymake diagnostics buffer associated with a file in the current buffer, it shows the diagnostics buffer in the new window and switches to it. If the current buffer is the Flymake diagnostics buffer, it closes it. Otherwise it just shows the error message.

(defun my/flymake-toggle-diagnostics-buffer ()
  (interactive)
  ;; Check if we are in the diagnostics buffer.
  (if (string-search "*Flymake diagnostics" (buffer-name))
      (delete-window)
    (progn
      ;; Activate the Flymake diagnostics buffer.
      ;; and switch to it
      (flymake-show-buffer-diagnostics)
      (let ((name (flymake--diagnostics-buffer-name)))
        (if (get-buffer name)
            (switch-to-buffer-other-window name)
          (error "No Flymake diagnostics buffer found")
          )))))

I’ve bound this function to the F7 key globally since I’m using F7 in other programming modes as well.

(global-set-key [(f7)] #'my/flymake-toggle-diagnostics-buffer)

;; Additional bindings.
(global-set-key (kbd "C-c f b") #'flymake-show-buffer-diagnostics)
(global-set-key (kbd "C-c f p") #'flymake-show-project-diagnostics)

The screenshot below shows what happens if you press F7 while editing a C++ file managed by Eglot + Flymake.

Click or tap to view the full-size picture.

Treemacs

From looking at the screenshot above, you can see using of Treemacs, a tree layout file explorer for Emacs.

I can highly recommend to use it for any project you’re working on in conjunction with the excellent Projectile and Ivy packages.

(use-package ivy
  :config
  (ivy-mode)
  (setq ivy-use-virtual-buffers t)
  (add-hook 'after-init-hook (lambda () (setq ivy-height (/ (window-height) 2))))
)

(use-package projectile
  :ensure t
  :config
  (projectile-global-mode)
  (setq projectile-enable-caching t)
  (setq projectile-completion-system 'ivy)
)

(use-package treemacs :ensure t)
(use-package treemacs-projectile :ensure t)

I’ve bound Treemacs to F12 globally.

(global-set-key [(f12)] #'treemacs-select-window)

Press ? when in the Treemacs window to see all commands available. Press q to close the Treemacs window.

Code Completion

This chapter is identical to the corresponding chapter in my previous post Python Programming in Emacs. I put it here for clarity.

I’m using the company package, a modular in-buffer completion framework for Emacs, as an Eglot front-end for code completion; it integrates with Eglot seamlessly.

;;;; `COMPANY'
(use-package company
  :ensure t
  :config
  (setq company-idle-delay 0)
  (setq company-minimum-prefix-length 2)
  (setq company-show-numbers t)
  ;; To prevent default down-casing.
  ;; https://emacs.stackexchange.com/questions/10837/how-to-make-company-mode-be-case-sensitive-on-plain-text
  (setq company-dabbrev-downcase nil)
  ;; 2023-01-13 From a Reddit post on mixed case issue.
  (setq company-dabbrev-ignore-case nil)
  (setq company-dabbrev-code-ignore-case nil))

;; Use `company' everywhere.
(add-hook 'after-init-hook 'global-company-mode)

Click or tap to view the full-size picture.

My favorite tool for code navigation in the current buffer is the excellent imenu-list package. Powered by Eglot, it shows almost everything you want to see.

Click or tap to view the full-size picture.

Now your Emacs looks like a full-featured C++ IDE – and it is, actually.

;; Show the current buffer's imenu entries in a separate buffer
(use-package imenu-list
  :ensure t
  :config
  (setq imenu-list-focus-after-activation t)
  (global-set-key (kbd "C-.") #'imenu-list-minor-mode)
)

I’ve bound imenu-list-minor-mode to C-.; this key chord will toggle the Imenu buffer on/off.

Alternatively, you can use Treemacs to navigate through the code and files on a per-project basis.

Click or tap to view the full-size picture.

“Classic” default navigation keys will also work with all files in your project.

xref-find-definitions: M-. to find the definition of the identifier at point.
xref-go-back: M-, to return back to where you invoked the xref-find-definitions command.
xref-find-references: M-? to find references to the identifier at point.

These functions are now powered by Eglot.

Appendix A

All the Icons

As you can see from the screenshots above, I like to see icons wherever possible – in treemacs, dired, ibuffer, company and other modes. To achieve that, all you need is to install the corresponding packages.

;; https://github.com/domtronn/all-the-icons.el
(use-package all-the-icons :ensure t)

(use-package all-the-icons-dired :ensure t)
(add-hook 'dired-mode-hook 'all-the-icons-dired-mode)

(use-package all-the-icons-ibuffer :ensure t
  :init (all-the-icons-ibuffer-mode 1)
  :hook (ibuffer-mode . all-the-icons-ibuffer-mode))

(use-package treemacs-all-the-icons :ensure t)

(use-package all-the-icons-ivy :ensure t
  :after all-the-icons
  :config (all-the-icons-ivy-setup))

To install icons font, please follow these instructions.

Appendix B

A Note for Tree-Sitter Users

I do not use Tree-Sitter for coding in C++. It seems it has its own rules for indentation that break down the code style I prefer.

Happy emacsing!

– The Emacs Cat.

P.S. Emacs 30.1 has been released on February 23. Thanks for everyone involved with this great project!

P.P.S. Mickey Petersen has published his excellent review on what’s new in this release.

Python Programming in Emacs

Thu, 26 Dec 2024 10:01:05 +0100

Python is one of my programming languages I’m using for both work and home life – no doubt, I’d want to use Emacs as an IDE for Python programming. There is a certain set of features we’d expect to have in any IDE: 1) code completion, 2) code navigation, 3) error checking.

Thanks to the fact that both eglot, the Emacs client for the Language Server Protocol (LSP), and tree-sitter, a powerful parsing library, are now – since version 29 – the parts of Emacs, It should not be too hard to construct a lightweight and fast Python IDE.

Choosing a Language Server

There are a number of the language servers for Python available these days – pylsp, pyls, pyright, jedi-language-server. After a series of tests, I’ve settled on pyright, an open syntax and type checker from Microsoft (sic!) used in Visual Studio Code, the fast and reliable one, as for me.

The Pyright documentation – a bit weird – claims that Pyright is just static type checker for Python. However, as we’ll see later, Pyright can do much more than just type checks.

A note on the Tree-Sitter package

The tree-sitter package is optional – I’m using it for pretty-looking source code fontification mainly. However, if you want to use it you have to pay attention to the following quote from the Mickey Petersen’s ‘Mastering Emacs’ book:

And in Emacs 29, support for tree-sitter is built in. Sort of. It’s an optional extra, so you must compile Emacs from source, or hope that someone else will do it for you.

Neither tree-sitter nor Emacs come installed with language grammars. Just like kids’ toys and batteries, they’re sold separately. So you’re required to download and compile the sources for each language grammar you want to use.

– Mastering Emacs by Mickey Petersen.

If you are – like me – on Linux, the best way to setup language grammars is to compile them from the source code; you can find all grammars available on the tree-sitter repository. More details at How to Get Started with Tree-Sitter.

Python prerequisites

First of all, we need to install the following Python packages – pyright (the language server) and jsonrpc (the transport layer for the LSP).

[p3] $ pip install pyright
[p3] $ pip install jsonrpc

I’m running Python in the virtual environment, “p3” in my case.

Error checking with Pyright

Eglot automatically finds a suitable LSP – Pyright in our case – when you are opening a Python file. I’m using the default Pyright settings, no extra tuning required.

Pyright LSP with Flymake

Flymake is a minor Emacs mode performing on-the-fly syntax checks. I’m using the flymake built-in Emacs package as an Eglot front-end for syntax checks.

(require 'flymake)

My custom my/flymake-toggle-diagnostics-buffer function toggles the Flymake diagnostics buffer window.

(defun my/flymake-toggle-diagnostics-buffer ()
  (interactive)
  ;; Check if we are in the diagnostics buffer.
  (if (string-search "*Flymake diagnostics" (buffer-name))
      (delete-window)
    (progn
      ;; Activate the Flymake diagnostics buffer.
      ;; and switch to it
      (flymake-show-buffer-diagnostics)
      (let ((name (flymake--diagnostics-buffer-name)))
        (if (get-buffer name)
            (switch-to-buffer-other-window name)
          (error "No Flymake diagnostics buffer found")
          )))))

I’ve bound this function to the F7 key globally since I’m using F7 in other programming modes as well.

(global-set-key [(f7)] #'my/flymake-toggle-diagnostics-buffer)

;; Additional bindings.
(global-set-key (kbd "C-c f b") #'flymake-show-buffer-diagnostics)
(global-set-key (kbd "C-c f p") #'flymake-show-project-diagnostics)

The screenshot below shows what happens if you press F7 while editing a Python file managed by Eglot + Flymake.

Click or tap to view the full-size picture.

As you can see, Pyright can do much more than just type checks.

Code completion

I’m using the company package, a modular in-buffer completion framework for Emacs, as an Eglot front-end for code completion; it integrates with Eglot seamlessly.

;;;; `COMPANY'
(use-package company
  :ensure t
  :config
  (setq company-idle-delay 0)
  (setq company-minimum-prefix-length 2)
  (setq company-show-numbers t)
  ;; To prevent default down-casing.
  ;; https://emacs.stackexchange.com/questions/10837/how-to-make-company-mode-be-case-sensitive-on-plain-text
  (setq company-dabbrev-downcase nil)
  ;; 2023-01-13 From a Reddit post on mixed case issue.
  (setq company-dabbrev-ignore-case nil)
  (setq company-dabbrev-code-ignore-case nil))

;; Use `company' everywhere.
(add-hook 'after-init-hook 'global-company-mode)

Click or tap to view the full-size picture.

I’m using the default key bindings for

xref-find-definitions: M-. to find the definition of the identifier at point.
xref-go-back: M-, to return back to where you invoked the xref-find-definitions command.
xref-find-references: M-? to find references to the identifier at point.

These functions are now powered by Eglot.

Final notes

I can recommend to force using Eglot for Python explicitly –

(require 'eglot)
(add-hook 'python-mode-hook 'eglot-ensure)

A note for Tree-Sitter users

If you are using Tree-Sitter for Python, it’s recommended to remap the python-mode to the Tree-Sitter specific python-ts-mode.

(add-to-list 'major-mode-remap-alist '(python-mode . python-ts-mode))

If this is the case, do not forget to force using Eglot for this mode as well.

(add-hook 'python-ts-mode-hook 'eglot-ensure)

Happy emacsing!

Emacs Startup Screen

Fri, 06 Dec 2024 18:40:56 +0100

Some time ago, I decided to customize my Emacs startup screen in order to display something helpful for me. Ultimately, after much consideration, I’ve settled on the following items I just want to see on my startup screen: 1) 3-month calendar, 2) agenda, 3) diary, 4) something just for fun.

No doubt, there are a number of packages that can assist you in making a pretty good-looking startup screen – like enlight, for instance. However, I decided to construct my own startup screen, a very simple one.

It requires having two command line utilities installed on your system: fortune to print out a random epigram, and calendar to print out some of the events that have occurred on the current date in the past. If you, like me, are using Linux or macOS – it will not be difficult to install them.

And this is what I got…

In the `.emacs` init file

First of all, disable the builtin startup screen.

(setq inhibit-startup-screen t)

Then add a startup hook.

(add-hook 'emacs-startup-hook
  (lambda ()
    (let* ((buffer-today (get-buffer-create "*today*"))
           (buffer-calendar "*Calendar*")
           (buffer-agenda "*Org Agenda*")
           (buffer-diary "*Fancy Diary Entries*"))
      ;; Call calendar first to obtain the current date
      ;; required to display the diary.
      (calendar)
      (diary)
      (org-agenda-list)
      ;; Fill and show the Today Events buffer.
      ;; NOTE: requires `fortune' and `calendar' command line utilities.
      (switch-to-buffer buffer-today)
      (call-process "fortune" nil buffer-today)
      (insert "\n")
      (call-process "calendar" nil buffer-today)
      (goto-char 0)
      (toggle-truncate-lines)
      ;; Maximize the Today Events window
      (delete-other-windows)
      ;; Show Agenda in the lower left quadrant.
      (split-window-vertically)
      (other-window 1)
      (switch-to-buffer (get-buffer buffer-agenda))
      (split-window-horizontally)
      ;; Try to show Diary in the lower right quadrant.
      (other-window 1)
      (if (get-buffer buffer-diary)
          ;; If Diary exists then show it ...
          (switch-to-buffer (get-buffer buffer-diary))
        ;; ... else show the scratch buffer.
        (let* ((buffer-scratch (switch-to-buffer (get-buffer "*scratch*"))))
          (goto-char (point-max))
          (insert (format-time-string "\n;; No diary entries for %A %d %b")))
        )
      ;; Go back to the Today Events buffer.
      (other-window -2)
      (split-window-horizontally)
      ;; Show Calendar in the upper left quadrant.
      (switch-to-buffer (get-buffer buffer-calendar))
      )))

The startup screen

Click or tap to view the full-size picture.

Happy emacsing!

Some Excerpts From My Emacs Config - 2: Functions

Fri, 29 Nov 2024 11:45:17 +0100

In his comment on Irreal’s post Some Configuration To Solve Common Problems, gregbognar noted that some of my configuration is seriously outdated. In some sense, he is absolutely correct – I’ve been collecting Emacs settings/tweaks since 2012, and keeping them unmodified for 12+ years.

But on the other hand, it demonstrates how stable and powerful Emacs is – everything is still working! If something works, don’t fix it – I’ve since tried to apply this rule wherever possible.

Here are a few functions/enhancements I found helpful.

`dired-mode` enhancements

Function: Calculate the total size of all marked files

The custom dired-get-size function calculates the total size of all marked files in the dired buffer and displays it in the echo area. Files in the dired buffer can be marked with m key and unmarked with u key.

The current version only works on systems with the /usr/bin/du system utility, which actually comprise 100% of the (non-Windows) systems – borrowed from oremacs.com.

(defun dired-get-size ()
  "Display file size in dired."
  (interactive)
  (let ((files (dired-get-marked-files)))
    (with-temp-buffer
      (apply 'call-process "/usr/bin/du" nil t nil "-sch" files)
      (message
       "Size of all marked files: %s"
       (progn
         (re-search-backward "\\(^[ 0-9.,]+[A-Za-z]+\\).*total$")
         (match-string 1))))))

In my config, dired-get-size is bound to z key in the dired-mode.

;; https://oremacs.com/2015/01/12/dired-file-size/
(define-key dired-mode-map "z" #'dired-get-size)

The result of pressing the `z` key in dired.

Some other `dired-mode` enhancements

Move to the parent directory

It reuses the current dired buffer for opening the parent directory (oremacs.com) instead of creating a new buffer. Bounded to the a key in dired-mode.

;; Move to the parent directory.
(define-key dired-mode-map "a"
  (lambda ()
    (interactive)
    (find-alternate-file "..")))

Run `eshell` in the current `dired` directory

Bounded to the ` back-tick key in dired-mode.

;; Run eshell.
(define-key dired-mode-map "`"
  (lambda ()
    (interactive)
    (eshell)))

Date and time stamps

Inserting the date and/or time stamps at the current cursor position. You can bind these functions to any key chords you prefer or call the corresponding function with M-x.

(defun my/time-stamp ()
  "Insert full date/time stamp as 2024-11-29 10:41 +0100 CET"
  (interactive)
  (insert (format-time-string "%Y-%m-%d %R %z %Z")))

(defun my/time-stamp-short ()
  "Insert short date/time stamp as 2024-11-29 10:41"
  (interactive)
  (insert (format-time-string "%Y-%m-%d %R")))

(defun my/date-stamp ()
  "Insert date stamp as 2024-11-29"
  (interactive)
  (insert (format-time-string "%Y-%m-%d")))

Some editing tweaks

Inserting a new line

Insert a new line, indent it, and move the cursor there. This behavior is different then the typical function bound to Enter which may be open-line or newline-and-indent. When you call them with the cursor between ^ (beginning of line) and $ (end of line), the contents of the line to the right of it will be moved to the newly inserted line. This function will not do that. Instead, the current line is left alone, a new line is inserted, indented, and the cursor is moved there. Borrowed from emacsredux.

(defun smart-open-line ()
  "Insert a new line, indent it, and move the cursor there."
  (interactive)
  (move-end-of-line nil)
  (newline-and-indent))

(global-set-key (kbd "<C-return>") #'smart-open-line)

I have bound it globally to Ctrl-Enter – C-return in the Emacs notation – so it should work in any mode.

Smart beginning of line

Move point to first non-whitespace character or beginning-of-line.

(defun smart-beginning-of-line ()
  "Move point to first non-whitespace character or `beginning-of-line`."
  (interactive)
  (let ((oldpos (point)))
    (back-to-indentation)
    (and (= oldpos (point))
         (beginning-of-line))))

(global-set-key (kbd "C-a") #'smart-beginning-of-line)

I’ve rebound the default Ctrl-A – C-a in the Emacs notation – to move to first non-whitespace character of a line instead of first column.

Killing a word at point

Deleting the whole word at the cursor position.

(defun kill-whole-word ()
  "Kill the current word at point."
  (interactive)
  (backward-word)
  (kill-word 1))

(define-key global-map (kbd "<M-DEL>") #'kill-whole-word)

I’ve rebound it to Alt-delete – M-DEL in the Emacs notation.

Nuke all buffers

Kill all buffers, leaving *scratch* only.

(defun nuke-all-buffers ()
  "Kill all buffers, leaving *scratch* only."
  (interactive)
  (mapc
   (lambda (buffer)
     (kill-buffer buffer))
   (buffer-list))
  (delete-other-windows))

To be continued. Happy emacsing!

Migration to Bluesky

Fri, 22 Nov 2024 11:23:12 +0100

After reading the quite interesting post Blue Sky by Mike Zamansky I decided to begin my gentle migration to Bluesky, a new and promising social media platform.

I completely agree with Mike’s opinion on Twitter as well as other social platforms. Like many of us, I migrated from Twitter – keeping my existing account there – to Mastodon. Unfortunately, Mastodon, largely due to its distributed architecture, seems to be more fragile than other platforms – recently, I have been warned that emacs.ch, a fediverse server I have been using for two years now, is about to shutdown in this December.

Sure, there is a (bit complex) way to transfer your Mastodon account to another server – and here is detailed explanation on how to do that. Perhaps, I will do that in the nearest future, but who can guarantee that the new server is immune from the same fate?

Anyway, Bluesky looks promising and I decided to give it a try. You can find me at @olddeuteronomy.bsky.social.

Some Excerpts From My Emacs Config

Wed, 20 Nov 2024 11:52:19 +0100

I’m happy to be back after one year away and it feels great.

Below are some chaotic mini/micro – or even nano – excerpts from my ~/.emacs file I have been tuning in for 12 years. These days, I’m running Emacs 29.4 on Ubuntu (Pop!_OS) 22.04 and, rarely, on macOS.

These tweaks have been collected from various sources; I provide a reference to the source if available.

Checking the operating system Emacs is running on

(defvar my/os-linux (string-equal system-type "gnu/linux") "I'm on Linux")
(defvar my/os-macos (string-equal system-type "darwin") "Oh, I'm on macOS")
(defvar my/os-windows (string-equal system-type "windows-nt") "OMG, that's Windows!")

macOS keyboard

;; Disable Command key and enable Options as Meta.
(if my/os-macos
    (setq mac-command-key-is-meta nil
          mac-command-modifier 'super
          mac-option-key-is-meta t
          mac-option-modifier 'meta))

Everything is UTF-8

(set-language-environment 'utf-8)
(setq locale-coding-system 'utf-8)
(setq buffer-file-coding-system 'utf-8-unix)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(set-selection-coding-system 'utf-8)
(prefer-coding-system 'utf-8)

Smooth scrolling

Borrowed from http://home.thep.lu.se/~karlf/emacs.html

(setq scroll-step 1)

;; Marker distance from center (don't jump to center).
(setq scroll-conservatively 100000)

;; Try to keep screen position when PgDn/PgUp.
(setq scroll-preserve-screen-position 1)

;; Start scrolling when marker at top/bottom.
(setq scroll-margin 0)

;; Mouse scroll moves 1 line at a time, instead of 5 lines.
(setq mouse-wheel-scroll-amount '(1))

;; On a long mouse scroll keep scrolling by 1 line.
(setq mouse-wheel-progressive-speed nil)

Some helpful tips for emacsing in comfort

Clipboard

;; Non-nil means cutting and pasting uses the clipboard.
(setq x-select-enable-clipboard t)

Turning off some annoying features

;; No ToolBar, please.
(tool-bar-mode -1)

;; No alarms, please.
(setq ring-bell-function 'ignore)

;; No lock files, please.
;; https://emacs.stackexchange.com/questions/78800/how-to-disable-automatic-appearance-of-warnings-buffer-in-emacs
(setq create-lockfiles nil)

;; Sentences do not need double spaces to end. Period.
(set-default 'sentence-end-double-space nil)

;; Replace "yes" by "y".
(fset 'yes-or-no-p 'y-or-n-p)

;; Don’t use dialog boxes.
(setq use-dialog-box nil)

;; For gpg (works on Ubuntu and macOS) to disable custom prompt.
(setenv "GPG_AGENT_INFO" nil)

;; Speedup cursor movement.
;; https://emacs.stackexchange.com/questions/28736/emacs-pointcursor-movement-lag/28746
(setq auto-window-vscroll nil)

;; Spaces instead of tabs when indenting.
;; Some people may not agree with this though.
(setq-default indent-tabs-mode nil)

Turning on some helpful features

;; Nonzero means echo unfinished commands after this many seconds of
;; pause. The value may be integer or floating point. If the value is
;; zero, don’t echo at all.
(setq echo-keystrokes 0.01)

;; Winner mode is a global minor mode that records the changes in the
;; window configuration.
;; https://www.gnu.org/software/emacs/manual/html_node/emacs/Window-Convenience.html
(winner-mode t)

;; Turn on highlighting current line.
;; http://ergoemacs.org/emacs/emacs_make_modern.html
(global-hl-line-mode 1)

;; Replace highlighted text with what I type rather than just
;; inserting at point.
(delete-selection-mode t)

;; Restore opened files.
(desktop-save-mode 1)

;; Save minibuffer history.
(savehist-mode 1)

;; When on a tab, make the cursor the tab length.
(setq-default x-stretch-cursor t)

;; Auto refresh dired when file changes.
;; http://pragmaticemacs.com/emacs/automatically-revert-buffers/
(add-hook 'dired-mode-hook 'auto-revert-mode)

;; Auto refresh dired, but be quiet about it.
(setq global-auto-revert-non-file-buffers t)
(setq auto-revert-verbose nil)

;; Automatically reload files was modified by external program.
;; https://www.emacswiki.org/emacs/AutoRevertMode
(global-auto-revert-mode 1)

;; Make URLs in comments/strings clickable, (Emacs > v22).
(add-hook 'find-file-hooks 'goto-address-prog-mode)

;; Display fringe indicators in `visual-line-mode`.
(setq visual-line-fringe-indicators '(left-curly-arrow right-curly-arrow))

;; Switching the focus to the help window when it's opened.
(setq help-window-select t)

Frame title

Template for displaying the title bar of visible frames. (Assuming the window manager supports this feature.)

This variable has the same structure as mode-line-format, except that the %c, %C, and %l constructs are ignored.

;; Frame title.
(setq frame-title-format "%F--%b-[%f]--%Z")

Electric Pair mode

Electric Pair mode is a global minor mode. When enabled, typing an open parenthesis automatically inserts the corresponding closing parenthesis, and vice versa. (Likewise for brackets, etc.). If the region is active, the parentheses (brackets, etc.) are inserted around the region instead.

;; Global.
(electric-pair-mode 1)

Calendar tweaks

If you want to be informed about the times of sunrise and sunset for any date at your location, Emacs is always ready to lend a hand – you just need to provide your coordinates to Emacs. Use one decimal place in the values of calendar-latitude and calendar-longitude.

(defvar calendar-latitude NN.N)
(defvar calendar-longitude NN.N)

;; Number of minutes difference between local standard time and UTC.
;; For example, -300 for New York City, -480 for Los Angeles.
(defvar calendar-time-zone NNN)

;; Optional, the default value is just the variable `calendar-latitude`
;; paired with the variable `calendar-longitude`.
(defvar calendar-location-name "Your City, Your Country")

Within the calendar, the following commands are available:

S: Display times of sunrise and sunset for the selected date (calendar-sunrise-sunset).
M-x sunrise-sunset: Display times of sunrise and sunset for today’s date.
C-u M-x sunrise-sunset: Display times of sunrise and sunset for a specified date.
M-x calendar-sunrise-sunset-month: Display times of sunrise and sunset for the selected month.

The command M-x sunrise-sunset is also available outside the calendar to display the sunrise and sunset information for today’s date in the echo area.

Some other Calendar tweaks

;; First day of the week: 0:Sunday, 1:Monday.
(defvar calendar-week-start-day 1)

;; Use European date format (DD/MM/YYYY or 9 October 2024).
(defvar calendar-date-style 'european)

To be continued. Happy emacsing!

Org Mode: Exporting Clock Tables

Tue, 01 Aug 2023 14:07:46 +0300

After reading a quite interesting post by Irreal on Org mode clock tables, I decided to share my — a bit specific — experience with the subject.

The Task

Like many of us these days, I’m working remotely. My employer requires a periodic report and I should track my time I spend on various task — exactly as Irreal describes in his post. Of course, I’m using Org mode clock tables for that purpose.

#+TITLE: Worktime Tracker for July 2023
#+OPTIONS: num:nil toc:nil

#+BEGIN: clocktable :maxlevel 3 :scope file
#+END

* 2023-07    :2023:

** 2023-07-03
*** Impl. a test gRPC server                            :TEST:
:LOGBOOK:
CLOCK: [2023-07-03 Mon 15:05]--[2023-07-03 Mon 15:50] =>  0:45
CLOCK: [2023-07-03 Mon 09:45]--[2023-07-03 Mon 14:10] =>  4:25
:END:

** 2023-07-04
*** Fix client timeout                                   :FIX:
:LOGBOOK:
CLOCK: [2023-07-04 Tue 12:45]--[2023-07-04 Tue 13:10] =>  0:25
:END:
*** Add AddOrder handler                                :FEAT:
:LOGBOOK:
CLOCK: [2023-07-04 Tue 14:05]--[2023-07-04 Tue 15:10] =>  1:05
:END:

Then if I put the cursor at the line with the word #+BEGIN (line #4 in my org file) and press C-c C-c (in the Org mode, this chord runs the multipurpose command org-ctrl-c-ctrl-c), the dynamic clock table block is getting updated immediately and I get a standard clock table report as shown below.

#+BEGIN: clocktable :maxlevel 3 :scope file
#+CAPTION: Clock summary at [2023-07-30 Sun 15:32]
| Headline                       | Time |      |      |
|--------------------------------+------+------+------|
| *Total time*                   |*6:40*|      |      |
|--------------------------------+------+------+------|
| 2023-07                        | 6:40 |      |      |
| \_  2023-07-03                 |      | 5:10 |      |
| \_    Impl. a test gRPC server |      |      | 5:10 |
| \_  2023-07-04                 |      | 1:30 |      |
| \_    Fix client timeout       |      |      | 0:25 |
| \_    Add AddOrder handler     |      |      | 1:05 |
#+END

So far, everything looks fine.

The Problem

The problem is that my employer wants the report to be in a specific format.

The required MS Word (sic!) file with the work time report.

Please note the column #1 should contain a tag of the task, all dates should be in the DD.MM.YYYY format, a time spent for the task should be in the hh:mm format, left-padded with 0s if required, and the total time should be in the hhh:mm format, left-padded with 0s as well.

Here the adventure begins.

The Adventure

I decided to implement my exporter as the Elisp code block inside my time tracking org file. Therefore, if I press C-c C-c when the cursor is over the exporter code block, Emacs evaluates this block and prints the result just below the block. This would allow us to make some experiments.

First of all, I need an access to my clock table entries. After some research I found what I need — org-clock-get-table-data, a built-in function defined in the org-clock.el[.gz] file (as of Emacs 28.2).

(defun org-clock-get-table-data (file params)
  "Get the clocktable data for file FILE, with parameters PARAMS.
FILE is only for identification - this function assumes that
the correct buffer is current, and that the wanted restriction is
in place.
The return value will be a list with the file name and the total
file time (in minutes) as 1st and 2nd elements.  The third element
of this list will be a list of headline entries.  Each entry has the
following structure:

  (LEVEL HEADLINE TAGS TIMESTAMP TIME PROPERTIES)

LEVEL:      The level of the headline, as an integer.  This will be
            the reduced level, so 1,2,3,... even if only odd levels
            are being used.
HEADLINE:   The text of the headline.  Depending on PARAMS, this may
            already be formatted like a link.
TAGS:       The list of tags of the headline.
TIMESTAMP:  If PARAMS require it, this will be a time stamp found in the
            entry, any of SCHEDULED, DEADLINE, NORMAL, or first inactive,
            in this sequence.
TIME:       The sum of all time spend in this tree, in minutes.  This time
            will of cause be restricted to the time block and tags match
            specified in PARAMS.
PROPERTIES: The list properties specified in the `:properties' parameter
            along with their value, as an alist following the pattern
            (NAME . VALUE)."

Let’s make an experiment.

#+begin_src elisp
(org-clock-get-table-data buffer-file-name '(:tags t))
#+end_src

#+RESULTS:
| /home/magnolia/Desktop/demo.org | 400 | ((1 2023-07 (2023) nil 400 nil) (2 2023-07-03 (2023) nil 310 nil) (3 Impl. a test gRPC server (2023 TEST) nil 310 nil) (2 2023-07-04 (2023) nil 90 nil) (3 Fix client timeout (2023 FIX) nil 25 nil) (3 Add AddOrder handler (2023 FEAT) nil 65 nil)) |

Please note the output is an Org table because the result is a list. Please also note the '(:tags t) parameter — it is required because we want all tags to be included in the output.

Obviously, we actually want the 3rd element of the output list.

#+begin_src elisp
(nth 2 (org-clock-get-table-data buffer-file-name '(:tags t)))
#+end_src

#+RESULTS:
| 1 |                  2023-07 | (2023)      | nil | 400 | nil |
| 2 |               2023-07-03 | (2023)      | nil | 310 | nil |
| 3 | Impl. a test gRPC server | (2023 TEST) | nil | 310 | nil |
| 2 |               2023-07-04 | (2023)      | nil |  90 | nil |
| 3 |       Fix client timeout | (2023 FIX)  | nil |  25 | nil |
| 3 |     Add AddOrder handler | (2023 FEAT) | nil |  65 | nil |

It seems we are on the right way. The column #1 contains the level of the headline, as an integer; #2 — the text of the headline; #3 — the list of tags of the headline; #5 — the sum of all time spend in this tree, in minutes, as an integer.

The Magic

Before implementing the clock table parser, we need some utilities.

First of all we should convert a date from the ISO 8601 format (YYYY-MM-DD) to the European DD.MM.YYYY format. According to the GNU Emacs Lisp Reference Manual, we can use two built-in functions for this purpose:

Function: format-time-string format-string &optional time zone

This function converts time (which should be a Lisp timestamp, and defaults to the current time if time is omitted or nil) to a string according to format-string.

and

Function: date-to-time string

This function parses the time-string string and returns the corresponding Lisp timestamp. This function assumes Universal Time if string lacks explicit time zone information, and assumes earliest values if string lacks month, day, or time.

As we’ll see below, the last sentence (in italic) is wrong — at least as of Emacs 28.2. Maybe it has something to do with this bug in Emacs 28, I don’t know.

Okay, let’s test it out.

#+begin_src elisp
  (format-time-string "%d.%m.%Y" (date-to-time "2023-07"))
#+end_src

Error: date-to-time: Invalid date: 2023-07

This doesn’t work.

#+begin_src elisp
  (format-time-string "%d.%m.%Y" (date-to-time "2023-07-04"))
#+end_src

Error: date-to-time: Invalid date: 2023-07-04

This doesn’t work as well.

This is where the magic begins. Let’s add a fake time component T01 to the ISO date string.

#+begin_src elisp
  (format-time-string "%d.%m.%Y" (date-to-time "2023-07-04T01"))
#+end_src

#+RESULTS:
: 04.07.2023

It worked, I’m so happy.

Now let’s implement a utility function that converts a time, in minutes, as an integer, to the properly padded string.

#+begin_src elisp
  (defun my/clock--format-time (time-in-minutes &optional padding)
  "Convert TIME-IN-MINUTES, as an integer, to a string,
   with hours left-padded with zeroes. Default PADDING is 2."
    (let* ((hours (/ time-in-minutes 60))
           (minutes (- time-in-minutes (* hours 60))))
      (format (concat "%0" (format "%d" (or padding 2)) "d:%02d")
               hours minutes)))

;; TEST
(my/clock--format-time 310)
#+end_src

#+RESULTS:
: 05:10

Okay, it works.

The Result

Now let’s combine everything together and then evaluate the code block.

#+begin_src elisp
  (require 'org-clock)

  (defvar my/cur-date nil "Holds the current entry date.")

  (defun my/clock--format-time (time-in-minutes &optional padding)
  "Convert TIME-IN-MINUTES, as an integer, to a string,
   with hours left-padded with zeroes. Default PADDING is 2."
    (let* ((hours (/ time-in-minutes 60))
           (minutes (- time-in-minutes (* hours 60))))
      (format (concat "%0" (format "%d" (or padding 2)) "d:%02d")
               hours minutes)))

  (defun my/clock--parse-entry (entry)
  "Parse the clock table ENTRY, returning a list of row items,
   depending on the level of the headline."
    (let* ((level (car entry))
           (headline (nth 1 entry))
           (tag (nth 1 (nth 2 entry)))
           (minutes (nth 4 entry))
           (date (if (= level 2)
                     (format-time-string "%d.%m.%Y"
                         (date-to-time (concat headline "T01"))))))
      (cond
        ((= level 1) (list headline "TOTAL" "" (my/clock--format-time minutes 3)))
        ((= level 2) (progn (setq my/cur-date date) nil))
        ((= level 3) (list tag headline my/cur-date (my/clock--format-time minutes)))
      )))

  ;; Apply the parser to every entry in the clock table.
  (mapcar #'my/clock--parse-entry
     (nth 2 (org-clock-get-table-data buffer-file-name '(:tags t))))
#+end_src

#+RESULTS:
| 2023-07 | TOTAL                    |            | 006:40 |
| TEST    | Impl. a test gRPC server | 03.07.2023 |  05:10 |
| FIX     | Fix client timeout       | 04.07.2023 |  00:25 |
| FEAT    | Add AddOrder handler     | 04.07.2023 |  01:05 |

Bingo! We’ve got what we exactly want — the Org mode table filled with properly formatted data. Now I can just copy this table from my work time org file to another org file and export it to the ODT file (and then save it as the MS Word file).

The MS Word file with the work time report.

Tested on Ubuntu Linux (Pop!_OS 20.10) and MS Windows 10 using Emacs 28.2.

Conclusions

We can have access to all the data collected in a clock table.
Org mode code blocks provide an ideal way to make experiments, testing your code, and getting the result inplace.
In Emacs, you can do everything.

Happy emacsing!

A Simple tree-sitter Config That Works

Mon, 05 Dec 2022 14:14:13 +0300

Recently, I’ve discovered a number of posts on Reddit — like tree-sitter-hl-mode does not do anything or How to use Emacs 29 Tree-sitter? — and decided to share my simple tree-sitter setup that seems to be working on my Emacs 28.2 like a charm.

Step 1. OS: Installing the `tree-sitter` app

First of all, I’ve downloaded the latest pre-build binary archive for my system from this GitHub repo, in my case that is tree-sitter-linux-x64.gz because I’m on Pop!_OS 20.10. Then I’ve unpack the archive, put the standalone binary in my $HOME/bin that is in my $PATH and therefore is accessible from anywhere, and changed its mode to executable by chmod +x tree-sitter.

The latest tree-sitter app is installed.

Step 2. Emacs

Step 2.1. Emacs: Installing `tree-sitter` packages

Then I’ve installed tree-sitter (the parsing system) and tree-sitter-langs (the grammar bundle) Emacs packages using package-list-packages.

The tree-sitter packages are installed.

Step 2.2. Emacs: Configuring `tree-sitter`

I’ve added the following lines to my ~/.emacs.

;;;; `TREE-SITTER'
;; 2022-12-04
(require 'tree-sitter)
(require 'tree-sitter-langs)

(global-tree-sitter-mode)

(add-hook 'python-mode-hook #'tree-sitter-hl-mode)

That’s it. Quite simple, isn’t it?

Please pay attention to the last line. It seems that the tree-sitter highlighting mode provided by tree-sitter-hl-mode is not activated when you load a file into the buffer even if the global tree sitter mode is on. Adding the hook for the particular source code mode solves this problem.

Result

Now I have a pretty looking Python code.

More on tree-sitter and its internals can be found at https://tree-sitter.github.io/tree-sitter/.

Happy tree-sittering!

How to Clear the Eshell

Wed, 05 Oct 2022 13:07:45 +0300

I’m a big fan of Eshell, but some things in Eshell look, hmm, a bit strange. One of such things is how the Eshell’s command clear clears the screen.

As it is decribed at the Unix Wiki page, clear is a computer operating system command which is used to bring the command line on top of the computer terminal. The key words are “bring the command line on top”.

The Eshell’s clear works in a different way, it brings the command prompt on bottom, instead.

Using the `clear` command to clear the Eshell screen.

After the `clear`, the command prompt has been moved on bottom.

Just recently, I’ve accidently discovered an unexpected, at least for me, workaround (from this Stackexchange thread). To clear the Eshell screen you just need to type clear 1 instead of just clear.

Using the `clear 1` command to clear the Eshell screen.

After the `clear 1`, it's OK now.

Of course, then I’ve immediately added an alias for clear 1 to my Eshell aliases configuration file ~/.emacs.d/eshell/alias.

alias cls clear 1

More on Eshell aliases you can find in my post Eshell Aliases, Prompt, And Colors.

Perhaps you can use this trick for your eshelling.

Emacs Keyboard Shortcuts

Tue, 06 Sep 2022 15:26:36 +0300

Irreal has recently published a post with a reference to the Vernon Grant’s emacs-keyboard-shortcuts README that contains a list of Emacs keyboard shortcuts Vernon uses on a regular basis.

It’s worth to bookmark it or to download the markdown README locally even if you think you know Emacs very well (there is no such people, though).

Many thanks to both Irreal and Vernon.

Reverso Context in Emacs

Sat, 03 Sep 2022 01:46:36 +0300

If you are an emacser, you are probably already following the Sacha Chua’s blog. If you are not, you should. Sacha maintains an incredible blog on Emacs-related news, upcoming events, Org Mode, configuration, new packages, and many other things from the Emacs world.

English is not my native language so I need the right tools to improve my language skills. My favorite tool is the Reverso web service, an AI-powered service for translation, grammar check, context, and synonyms search.

Of course, I’d prefer to use it in Emacs directly, and in one of the latest Sacha’s posts I found what I had been searching for - reverso.el.

At the time of writing, the package isn’t yet available anywhere but in the author’s GitHub repository, so as a first step you need either to download or to clone this package to your box.

I’ve cloned it to my ~/emacs.d/extras/.

git clone https://github.com/SqrtMinusOne/reverso.el.git

Secondly, you need to add this directory to your load-path and require the package.

(add-to-list 'load-path "~/.emacs.d/extras/reverso.el/")

Almost done.

Because I’m using Reverso quite often, I decided to implement a smart start-up function and to bind it to a common key like <F9>. I want to distinguish between the Translation (applied to a single word) and the Context (applied to a phrase or a sentence) features of Reverso. So now if you press <F9> and there is some region selected (active, in terminology of Emacs), reverso-context is called, else, if no region selected, reverso-translate is called for a word under the cursor.

;; Reverso context
;; https://github.com/SqrtMinusOne/reverso.el
(require 'reverso)

(defun avs/reverso ()
  "Calls `reverso' functions depending on selection.
If a region (selection) is active, calls `reverso-context',
otherwise calls `reverso-translate' for a word under the cursor."
  (interactive)
  (if (region-active-p)
      ;; Region is active, use context.
      (reverso-context)
    ;; Region is not active, get word coordinates...
    (let ((bounds (bounds-of-thing-at-point 'word))
          (p (point))
          )
      (if bounds
          (progn
            ;; ...select the word under cursor...
            (goto-char (car bounds))
            (set-mark-command nil)
            (goto-char (cdr bounds))
            ;; ...and translate it.
            (reverso-translate)
            ;; Then back to the initial position.
            (deactivate-mark)
            (goto-char p)
            )
        (error "No word under cursor!")
        )
      )
    )
  )

(global-set-key [(f9)] #'avs/reverso)

The word 'deposed' is under the cursor, no region is active, <F9> calls `reverso-translate'.

The region 'different kind of weather' is active, <F9> calls `reverso-context'

Many thanks to Pavel Korytov for the excellent packages, and, indeed, to Sacha Chua for pointing it out to all of us.

Using abbrev to Enter Special Characters

Tue, 16 Aug 2022 15:08:36 +0300

As it’s described in the GNU Emacs Manual, an abbreviation or abbrev is a string of characters that may be expanded to a longer string. The user can insert the abbrev string and find it replaced automatically with the expansion of the abbrev. This saves typing.

Mostly I use builtin abbrev package to enter the special characters like greek letters, arrow symbols etc.

Below is my setup of abbrev from my ~/.emacs.

(setq abbrev-file-name                ;; Tell Emacs where to read abbrev
      "~/.emacs.d/abbrev_defs.el")    ;; Definitions from...
(setq save-abbrevs t)                 ;; (ask) save abbrevs when files are saved
(setq-default abbrev-mode t)          ;; Turn it on globally
(if (file-exists-p abbrev-file-name) (quietly-read-abbrev-file))

Here is my abbrev definition file ~/.emacs.d/abbrev_defs.el.

;; Time-stamp: <Last changed 2022-08-16 16:38:50 by magnolia>

(define-abbrev-table 'global-abbrev-table
  '(
    ("8alpha"   "α")
    ("8beta"    "β")
    ("8gamma"   "γ")
    ("8Delta"   "Δ")
    ("8delta"   "δ")
    ("8theta"   "θ")
    ("8ksi"     "ξ")
    ("8lambda"  "λ")
    ("8mu"      "µ")
    ("8nu"      "ν")
    ("8pi"      "π")
    ("8Sigma"   "Σ")
    ("8sigma"   "σ")
    ("8tau"     "τ")
    ("8phi"     "φ")
    ("8psi"     "ψ")
    ("8Omega"   "Ω")
    ("8omega"   "ω")
    ("8in"      "∈")
    ("8nin"     "∉")
    ("8almost"  "≈")
    ("8inf"     "∞")
    ("8deg"     "°")
    ("8cels"    "℃")
    ("8right"   "→")
    ("8left"    "←")
    ("8up"      "↑")
    ("8down"    "↓")
    ("8para"    "§")
    ("8copy"    "©")
    ("8reg"     "®")
    ("8tm"      "™")
    ("8eur"     "€")
    ("8pound"   "£")
    ("8plusmin" "±")
    ("8sup1"    "¹")
    ("8sup2"    "²")
    ("8sup3"    "³")
    ("8ldquo"   "«")
    ("8rdquo"   "»")
    ("8range"   "÷")
    ("8not"     "¬")
    ("8mdot"    "·")
    ("8bull"    "∙")
    ("8accent"  "´")
    ("8mdash"   "—")
    ("8ndash"   "–")))

Just after you type an abbreviation following by either SPC or any punctuation symbol it is replaced by the corresponding character.

Of course, I’ve compiled this setup from various sources, mostly from the Impaktor’s article with some additions.

It’s also worth to read the Xah Lee’s article for more examples of how to use abbrev mode in your daily Emacs life.

Happy abbreving.

Eshell Aliases, Prompt, And Colors

Fri, 22 Jul 2022 13:57:32 +0300

Do you use #Emacs to run shells or terminal emulators? Well, you should. With vterm you have a fast alternative to the builtin ansi-term. And if you prefer shells, you’ve got EShell and Shell Mode. And don’t forget serial-term for embedded programming. — Mickey Petersen (@mickeynp) on Twitter, July 18, 2022.

Eshell Aliases

An excellent post from Mickey Petersen, a famous Emacs guru and the author of Mastering Emacs reminded me to share my eshell configuration.

There are 2 ways to configure eshell aliases. Elsa Gonsiorowski uses a special configuration file ~/.emacs.d/eshell/alias while Howard Abrams prefers to put his eshell alias settings to .emacs or init.el. Personally, I prefer the former approach.

Here is my ~/.emacs.d/eshell/alias.

alias ll ls -AFGhl --color=always $1
alias ff find-file $1
alias e find-file-other-window $1
alias d dired $1
alias gd magit-diff-unstaged
alias gds magit-diff-staged
alias gg git log --color --graph --oneline --abbrev-commit --decorate --all --date=short --pretty=format:"%C(cyan)%h %C(yellow)%ad %C(bold green)%d %C(reset)%s"

Most of these aliases are obvious, e.g. ll prints extended directory listing, ff somefile opens somefile for editing in the same window, e somefile uses other window to edit somefile, d opens the dired buffer in the same window, etc. The last one prints the colorized one-line git log as shown below.

Eshell Prompt

The prompt you can see on the screenshot above is borrowed from the Reddit post with some colors optimized for the Solarized Dark theme.

(setq eshell-prompt-function
      (lambda ()
        (concat
         (propertize "┌─[" 'face `(:foreground "#2aa198"))
         (propertize (user-login-name) 'face `(:foreground "#dc322f"))
         (propertize "@" 'face `(:foreground "#2aa198"))
         (propertize (system-name) 'face `(:foreground "#268bd2"))
         (propertize "]──[" 'face `(:foreground "#2aa198"))
         (propertize (format-time-string "%H:%M" (current-time)) 'face `(:foreground "#b58900"))
         (propertize "]──[" 'face `(:foreground "#2aa198"))
         (propertize (concat (eshell/pwd)) 'face `(:foreground "#93a1a1"))
         (propertize "]\n" 'face `(:foreground "#2aa198"))
         (propertize "└─>" 'face `(:foreground "#2aa198"))
         (propertize (if venv-current-name (concat " (" venv-current-name ")")  "") 'face `(:foreground "#00dc00"))
         (propertize (if (= (user-uid) 0) " # " " $ ") 'face `(:foreground "#2aa198"))
         )))

In addition to the username, the current time, and the current directory it also shows the current Python virtual environment name (in green).

Eshell Colors

The often cited issue with eshell is the lack of color output even if it is explicitly specified in a command (e.g. ls --color=always).

Adding this to your ~/.emacs (or init.el) DOES NOT solve the problem:

(setenv "TERM" "xterm-256color")

THIS DOES solve the problem with color output in eshell:

(add-hook 'eshell-mode-hook (lambda () (setenv "TERM" "xterm-256color")))

Though to get the current directory listing in eshell I prefer to use the eshell alias d (equivalent to d .), see the list of aliases above.

More on Emacs’ eshell can be found here, thanks again, Mickey.

DMS To Decimal Degree Conversions And More

Wed, 22 Jun 2022 14:11:33 +0300

Working with satellite data I often have to convert a coordinate value or an angle value from the DMS notation (degree@minute’second") to a decimal degree in the floating point number format and vice versa.

DMS to Decimal Degree

Of course, I want to do this directly in an Emacs buffer, so I wrote a simple function that uses deg and hms functions provided by the built-in superb calc package.

(defun dms2deg (p1 p2)
  "Converts a region from the DMS (dd@mm'ss\")
  to a decimal degree.
  P1,P2 are the beginning and the end of the region
  (selection) respectively."
  (interactive "r")
  (let (s)
    (if (region-active-p)
        (progn
          (setq s (calc-eval
              (concat "deg(" (buffer-substring-no-properties p1 p2) ")")))
          (delete-active-region)
          (insert s))
      (message "No active region!"))
    )
  )

I’ve bound this function to the Ctrl+F6 key chord (C-f6 in the Emacs notation) globally. Of course, you can use your own key combination.

(global-set-key [(control f6)] #'dms2deg)

Now I can select a region in a buffer, press C-f6 and replace the selection with its decimal value, so 30@15'54" becomes 30.265.

Decimal Degree to DMS

The inverse function (bound to S-f6 or Shift+F6) replaces a floating point with the corresponding DMS string.

(defun deg2dms (p1 p2)
  "Converts a region from a decimal degree
  to the DMS format (dd@ mm' ss\").
  P1,P2 - beginning and end of the region
  (selection) respectively."
  (interactive "r")
  (let (s)
    (if (region-active-p)
        (progn
          (setq s (calc-eval
              (concat "hms(" (buffer-substring-no-properties p1 p2) ")")))
          (delete-active-region)
          (insert s))
      (message "No active region!"))
    )
  )

(global-set-key [(shift f6)] #'deg2dms)

Now if you select a region in a buffer and then press S-f6, your 30.265 becomes 30@ 15' 54."

Enhanced Version

After a while, I decided to enhance the first conversion function by adding an ‘inline calculator’ feature. It works quite simple: if a selected region contains the ‘@’ character, the region is considered as a coordinate (angle) value in the DMS notation, and it should be replaced with its decimal value. Otherwise, the region is considered as an arithmetic expression (in terms of the Emacs’ calc) and its calculated value will be inserted just after the region.

(defun avs/calc-region (p1 p2)
  "Calculates a region or converts DMS to decimal.
   P1,P2 - beginning and end of the region
   respectively."
  (interactive "r")
  (if (region-active-p)
      (let ((b (buffer-substring-no-properties p1 p2)))
        (cond ((string-match-p "@" b) ; convert DMS to decimal ...
               (delete-active-region)
               (insert (calc-eval (concat "deg(" b ")"))))
              (t ; ... otherwise calculate a region
               (goto-char (region-end))
               (pop-mark)
               (insert " = " (calc-eval b))))
        )
    (message "No active region!"))
  )

(global-set-key [(f6)] 'avs/calc-region)

The enhanced function is bound to f6. So now if you press F6, 15@45'20" becomes 15.7555555556, and ((350.0 / 7) + 48.314) becomes ((350.0 / 7) + 48.314) = 98.314.

Conclusion

Emacs’ calc is great.

As a next step, I want to implement DMS and Decimal degree conversions to the DD:MM:SS format used by the excellent Generic Mapping Tools (GMT) toolbox.

I Am Back

Tue, 21 Jun 2022 02:45:58 +0300

I started this blog in 2017. After a long break, I decided to continue blogging about various things related to Emacs. And not just to Emacs.

Also, I’ve switched from Jekyll to Hugo for a variety of reasons, mainly because of the Mainroad theme.

About

Sat, 17 Jun 2017 14:51:33 +0300

About The Emacs Cat My first attempt to dive into the vast ocean of Emacs was in 1997, over 25 years ago. My first attempt was unsuccessful; I now realize I couldn’t fully grasp the spirit of Emacs at the time. My second—and successful—attempt came in 2012. Since then, I’ve been using Emacs for nearly everything, from coding in C++ and Python to maintaining my knowledge base with org-roam and writing articles in LaTeX.

The Emacs Cat

Emacs, Software Development, and LLM

Part 1. Emacs and Software Development

Part 2. Software Development and LLM

My Emacs IBuffer Configuration

Prettifying the IBuffer Window

IBuffer Configuration

IBuffer. Click or tap to view the full-size picture.

Casual IBuffer

Casual IBuffer. Click or tap to view the full-size picture.

My Emacs Org Configuration

Org-mode

Common Settings

Hide Emphasis Characters

Better List Bullets

Better Header Bullets

Source Code Blocks

Org Agenda

Theme Specific Settings

Some Custom Face Settings for Org-mode

Screenshots

Org mode w/ code blocks. Click or tap to view the full-size picture.

Org agenda w/ diary. Click or tap to view the full-size picture.

Making a Multiplatform Emacs Configuration

Introduction

Paths

OS-Specific Key Bindings

macOS

OS-Specific Tweaks

Microsoft Windows

Linux

Font Size

Summary

Windows Navigation in Emacs

Window labels are in the top left corner of each window (shown in red). The frame is dimmed when activating `ace-window`.

Emacs Time Stamp

Examples

ELisp

Org Mode

C++ source code

Elfeed-optimized Blogging

Using Emacs Org Mode for Reproducibility Testing

The Server

Click or tap to view the full-size picture.

The Client

Listing of available services at localhost port 50051

Inspecting helloworld.Greeter service

Inspecting helloworld.Greeter.SayHello method

Querying the server

Click or tap to view the full-size picture.

C++ Programming in Emacs

Choosing a Language Server

Configuring clangd

Emacs Configuration for C++

Using Eglot

Visual Improvements

C++ Headers

Code Styles

Indentation Inside of Namespaces

Spaces vs Tabs

Trailing Tabs and Spaces

Clangd with Flymake

Click or tap to view the full-size picture.

Treemacs

Code Completion

Click or tap to view the full-size picture.

Code Navigation

Click or tap to view the full-size picture.

Click or tap to view the full-size picture.

Appendix A

All the Icons

Appendix B

A Note for Tree-Sitter Users

Python Programming in Emacs

Choosing a Language Server

A note on the Tree-Sitter package

Python prerequisites

Error checking with Pyright

Pyright LSP with Flymake

Click or tap to view the full-size picture.

In the `.emacs` init file

`dired-mode` enhancements

Some other `dired-mode` enhancements

Run `eshell` in the current `dired` directory

Step 1. OS: Installing the `tree-sitter` app

Step 2.1. Emacs: Installing `tree-sitter` packages

Step 2.2. Emacs: Configuring `tree-sitter`