What you need to know before try Emacs

As a mature programmer, you need to be aware of backups at all times. After all, mistakes are inevitable.

In Emacs, there are mainly two backup methods, called backups and auto-saving:

• Backups occurs when you first open the file, the end of the backup file name has ~ labeled; and multiple-version backup is support
• Auto-saving periodically save the current file being edited, the file name of the head and tail have # labeled. When saving, the auto-saving files will be deleted, and when Emacs crashes due to unexpected reasons (such as system crash), the files will be retained, and you can use the recover-this-file command to restore.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

Backups
!Users!liujiacai!.emacs.d!README.org.~ 1 ~
!Users!liujiacai!.emacs.d!README.org.~ 2 ~
!Users!liujiacai!.emacs.d!customizations! editing.el.~ 1 ~*
!Users!liujiacai!.emacs.d!customizations!editing.el.~ 44 ~*
!Users!liujiacai!.emacs.d!customizations!editing.el.~ 45 ~*
!Users !liujiacai!.emacs.d!customizations!editing.el.~ 46 ~*
!Users!liujiacai!.emacs.d!customizations!editing.el.~ 47 ~*
!Users!liujiacai!.emacs.d!customizations! editing.el.~ 48 ~*

Auto-saving
#!Users!liujiacai!.emacs.d!customizations!misc.org#
#!Users!liujiacai!.emacs.d!customizations!navigation.el#*
#!Users!liujiacai!.emacs.d! elpa!lsp-java- 20201105.1758 !lsp-java.el#
#!Users!liujiacai!.emacs.d!init.el#

The above show part of the backup files in my computer. Thanks to these two functions, I have been rescued from the edge of a crash many times.

When editing the file, undo and redo is a very basic, important feature. In conventional editor operations are linear, whereas in Emacs with the help of undo-tree, it can be a tree. I will illustrate the difference between the two using state diagram below:

• First, enter three characters a b c, and we come to current buffer state

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

;;                                o  (initial buffer state)
;;                                |
;;                                |
;;                                o  (first edit)
;;                                |
;;                                |
;;                                o  (second edit)
;;                                |
;;                                |
;;                                x  (current buffer state)

• Then undo of two steps back to first edit state (only a is left), conventional editor will have state as

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

;;                                o  (initial buffer state)
;;                                |
;;                                |
;;                                x  (current buffer state)
;;                                |
;;                                |
;;                                o
;;                                |
;;                                |
;;                                o

However, Emacs is not the case, its status is

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

;;                                o  (initial buffer state)
;;                                |
;;                                |
;;                                o  (first edit)
;;                                |
;;                                |
;;                                o  (second edit)
;;                                |
;;                                |
;;                                x  (buffer state before undo)
;;                                |
;;                                |
;;                                o  (first undo)
;;                                |
;;                                |
;;                                x  (second undo)

The state is append-only, and a undo means returning to the last state, so the following state diagram may be more appropriate:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

;;        (initial buffer state)  o
;;                                |
;;                                |
;;                  (first edit)  o  x  (second undo)
;;                                |  |
;;                                |  |
;;                 (second edit)  o  o  (first undo)
;;                                | /
;;                                |/
;;                                o  (buffer state before undo)

• At this point, if you perform a new insertion (such as d), although the characters on the text are the same, simply a d, the state diagrams of editors are different, as shown below:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

;;            Undo/Redo:                      Emacs' undo
;;
;;               o                                o
;;               |                                |
;;               |                                |
;;               o                                o  o
;;               .\                               |  |\
;;               . \                              |  | \
;;               .  x  (new edit)                 o  o  |
;;   (discarded  .                                | /   |
;;     branch)   .                                |/    |
;;               .                                o     |
;;                                                      |
;;                                                      |
;;                                                      x  (new edit)

• At this point, if we undo twice, conventional editor returns to initial state (no characters), but Emacs restore to second state (there are a b there).

It is very confusing when I first encountered tree-based undo, but fortunately undo-tree provide undo-tree-visualize to visualize the undo state. The state diagram above is taken from its comments.

Org-mode is the main reason why many non-programmers choose Emacs. Simply put, it is a markdown-like language. Many users use it to take notes and manage GTD. With the help of Emacs's powerful expansion capabilities, programmers use it for literate programming, and it deserves to be ranked first in the extension list. 🥇

At present, I use org-mode relatively simply, just use it as markdown at the time. Just this point, coupled with the shortcut keys of Emacs, it has been a few blocks ahead from various editors.

One thing I demo here is table support with org-mode. You can use the org-table-transpose-table-at-point command to transpose row and column of a table.

Magit provides an interface for Emacs to git. It is the first Emacs extension I rely on heavily and it's the second-ranked extension in the community. All git operations are extremely easy within magit. Without it, I wouldn't even be able to do rebase.

I mentioned evil in my personal experience above. It is not "evil" but Extensible VI Layer for Emacs. In addition to porting vi's normal/insert/visual state, Evil also adds emacs state to disable all vi functions. Because it is in Emacs, we can customize the shortcuts to override vi's, we can have both h j k l and C-a, C-e, M-s, M-f, M-b.

Copy 7 lines of text, in the normal state of evil, only need

1

7 yy

And in Emacs requires

1

C-a C-SPC Cu 6 Cn C -e Mw

The best editor is neither Emacs nor Vim, it's Emacs with Vim binding!

Dired is the abbreviation of directory editor and is the built-in extension of Emacs, similar to the file manager Finder on macOS. In Dired interface, you can easily move/delete/create the file just like edit text. The following figure shows how to test_foo_*.dat rename test_bar_*.dat in bulk. (source)

Ivy/Counsel/Swiper is a completion framework, which can easily display the candidates of the current operation in an interactive way, similar to the Command Palette in VSCode and Double Shift in Intellj .

Although other editors have similar functions, their functions are either limited or separated from other functions, and there is no unified experience. Emacs is different, no matter how many extensions we have, we can still have a unified experience, this greatly affects the user experience.

Below, ivy-occur + wgrep + evil is used to modify the contents of multiple files in bulk to illustrate the powerful functions of the ivy suite.

There are two files 1.txt 2.txt in current directory, whose content are all hello world, and modify to hello emacs at last.

Steps:

• counsel-ag world search the current directory to search for files containing world
• C-c C-o (ivy-occur) Open the occur interface
• C-x C-q (ivy-wgrep-change-to-wgrep-mode) Enter edit mode
• :%s/world/emacs/g Modify content with the help of evil
• C-c C-c (wgrep-finish-edit) Save files

Of course, you can define shortcut keys for the above operations according to your own habits. The above five steps are done in one go.

Before the emergence of LSP , there was no unified framework to solve the basic functions of modern IDEs such as highlighting and completion of different languages. The LSP launched by Microsoft has undoubtedly become the industry standard, and there is no need to use regular, which is both inaccurate and rude. There are two extensions in Emacs that support LSP, namely

• Lsp-mode, provides all the experience of traditional IDE by default
• EGlot, the main focus is small and exquisite

Currently I use lsp-mode, beginners can try it, and then choose the one that suits their taste.

In addition to the extensions introduced above, there are some more "small" extensions I use daily. Of course, the list can go on and on, readers can find out more by yourselves.

• company completion framework, can be used with lsp-mode

• multiple-cursors

• ace-jump-mode moves the cursor quickly according to the first character. The figure below is an example of fast jump according to p

• yasnippet template system, which simplifies input by defining abbreviations for code fragments

• flycheck syntax real-time check

• treemacs file directory tree navigation

• projectile project workspace management

The above illustration shows how to find files in a project, switch between implementation and testing, and switch between different projects