Ruslan's Tech Blog

Emacs: goto-address-mode

Sun, 05 Apr 2026 14:12:53 +1000

In one of my previous blog posts I mentioned a command that returns the list of all open pull requests I have ever created on github:

gh search prs --author @me --state open --json title,url --template '{{range .}}{{.title}} - {{.url}}{{"\n"}}{{end}}'

I wrapped this command into krydos/show-my-prs elisp function that just executes the above’s snippet using async-shell-command.

Here is its output:

Looks great and already useful for me but what’s missing is clickable links.

Turns out Emacs, as usual, have a built in answer.

The mode is called goto-address-mode. Just turn it on in the buffer and all the links become clickable (you can also C-c RET on them).
Look:

Emacs is the best!

Emacs: Dumb Jump Is So Good

Sat, 03 Jan 2026 21:22:17 +1100

There is a library I rely on constantly in my day to day computing, at work and at home. This library is called dumb-jump.

I don’t see it is prized as often as Magit for example, which made me write this post.

Below I explain what it does but first, let me thank to Jack Angers and all the contributors. I have used this library for 10 years. It is one of the best computer programs I have ever used. There were periods when I was off Emacs during that time and the first thing I looked for in other editors was a plugin similar to dumb-jump.

What does it do

It jumps to definition of a function/method/class.

Here is my config for it:

(use-package dumb-jump
 :ensure t
 :config
 (add-hook 'xref-backend-functions #'dumb-jump-xref-activate)
 (setq dumb-jump-force-searcher 'rg)
 ;; use completion-read instead of a separate buffer with candidates
 (setq xref-show-definitions-function #'xref-show-definitions-completing-read))

Combined with rg it eliminated my need in LSPs or ctags/etags entirely.

Here is me using it on Emacs source code, which is big code base (click to view the video in a separate tab):

In this video I:

press M-. to go to definition.
In less than a second I get matching definitions that I can filter if necessary.
I jump straight to the definition.

How does it work

It just greps the entire project for the symbol at point. The best thing about it is that with LSP for example it’s impossible (or rather I haven’t seen it working) to place my cursor over a function name in a comment somewhere and jump to it.

Like in:

/**
 * This test function is cool but
 * check another_function_name for more info
 */
 function test() {}

With dumb-jump - I can place my cursor at another_function_name, press M-. and I’m looking at the definition of it.

It works with ANY programming language.

Why not

ctags/etags

Every time a file is changed the ctags table must be regenerated. It can be automated but I think it’s unnecessary overhead.

LSP (Eglot)

I love LSP as a technology but I don’t want a background process to run on my machine while I’m working on a project. What if during the day I work on 10 projects, which is real for me at work for example. It will spawn 10 background processes for different languages that I have to mentally track (because I do mentally track what’s running in my computing environment).

The amount of RAM and CPU spent on this just feels too expensive.

Summary

If for some reason you haven’t tried this library - try. It’s so good.

I wish I can find better words on how grateful I am that it exists. Thank you!

Emacs: find-file-at-point trick

Wed, 05 Nov 2025 16:29:36 +1100

The story

Sometimes I hover over a file path in my terminal emulator (in Emacs of course) and type
M-x find-file-at-point. It’s nice command and it works reliably.

I don’t want to type it though. I want Emacs to detect a file path at point.

And there is a built in package for this. Just add this line to your init.el and it should work.

(ffap-bindings)

This makes C-x C-f keybinding to automatically detect a file path at point. Cool!

The twist

Unfortunately it was so much worse than what I’ve expected.

It does detect file path at point so reliably and so often (there are lots of file paths in my terminal output usually)
that almost 80% of time when I press C-x C-f my minibuffer is already pre-filled with the path my cursor happened to be on, which I didn’t need. I wanted it to be clean so I could type a file path there by myself.

I noticed that using ffap package adds a bit of cognitive overload for my workflow. I have to always think about where my cursor is before I press C-x C-f.

I decicded to write my own function that should check for current-prefix-arg and call find-file or find-file-at-point accordingly but just before that I decided to read some docs.

RTFM

Something that I don’t think I’ve ever done is C-h f find-file.

I learned this keybinding early on in my Emacs journey and never needed to read a documentation for it.

But if I read it, it says something about M-n keybinding that uses functions defined in file-name-at-point-functions variable. One of them, by default, is ffap-guess-file-name-at-point.

So having my cursor at a file path, I can type C-x C-f get my regular find-file behavior and then I can just press M-n and the minibuffer will be pre-filled with the file path at point.
^here is how small this blog post could be lol

Perfection.

Emacs: Keep journaling on the go

Sun, 27 Jul 2025 16:35:19 +1000

I’ve been journaling a lot for many years. It cools down my brain a little and helps me reflect on things better. Emacs and org-mode are of course the tools I use to journal.

The problem

I can’t easily journal on the go when I only have my phone handy.

Solution

I’ve built incredibly minimal web page with a simple form. When the form is submitted it is captured by a script, parses the form data and calls my Emacs with --eval to add the form data into my journal.org file.

And when I say minimal I mean it. Just look at it.

Here is its whole source code:

<html>
 <head>
 <meta name="viewport" content="width=device-width, initial-scale=2.0, maximum-scale=4.0">
 </head>
 <body>
 <form action="" method="post">
 <input name="title" type="text"/><br/>
 <textarea name="content"></textarea><br/>
 <button>submit</button><br/>
 </form>
 </body>
</html>

<?php
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
 $title = addslashes($_POST['title']);
 $content = addslashes($_POST['content']);

 # In actual file it's a oneliner.
 # I split it for this post purposes.
 # Hope it still works in case you decide to copy/paste.
 $cmd = "emacs --batch --load=\"~/.emacs.d/init.el\" --eval \"";
 $cmd .= "(progn ";
 $cmd .= " (org-capture nil \\\"j\\\")";
 $cmd .= " (insert \\\"{$title}\\\")";
 $cmd .= " (end-of-buffer) (org-return) (org-cycle)";
 $cmd .= " (insert \\\"{$content}\\\") (org-capture-finalize))\"";

 shell_exec($cmd);
}
?>

I start it with php -S 0.0.0.0:8080 and it just works. It knows what templates I use and it knows where the org-directory is.
I deployed it to my home server (just a laptop in my closet) and run it using Portainer.

My home server is constantly available for me thanks to Tailscale so I can access it outside of my home.

Why not

Why not Orgzly

Orgzly, for those who doesn’t know, is an Android app that allows to interact with org-mode files. One can import org files in it and then just update them on the go. Synchronization among machines can be done with Syncthing.

It’s very good app and I was using it for journaling a lot. Often times though, I want to add a note to my journal and then I realize that I need to create all the subheadings for today manually to follow the format I defined in my org-capture-templates. Not a big deal and it worked for awhile but it stopped me from dumping my thoughts into the journal quite a few times.

Why not Emacs on Android or Termux + Emacs

Both are great solutions as soon as one plugs in a keyboard into their phone. Using Emacs on a touch-screen is of course possible but the amount of frustration I get in the first 10 seconds of using it feels very much unjustified.

Why not run the same script on your phone locally

In this case I don’t need the whole home server setup with tailscale and portainer. Just syncthing which I already have would do the job.
Good point. I just wanted to have a bit more fun than that :)

Newsticker - Emacs built-in RSS reader

Wed, 09 Apr 2025 16:47:34 +1000

I’ve been browsing Emacs’s The Info Directory (C-h i) the other day and came across a menu item called Newsticker.

Turned out is a built-in RSS reader I never heard of. I know Emacs has Gnus which I tried to use as RSS reader before but didn’t succeed. Then, as probably most of Emacs users, I moved to Elfeed which is great.

Here is how Newsticker looks like:

isn’t it nice? You can open it with M-x newsticker-show-news.

It’s been a few weeks since I decided to use it.

Navigation is very simple:

f and F for switching feeds forward/backward
n and p for switching posts
<RET> to read full article

Configuration

Setting feeds is only slightly different from Elfeed:

(setq newsticker-url-list '(
 ("Planet Emacslife" "https://planet.emacslife.com/atom.xml")
 ("<name>" "<url>")))

