Emacs

Duplicating the current line is frequent editing for me when I am coding. Initially, I copied a snippet as a command in Emacs from the Internet:

(defun w/duplicate-line()
  "Duplicate the current line."
  (interactive)
  (move-beginning-of-line 1)
  (kill-line)
  (yank)
  (open-line 1)
  (next-line 1)
  (yank))

Most of the time, I was happy with it, but it has mainly two drawbacks:

1. It cannot keep the column position when moving to the next line
2. It messes up with the yank ring as it yanks the text under the hood

So today, I took some time to fix these two problems, and I also want it to be capable of commenting the current line out if I prefix the command.

If you're using i3wm on Linux, how do you adjust the laptop's screen brightness?

Most of the time, I use the laptop with an external monitor. But when I am out, I have no monitors. And it seems no easy way to adjust the brightness in i3wm. Being too bright or dim is terrible for the eyes.

Recently I've been building a simple Emacs config for myself, along the way I re-discovered some fantastic packages, for example, I found that ace-window is a simple yet powerful package to enhance the default other-window command to select other windows quickly when it has more than two windows in a frame.

I replaced the key binding of other-window to ace-window by simply doing (global-set-key (kbd "C-x o") #'ace-window), then when there are >2 windows, it will show a white-in-red number at the top-left corner for every window, hit the number (1, 2, 3, …) and then Emacs will select the corresponding window (as demonstrated in the above screenshot).

LSP, or Language Server Protocol, makes programming easier by introducing features like more precise auto-completion and definition lookup. It may have scratched your itches, and you may wonder what the experience is like in Emacs.

BTW, I'm improving my English by watching YouTube videos every single day; If you're also learning English, or any languages, LanguagePuppy can definitely help you. It's a Chrome extension I developed using Clojure. Check it out:

So I'm trying to improve my English speaking skill by shadowing while watching TV episodes. The workflow before was to loop over video clips using mpv:

1. hit l to mark the start of the loop
2. play the video and wait for it to be at the end of the loop
3. hit l again to mark the end

Then mpv will loop over the clip, it basically works, but it's a bit hard and tedious to set the start and end precisely.

Note: watch my live coding session of this article:

I barely use notifications, but recently I think it's a valuable way to remind me things like helping me nurture habits, or to notify me of emergencies like a critically low laptop battery.

So I try to integrate notifications to org-mode and Emacs today.

The org-notify package from org-contrib (install it by (package-install 'org-contrib) ) could do this job easily before, so I first test it in the minibuffer with (org-notify "test").

Unfortunately, it errors out:

Doxygen is a nice tool for generating documentations for well-annotated C/C++ projects, the one feature that I like most is generating call graphs and class diagrams, so that I can learn a project quickly by browsing the diagrams from a higher point of view.

I take the following steps to generate call graphs for a project on terminals on Linux:

1. cd /path/to/a/project/, and generate a template config file by doxygen -s -g doxygen.conf (Omit -s to generate it with detailed comments).

2. Tweak the file by specifying input and output directories, and set HAVE_DOT and CALL_GRAPH to YES.

   [Read More]

There are many packages of Emacs that leverage subprocesses to do their jobs, Magit, eglot, elpy, to name a few. And there are times that a subprocess doesn't work as expected, for example, Magit is slow, and you're sure that it's ok when running git commands on shell. So how to spot these problems effectively and quickly?

The problem is that we don't know what's going on exactly, so here I want to share a few Elisp advices to make the subprocess creating visible, and print the exact program and its arguments to the *Message* buffer. Visibility is the key.

If you are a C/C++ programmer like me, you may experience jumping around different machines to write and compile your code, or you may write code on different machines for different projects, and scp/rsync/ftp the projects around. It works, but it's a bit tedious and takes too much burden on our brains.

For example, say I have two projects that should be compiled on their compiling machines respectively. There are two obvious workflows for writing code for them "simultaneously":