Also when q is pressed the whole Newsticker is closed BUT its buffers are still there which I don’t really like.

So I came up with this elisp:

(defun my/close-newsticker ()
 "Kill all tree-view related buffers."
 (kill-buffer "*Newsticker List*")
 (kill-buffer "*Newsticker Item*")
 (kill-buffer "*Newsticker Tree*"))

(advice-add 'newsticker-treeview-quit :after 'my/close-newsticker)

Now when newsticker-treeview-quit function is called the Newsticker buffers getting killed too.

Why use built-in tools

I remember I’ve read, I think in Irreal’s blog about not understanding some people’s obsession to use built-in tools in Emacs.

I can’t quite explain it either but I do feel drawn towards built-in tools too haha.

Naturally I try to track/think about every extension I add to my config to make sure it’s up to date, not abandoned, supports my version of emacs, how much dependencies it has, etc. And even when everything is ok, I still feel like someone can take it from me if let’s say a maintainer will decide to archive the project or something.

It just sits in my brain on the background and slowly drains my energy. It’s maybe silly reason but I just feel more vulnerable with more dependencies.

Anyways, I suggest you to try Newsticker, it’s very interesting mode.

Emacs: glasses-mode

Mon, 24 Feb 2025 00:00:00 +0000

Let’s say I have this code (TypeScript) with long camelCased variable names.

I’m ok with camelCase variables especially if this is a convention for a language. But at the same time I find it a bit difficult to read compared to underscore_case style.

Meet M-x glasses-mode.

A beautiful minor mode that is there, built-in, since Emacs 21. Look what it does

The mode doesn’t change text in the buffer. It just makes it look like camelCase variable names became underscore_case. It is possible to keep editing the buffer and variable names will adjust on the fly. You can use your M-x rg or M-x grep and they will search for the text under cursor in camelCase because, again, text in the buffer isn’t changed.

Amazing.

Emacs: quick-calc

Sun, 22 Dec 2024 00:00:00 +0000

You probably have heard about famous emacs M-x calc. I always wanted to become a poweruser of it but never could. My needs are too simple for it, I just want to quickly add/subtract numbers.

Recently I’ve discovered built-in M-x quick-calc which is perfect for what I need. It is already bound to C-x * q.

You can quickly calculate what’s needed and the result is going to be saved to the kill-ring. You can paste the result in place if you want by prefixing the command with C-u.

Emacs has everything :)

Emacs: which-function-mode

Fri, 02 Feb 2024 00:00:00 +0000

The problem

I sometimes work with long functions or big org subtrees and it’s not always clear what function or org subtree I’m in right now. I wish there is a package that can show me what function I’m in.

which-function-mode

Turns out Emacs has this mode built-in so this functionality is just M-x which-function-mode away. It shows in the status line a function name I’m currently in (see [encode_terminal_code] on the screenshot above). It’s global mode so as soon as it’s enabled, you’ll see it’s working for every buffer. You can have it enabled on Emacs startup by adding (which-function-mode) to your config file.

I just started to get benefits of this mode but it’s already surprising how well it works:

it works in various prog modes
it works in org mode
it even works in markdown files

It doesn’t seem to work in html files I tried it with or modes that use html (e.g. vuejs or laravel blade files).
It definitely not an issue for me so I’m going to continue using it and I suggest you to try it out.

Emacs: Did you know about IBuffer?

Wed, 15 Nov 2023 00:00:00 +0000

The problem

Sometimes I use C-x C-b to get list of buffers so I can clean it up a little after some time. To do it I mark some buffers with d (to delete) and then press x.

Today I wanted to filter that list of buffers to a particular project/folder and turned out I can’t.
There is no way to filter *Buffer List*.

IBuffer

If you look up for Buffer Menu in EmacsWiki you’ll find the Enhancements section which mentions IBufferMode which is built-in since Emacs 22.

This mode is literally Buffer Menu on steroids. Looks pretty much the same so from UI perspective you’ll see no changes (almost).

To filter buffers by directory just type / F and enter the project/folder name. The only thing left is C-x h d x to mark all buffers and delete them.
To remove all the applied filters just do / /.

The number of filtering commands available by default is great.
You can find them by C-h m (describe-mode) and then look for “Filtering commands” section. Go through other sections as well to get more familiar with ibuffer capabilities.

Doom & Spacemacs

If you’re Doom user you probably already enjoying this mode since it’s enabled by default.
In Spacemacs you can enable it by turning on ibuffer layer.

Both of these config distributions remap standard C-x C-b to call ibuffer and I suggest you do the same if you use custom config like me.

Emacs find-grep-dired: Filter files based on content

Tue, 17 Oct 2023 00:00:00 +0000

Intro

We all need to search in files sometimes, right?

I usually do it using grep -ri 'search term' . in the terminal (often in vterm-mode) and then I either open the file(s) in Emacs or in any other program.

But Emacs has better solution to it.

find-grep-dired

There is M-x find-grep-dired already built-in to Emacs. If you call it from Dired buffer it will auto-complete the current folder and then you just need to enter the search term.

Cool thing is that result of this function is just filtered Dired buffer which means you can perform regular Dired operations on the found files (delete them, move to another folder, etc).
This especially come in handy if you have (setq dired-dwim-target t) and another Dired buffer opened in split so you can quickly move files between splits (Far/Total Commander style).

Configuration

M-x find-grep-dired is as quick as grep is.
According to this function’s help page you can change grep-program variable if you want to use rg, ag or whatever…
CAUTION: It’s pretty possible grep-program may be used by other Emacs functions that may expect grep-specific output.

Emacs has built-in thread macros

Sun, 28 May 2023 00:00:00 +0000

Intro

Surprisingly for me I just discovered that Emacs Lisp has equivalent of Clojure’s -> and ->> macros.

And I’m not talking about dash.el. I’m talking about built-in thread-first and thread-last.

What are these

If you’re not familiar with these beautiful macros, the main goal is to pipe a value through multiple functions and return the result.

-> passes a value as first argument of next function, then takes the result and passes it as first argument to next function, etc.
->> does the same except that it passes the result as next function’s last argument

Example

Instead of having this:

(+ (- (/ (+ 5 20) 25)) 40)

we can have this:

(->
 5
 (+ 20)
 (/ 25)
 -
 (+ 40))

It’s way easier to modify and which is even more important - to read.

Emacs lisp equivalent

There is dash.el library that provides us with similar macros (and many more) but emacs has built-in thread-first and thread-last.

(thread-first
 5
 (+ 20)
 (/ 25)
 -
 (+ 40))

will work for you if you’re on Emacs 25 or newer.

I don’t write much elisp but every time I do I feel like I miss those ->/->>.

Not anymore!

Emacs: A few issues of Org-Roam

Thu, 25 May 2023 00:00:00 +0000

Intro

It has been almost a year since I started to use Org-Roam. I initially migrated from Obsidian even though I was incredibly happy with it.

Recently I started to take more notes than usual and noticed that Org-Roam has some issues that for me aren’t critical but disturbing.

Issues

No build-in search functionality

There is just no something like M-x org-roam-search.

I’m pretty sure there is no such thing because it’s Emacs and you can search any directory you want very quickly using built-in grep, rgrep or other tools like that. And of course you can make a function off of that and then bind it to a key chord you like.

But having such function already there will not force Org-Roam users to add more lines to their config.

org-roam-node-insert - don’t understand a word at point

org-roam-node-insert is very useful. Is how you link notes together.

At the moment when note is typed I usually quickly review it and then connect it to other notes. In such a case I move my cursor to a word that I’m going to use as a link and type that command.

The minibuffer starts listing all the notes but the “linking word” my cursor is at isn’t used.

There is no such issue in case you mark a word and then call M-x org-roam-node-insert.

Again, since it’s Emacs it should be quite easy to fix.

It would be nice to have it default though. I can’t find arguments against it.

Note creation date

Yes, it is in a file name BUT

if you use grep or even something like consult-grep for searching in your notes you will not be able to filter your results by a date.

It probably can be fixed with org roam templates.

Note IDs

I was able to find many complains about it.

For me it’s not that serious in terms of fear that my notes and links may stop working if I loose the roam db (the db is just a cache) or roam is not supported anymore (org files are text).

The main issue for me here is that I can’t understand the links if I open my notes in an editor that doesn’t have Org Mode. It sometimes happens. It happens on my Android. It happens on my Windows machine that I barely use and I don’t even need Emacs there.

In such a case I see the link with an ID and description of that link which sometimes doesn’t exactly match a note file name.

If org format is pure text and intended to be human readable, it’s probably should stay this way.

Conclusion

It should be understood that Org-Roam is open source and community driven. It definitely can be improved as, probably, any software.

The only person I can blame for not implementing those functionalities I mentioned is me. The project is opened for everyone to contribute (including me) so I hope I can fix those things somehow.

Org-mode archive with inherited tags

Fri, 19 May 2023 00:00:00 +0000

The issue

By default only the tags directly attached to an org record will be saved in the archive file. I want to keep all the tags attached to an org record when I archive it, even the inherited ones.

Explanation

In org-mode tags are inherited by default. In case of org tree like this:

* Header1 :tag1:
** Sub Header1 :subtag1:

you may find that Sub Header1 has :tag1:subtag1: tags attached to it.

This is something reflected in Agenda view. Also if you try to find headers with :tag1:
the Sub Header1 will be one of those even though we didn’t directly attach that tag to it. That’s the tag inheritance.

If you try to archive Sub Header1 you will get this kind of record in the *_archive.org file:

* Sub Header1 :subtag1: <--- this is the tag
 :PROPERTIES:
 :ARCHIVE_TIME: <date>
 :ARCHIVE_FILE: <original org file>
 :ARCHIVE_OLPATH: <org path>
 :ARCHIVE_CATEGORY: <org file category>
 :ARCHIVE_ITAGS: tag1 <--- this is the inherited tags
 :END:

As you can see the tag1 is missing in the heading. It is available in the ARCHIVE_ITAGS though. For me it would be much better if I can see all the tags immediately in the record heading. It will also allow me to filter my archived records by those tags.

Solution

(setq org-archive-subtree-add-inherited-tags t)

It’s as easy as that. Now the archived heading will look like this:

* Sub Header1 :tag1:subtag1:

which is exactly what I wanted.

Doom Emacs Search Documentation

Sat, 13 May 2023 00:00:00 +0000

Just a quick note on how easy it is to actually navigate Doom Emacs documentation and modules.

I initially was a little afraid that I will not be able to understand what each Doom module does and there always will be some hidden functionaltiy that will be hard for me to find.

Fortunately there is M-x M-x doom/help-search-headings that allows me to search through Doom documentation. Specifically it allows me to search through org headings of the documentation.

I can easily find a module I’m interested in, let’s say lsp. Then I’ll go there and I can see all the documentation of the module. I can see what packages will be installed and what configuration options available for the module (e.g. +eglot for lsp). Being in the README.org of a module I can also open config.el which is in the same directory and I’ll be able to inspect all the Elisp that module will add into my Emacs.

If you’d like to search not just headings but everything then M-x doom/help-search is your friend.

I start to like Doom more and more every day.

Doom Emacs - Turn LSP off by default for PHP files

Tue, 09 May 2023 00:00:00 +0000

I’m trying to get used to Doom Emacs and one issue I have is that LSP (in my case Eglot) starts automatically when I open up a php project.

I don’t really like it because sometimes I open php files that I don’t need autocompletion for and I don’t want to remember that there is Eglot process now running that I have to stop to save some resources of my laptop.

It happens because I have defined php module in init.el as (php +lsp). The reason I have it defined like this is because I need LSP. I just don’t want to start it automatically every time I open a php file.

I like how easy it is in Doom to inspect the module implementation so I went to Doom’s modules/lang/php/config.el and I found that there is no flag that can force LSP to not start automatically.

What it has though is this line:

(add-hook 'php-mode-local-vars-hook #'lsp! 'append)

It looks to me like something that starts the LSP automatically. It looks like this mostly because everything else looks pretty much unrelated to LSP.

Since there is no flag, let’s solve it in our own config by directly removing that lsp! piece from that variable:

(after! php-mode
 (remove-hook 'php-mode-local-vars-hook #'lsp!))

This will remove that lsp! piece from php-mode-local-vars-hook and now LSP won’t start automatically.

It would make sense probably to add such a flag so users can easily turn off the auto-LSP but at the same time solution to this is just one line so maybe it wouldn’t make sense to add it.

Trying Doom once again

Mon, 08 May 2023 00:00:00 +0000

Almost a year ago I already tried to start using Doom config which I eventually replaced with my own vanilla config.

Today I decided to try it once again. I also wanted to use it in Evil mode to make my hands feel better.

One of my main pain point with someone else’s config is that I don’t know how to handle it, what options are available and why things work in the way they do.

Since I was on my own config for quite some time I believe I know enough about Emacs configuration to attempt Doom config once again.

First impression

Well, it’s not first. If I’m not mistaken it’s my third or fourth attempt to use Doom.

So far it feels ok. I ported some configuration from my vanilla config. Added packages I need and things seems working smoothly.

It’s interesting to see that Doom preferably switched to project mode instead of projectile at least this is what I see based on keybindings that are set for project mode and no keybindings at all for projectile.

My custom org agendas and some other custom functions were ported with just simple copy-paste technique.

What I like

It’s really great to see the M-x doom/help exists. Everything is documented or at least most of the things.
There is also M-x doom/help-search which is very useful when you need to find a specific help.
- The documentation can be improved probably. There is no info about how to change evil escape sequence to something different from default. At least the doom/help-search mentions the evil-escape package which user then can google and find how to change that escape sequence.
I love doom modules. Community has already spent good amount of time tweaking every module and in most of the cases I don’t need to do much to reconfigure it.
LSP module is nice and works with Eglot. What’s great is that other modules (like PHP for example) already aware that LSP module can use Eglot and when I open a php file my Eglot just starts and works.
Evil mode and all keybindings that already configured are incredible.
General look and feel is way better than I could achieve with my vanilla config.
Org looks great and evil keybindings are very nice configured.
I like the way configuration works and some useful macros provided by Doom

What I need to understand/change

Documentation is sometimes lacking. That’s hopefully something I can help with.
I don’t like that LSP/Eglot starts automatically. I do believe “start automatically by default” is a good choice though.
There are no projectile keybindings and there is no my favorite projectile-run-vterm. Easy fix though.
I don’t really understand a point of +vterm/toggle. It works great in one project but when I open a second one then this function still opens up the vterm that belongs to that first project.
doom/reload-theme - probably doesn’t work on my end. When I set doom-theme variable to something else/non-default and then call M-x doom/reload-theme nothing changes. I have to use M-x consult-theme to actually change a theme.
I still need to figure out how to use after!. I initially thought that this macro’s first argument is something that is mentioned in init.el -> doom! call but apparently I should specify an emacs package name there.

Conclusion

In general, I love the feeling. It took me almost no time to get used to vim keybindings and keep coding like nothing’s changed. Probably my vim past is already too deep in my muscle memory. I’m glad my emacs past is also quite deep so I feel like I can seamlessly switch from one way of editing to another.

Org Agenda - show archived records by default

Thu, 13 Apr 2023 00:00:00 +0000

If you didn’t know, there are two methods of archiving subtrees in Emacs’ Org-mode.

Internal archiving (mark an item as ARCHIVED but keep it in the file)
Moving subtrees (move an item or subtree to *_archive.org file)

I often use the latter but the issue here is that all my items got disappeared from Org Agenda view when archived.

You can tell Org Agenda to show archived records by pressing v A in *Org Agenda* buffer. Notice upper-cased A. If you use lowercase a then only internally archived records will be shown.

What v A does is it calling (org-agenda-archives-mode 'files) which internally sets org-agenda-archives-mode variable to t.

This is what we can do in our init.el:

(setq org-agenda-archives-mode t)

Done!

Emacs & Wgrep

Tue, 11 Apr 2023 00:00:00 +0000

So I just discovered wgrep mode of a grep buffer in Emacs and it’s incredible.

I often use projectile-ripgrep if I need to find something in the project I’m working on. But if I wanted to rename some variables or strings that I grepped I had to go and manually update them or use something like projectile-replace.

But turns out there is wgrep mode that is available from projectile-ripgrep (*rg*) buffer or from *grep* buffer.

In case of you ripgrep you just press letter e and now you can edit anything you want. Then you press C-x C-s and now all the changes are made. Amazing.

Here is an example. Let’s try to find and replace projectile- string in this blog:

Here is what was found (image is clickable)

now I press e and I can edit the buffer. It says this in the message area:

Now I changed few occurrences of the projectile- to project- and pressed C-x C-s and now those two files are edited without me even visiting them.

You can save all unsaved buffers with C-x s

Incredible discovery. I’m going to use it all the time now.

I’m not sure though what kind of feature is this. It’s not a package that I had to install. It’s just there and it works.

Emacs 29 - Straight.el & Native compilation

Sun, 09 Apr 2023 00:00:00 +0000

I just built emacs-plus@29 on my MacOS using --with-native-comp just to see what it is and how it works.

I’ll talk about my impression of it later. Let’s start with the issue.

I use straight.el + use-package and as soon as I started my new Emacs instance I’ve got this:

Debugger entered--Lisp error: (void-variable native-comp-deferred-compilation-deny-list)
straight--build-native-compile((:type git :host github :repo "radian-software/straight.el" :files ("straight*.el") :branch "master" :package "straight" :local-repo "straight.el"))
straight--build-package((:type git :host github :repo "radian-software/straight.el" :files ("straight*.el") :branch "master" :package "straight" :local-repo "straight.el") nil)
#f(compiled-function () #<bytecode 0x13b193a2e77f4e46>)()
straight--transaction-exec(use-package-\"c809124e9c5270ea1c72e2c3507331d1\"-nil-nil :now #f(compiled-function () #<bytecode 0x13b193a2e77f4e46>))
straight-use-package((straight :type git :host github :repo "radian-software/straight.el" :files ("straight*.el") :branch "master"))
load-with-code-conversion("/Users/krydos/.emacs.d/straight/repos/straight.el/..." "/Users/krydos/.emacs.d/straight/repos/straight.el/..." nil t)
load("/Users/krydos/.emacs.d/straight/repos/straight.el/..." nil nomessage)
(let ((bootstrap-file (expand-file-name "straight/repos/straight.el/bootstrap.el" user-emacs-directory)) (bootstrap-version 6)) (if (file-exists-p bootstrap-file) nil (save-current-buffer (set-buffer (url-retrieve-synchronously "https://raw.githubusercontent.com/radian-software/..." 'silent 'inhibit-cookies)) (goto-char (point-max)) (eval-print-last-sexp))) (load bootstrap-file nil 'nomessage))
load-with-code-conversion("/Users/krydos/.emacs.d/init.el" "/Users/krydos/.emacs.d/init.el" t t)
load("/Users/krydos/.emacs.d/init" noerror nomessage)
startup--load-user-init-file(#f(compiled-function () #<bytecode 0x155c027c85bc7d>) #f(compiled-function () #<bytecode -0x1f3c61addc0da035>) t)
command-line()
normal-top-level()

It looks like for some reason straight.el expects native-comp-deferred-compilation-deny-list variable available in Emacs while this variable was renamed to native-comp-jit-compilation-deny-list.

Straight.el’s master branch doesn’t know about the rename but the develop branch does. So to switch straight.el to newer branch we can define straight-repository-branch somewhere on the top of our init.el like so:

(setq straight-repository-branch "develop")

I also removed my ~/.emacs.d/straight directory to make sure every other package will be pulled from scratch and there are no conflicts between my current version of Emacs and the older one (28).

Native compilation impression

I’m not sure about it. Since I use my own config and I don’t include that many packages everything was quite quick even without the --with-native-comp. With native compilation I don’t see the difference, maybe I’ll notice it later.

What I noticed is that when I first started my Emacs 29 the compilation process was running on the background (without indication) and the whole UI was sluggish. Switching buffers was slow, reaction to my keystrokes was delayed, etc. But in few minutes, I believe when everything was compiled, everything started to work as usual, no delays, no issues.

Search for hash(#) sign using Emacs' consult-grep

Mon, 03 Apr 2023 00:00:00 +0000

This is something I came across recently. I wanted to search for #todo using M-x consult-grep.

My initial #todo query didn’t work obviously because # sign in consult is a punctuation character as they call it.

I didn’t really want to change # sign as a punctuation character because I used to it. I’m not also sure if there is such an option (read til the end to find out why)

After some time spent googling I couldn’t find how to do escape it. Obvious things like #\#todo didn’t work.

Then I found this example in consult readme:

/defun/consult: It is also possible to use other punctuation characters.

This is not somewhere on the top of the readme. It’s under Asynchronous Search section which I ignored while I was looking for my use case.

So it seems like any NON [A-Za-z0-9] character can be a punctuation character. Though I’m not sure about it.

In any case /#todo worked nicely but it was unnecessary hard to find the proper syntax for it.

Emacs. Change inner/outer like in Vim

Tue, 17 Jan 2023 00:00:00 +0000

If you’re a former Vim user there is one feature I couldn’t find in any other editors.

Not sure what is the proper name of it but let’s call it change inside something.

Example (| - is a cursor):

function() {
 return 'hello |world'
}

If I press ci' the result is going to be:

function() {
 return '|'
}

or ci{:

function() {|}

That’s incredibly useful feature because I don’t really need to think where my cursor is. I just place it somewhere around the place I need to remove and press that magical keybinding.

There is no such built-in function in Emacs. And this one is probably the only feature I miss the most.

For some time I’ve been using expand-region by Magnar Sveen which is a different thing really. It just expands a selection by some logical semantic blocks and can be used as a replacement to that ci'. But still I need to think how many times I should call that expand-region function before the thing I need is selected.

So today I discovered change-inner.el by already mentioned Magnar Sveen. It uses expand-region internally and does exactly what ci<symbol> does.

Bindings suggested in the package readme, M-i / M-o, are pretty easy to used to.

So if you ever missed that change inner/outer Vim feature give this lib a shot.

Ditching Doom

Sat, 04 Jun 2022 16:00:00 +0000

In my previous post I’ve been talking about Doom config and that it is great and all but I find it really difficult to fix issues there. Doom has a lot of its own configuration, hooks here and there and functions that modifies standard behavior.

It’s probably much easier to go with my own config. I never could stick to spacemacs or doom. I couldn’t stick to similar configs in Vim too. Probably issue on my end :)

Also Doom’s evil mode feels so verbose. It definitely feels more verbose than Vim itself. It feels like I have to press much more keys to tell emacs to do something.

At the moment I’m on my own config WITHOUT evil-mode and interesting to note, my muscle memory switched to Emacs-mode in ~30 minutes. I didn’t expect that. For most of the actions there is no a “thinking process”. They just happen. Last time I used Emacs was couple of years ago and I’m surprised it’s keybindings went that deep in my muscle memory.

Maybe, which is strange for me to admit, the keybinding design in Emacs is a feature…

Anyway here is some highlight of my config:

UI is standard-minimal. No toolbar, no scroll-bar, no bells. Automatically start maximized
MacOS’ CMD key is bound to meta
Trailing spaces are deleted with delete-trailing-whitespace on every buffer save
Indent with spaces by default
Vertico for vertical completion (like helm or ivy)
Consult for some nice functions like consult-imenu or consult-buffer
Orderless for fuzzy-like autocompletion
Projectile
Magit
Flycheck
Company
Vterm - possibly the greatest terminal emulation in Emacs I could fine
Prodigy - love this tool. Allows you to manage services running on your machine.
various lang modes

What’s pretty interesting and I couldn’t expect I’d like is a white color scheme.

All of those are working pretty well and if I need to override some of their behavior it usually something super simple, unlike Doom or Spacemacs where some functionality overridden by the “package” configuration that you gotta go and inspect and then find some hooks that also adds additional layer of configuration.

Screenshot (click to zoom):

Getting back to Emacs

Sat, 14 May 2022 00:00:00 +0000

I do change my workflow from time to time to keep myself in shape.

Now, once again, I’m trying to switch back to Emacs. This time I decided to go with Doom. I already tried to install use it but it didn’t work well for me and I didn’t bother to change the configuration.

Main functionalities I need

Quick search in a project

That’s something I used ag for in my Vim. I could easily look for a word under the cursor everywhere in the project.

Projectile fortunately have something like this as well and I can search for word under cursor with SPC-*. The issue though is in PHP the word under cursor was including $ sign which is not want I wanted.

Fixed by excluding $ sign from part of a keyword

(after! php-mode
 (modify-syntax-entry ?$ "." php-mode-syntax-table))

Git interface

I usually use git in terminal to create a branch, for merging, branch switching. But I need a quick way to stage files and write commit messages.

Magit is definitely the suits my needs here.

Multiple cursors

Doom has multiple-cursors package. For some reason it doesn’t bind anything and I had to manually bind M-d to evil-multiedit-match-and-next

Tasks management / Notes

Well, in Vim I didn’t have any good tool for this. I usually switched to Obsidian to take notes.

With Emacs there is org-mode and that’s the primary reason why I’m even switching to Emacs right now.

Projects management

I used Vim with Tmux and every tmux session was created per project. Every session had windows for vim, terminal operations, background jobs.

In Doom we already have Projectile included. There are also workspaces.

These two packages are great for managing projects and buffers.

Issues that I still need to solve

php-mode is slow

That’s something I didn’t notice many years ago when I was using Emacs. Hard to tell if this is related to Evil mode enabled or some other Doom related configuration but when I try to evil-shift-right with more than 50 lines selected I have to wait some time for this action to happen.

magit is slow

Magit is pretty quick for small editings. But when I have, let’s say a merge conflict with a lot of files it takes 5-10 seconds for magit to open. It obviously depends on exact amount of files to show there but that’s pretty painful. Of course every other subsequent command is also slow.

company-mode doesn’t autocomplete

Company in my case didn’t want to autocomplete by default. The reason was that company backends chosen in doom don’t really work at least on my projects.

Moreover when I try to set company-backends variable to something I need and open a php file the variable updates automatically and company-capf with company-yasnippet is prepended to the list of backends.

Summary

Overall Doom experience is pretty nice. Configuration is hard sometimes because Doom sets some package variables, add hooks here and there and changes configuration of packages to some non-default behavior. It makes a bit more complex to setup a package/mode to something I need.

Maybe I should have chosen Doom in the first place because I already have some habits and needs that I want to have in my editor while Doom is probably good if you don’t have those habits or want to change them.

Projectile cleanup list of known projects (spacemacs)

Mon, 19 Feb 2018 00:00:00 +0000

Recently I’ve switched through a lot of different OS setups and my projects list in Spacemacs was bloated.

Some projects were from MacOS, others were from Windows. All of them were not existed anymore.

I’ve tried to find a file where Emacs (Spacemacs) stores list of projects but I’ve found even better elisp function for this.

Just call M-x projectile-cleanup-known-projects and every path (project) that is not exists on your current machine will be removed from the list of known projects.

Glad there is such function and my *spacemacs* buffer looks much much better now

Restclient (Postman for Emacs)

Sun, 22 Oct 2017 00:00:00 +0000

Hi everyone.

Here is my notes about restclient that can help you to forget about Postman (which is cool as well).

Define the action

Here is the example:

#
# get all people from star wars
#
GET https://swapi.co/api/people

To define an action you need to start with a comment.

Then you need to set method (GET, POST, PUT and other) and the url of course.

Now you can execute the query. Press C-c C-c (CTRL+c twice) and new buffer (*HTTP Response*) with the result will be opened.

At the bottom of that buffer you can see response headers:

// GET https://swapi.co/api/people
// HTTP/1.1 200 OK
// Date: Sun, 22 Oct 2017 19:03:17 GMT
// Content-Type: application/json
// Transfer-Encoding: chunked
// Connection: keep-alive
// Allow: GET, HEAD, OPTIONS
// Vary: Accept, Cookie
// X-Frame-Options: SAMEORIGIN
// Etag: "d080408a4d656729b0f52a6feb0783ca"
// Via: 1.1 vegur
// Server: cloudflare-nginx
// CF-RAY: 3b1eb73cda7d63af-FRA
// Request duration: 1.663359s

Pretty simple, ha?

Set headers

To define headers you need to write them just below the URL definition:

#
# get all people from star wars
#
GET https://swapi.co/api/people
User-Agent: Emacs Restclient
Content-Type: application/json

By pressing `C-c C-c` the headers will be attached to the request.

Post payload

If you want to send data to the server you can define it right after empty line of the URL (or headers if exist) definition.

Here is an example from restclient.el repo.

#
# Post works too, entity just goes after an empty line. Same is for PUT.
#
POST https://jira.atlassian.com/rest/api/2/search
Content-Type: application/json

{
 "jql": "project = HSP",
 "startAt": 0,
 "maxResults": 15,
 "fields": [
 "summary",
 "status",
 "assignee"
 ]
}

What if I want to post a file?

It’s also possible and it’s pretty easy

#
# post a file
#
POST http://httpbin.org/post
Content-Type: text/plain

< /etc/hosts

You can even define variables

Variables are useful to define the host or test user credentials.

Here how you can define it.

:myvar = https://google.com

You can also use elisp to set a value

:myvar := (some (artbitrary 'elisp)

use :variable-name syntax to get the value of variable:

#
# use a variable
#
GET :myvar/imghp

Restclient.el is a great package you definitely should try. It allows you quickly explore or test the API without leaving the Emacs.

Try it <3

Emacs Projectile find and replace

Fri, 20 Oct 2017 00:00:00 +0000

Projectile is great Emacs package you definitely have to install if you didn’t.

Along with projects management and quick switching among of them it allows you to limit grep/ack, find files and replacing commands. Here I want to note how to quickly search and replace strings in your project.

Search (grep/ack/ag)

If you know basics of grep you shouldn’t get any issues with it. Just call projectile-grep interactive function and type the query.

Here is how it works on this blog with title: query:

As you can see there is new buffer created called *grep*. At the bottom it says that search is finished (:exit) and have matches ([matched]). Filenames are links, so you can click on them and file will be opened in new buffer on the matched line.

Replace

Projectile is also really great in replacing with its projectile-replace and projectile-replace-regexp. When you call one of those functions you will be asked for an input to search for. Let’s search the blog for Replace. When you typed the query, you need to input the string you want to replace on. Let’s replace our Replace with Find.

When both params are entered the buffer with first match will be opened.

You can see the info in the mini-buffer:

Now you can press some keys to perform actions. Press ? for help.

As you can see if you click y button then the replace action will be performed. If you see something wrong is going to be replaced just press n button to skip the currently highlighted match and Emacs will switch to the next match.

Searching and replacing should be used as often as possible with minimum of manual work. It will save you from mistakes and improve your productivity a lot.

Good luck <3

From Emacs to Intellij IDEA

Tue, 29 Mar 2016 00:00:00 +0000

Recently I switched from Emacs, which I used about two years, to IntelliJ. It was pretty hard switch since my muscle memory wasn’t happy. Thanks guys from JetBrains they have Emacs keybinding-scheme. Today I will try to describe how I configured IntelliJ to be more Emacs-like.

First of all IntelliJ interface is pretty overloaded. Emacs had only text area with status line and mini buffer. I found very nice instructions about how to do interface more minimalistic in Laracast video. It was for PHPStorm but it also work for IntelliJ.

So, lets start.

I do not really use status bar at the bottom of window. If you no need it you can also remove it by checkbox in View -> Status Bar.
Navigation bar on top of window. Go to View -> Navigation Bar and uncheck it.
Toolbar. A lot of buttons for guys who use mouse. Go to View -> Toolbar checkbox.
Breadcrumbs probably useful feature, but I do not see a reason to use it. To disable it lets go to Preferences -> Editor -> Appearance. Uncheck Show HTML breadcrumbs (restart of IDE may be required).
Tabs. Emacs has buffers. IntelliJ has “Switcher” that contains list of recently opened files. It exists by C-x C-b. Let’s remove tabs by right click on it and select Tabs Placement -> None.

Now it should look something like this:

Much much better, right? ;)

Since I develop mostly backend and various APIs I used to use restclient-mode in Emacs.

Intellij has something similar. Tool called Test RESTful Web Service.

It has pretty much all features required by me, but it still sucks compared with restclient-mode of Emacs. There are not too much keybindings (actually only ⌘ + Enter is known and frequently used by me). You can add parameters, headers, you can repeat your last (or long before) query. It sucks mostly because too much mouse involved in the process of this tool usage.

Next thing its a terminal. The replacement of M-x shell called – Terminal. It’s very functional and looks better than Emacs eshell or term modes. I can even run Emacs inside.

I mapped it to C-c C-t to make it more accessible. I usually use it for files creation (instead of the IDE’s sidebar and mouse right click).

Hope it was useful. Don’t forget to switch your keybinding scheme to Emacs mode.