Emacs Mini Manual (PART 1) - THE BASICS

Easy way to install if you are using Ubuntu: sudo apt-get install emacs. If you use other Linux distributions, use the package manager of your distribution and install Emacs. However, the package manager only has the latest stable Emacs; if you want the latest Emacs, build it from source according to the instructions below.

To use Emacs with GUI:

• Install GTK 3: sudo apt-get install libgtk-3-dev libgtk-3-common libgtk-3-0
• Download Emacs; or if you prefer the latest Emacs, get it from source: git clone http://repo.or.cz/r/emacs.git
• If you download from the homepage, unpackage: tar xvf emacs-*.tar.gz
• Install GTK: sudo apt-get install libgtk-3-dev libgtk-3-common libgtk-3-0. You have to use gtk3 to be able to use true type fonts.
• cd emacs-<version>*
• ./autogen.sh

• Add prefix and path to where you want to install. This is useful if you work on a remote server without root access: ./configure --with-x-toolkit=gtk3 [--prefix=/path/to/dir]

  You should use GTKx 3, so you will be able to use true type fonts such as Inconsolata for a better Emacs experience.

• make
• sudo make install

If ./configure tells you there are dependencies missing, you should install them. Recommended dependencies: libtiff, libgiff, libjpeg, libpng and libxml2 for viewing and browsing web inside Emacs:

sudo apt-get install libtiff5-dev libpng12-dev libjpeg-dev libgif-dev libgnutls-dev libxml2-dev

Using in Terminal only:

• Download and unpackage as above.
• ./configure --without-x [--prefix=/path/to/dir]
• make
• sudo make install

If you don't like to compile Emacs yourself, install from the package manager of your Linux distribution.

After installation is done, add this line to your .bashrc or .zshrc:

alias em='emacs'

So you can start Emacs as fast as vim!

You can either download it on GNU Emacs homepage or better, download the latest 64 bit version: http://semantic.supelec.fr/popineau/programming-emacs.html.

After that, unpackage it in C:\Program Files\ and create a shortcut to C:\Program Files\Emacs\bin\emacsclientw.exe on desktop.

Download compiled Emacs for Mac OS X: http://emacsformacosx.com/.

You can also use this version that is more integrated with Mac OSX: https://github.com/railwaycat/emacs-mac-port

Follow this guide: Swapping Capslock and Control keys

Put this in your shell init file (.bashrc, .zshrc…):

/usr/bin/setxkbmap -option "ctrl:swapcaps"

If you use Ubuntu, follow this guide: Swap caps lock and ctrl in ubuntu 13.10.

Follow this answer on StackOverflow: Emacs on Mac OS X Leopard key bindings

You can use your palm to press Control in standard PC keyboard.

In Emacs, every user interaction is a function execution. You press a key to insert a character, Emacs runs self-insert-command. There are two types of functions in Emacs:

• Normal functions: These are like functions in other programming languages, and are used for implementing features in Emacs. Users do not need to care about these functions, unless they want to implement something or modify an existing implementation.
• Commands: Commands are like functions, but interactive. It means, commands are features provided to users and users directly use them.

execute-extended-command is bound to M-x.

Taken from here: EmacsWiki

A notation such as C-M-x (or, equivalently, M-C-x) means press and hold both Control and Meta (Alt) keys while hitting the x key. From now on, I won't say something like "Press M-x" anymore. For example, if I say "C-x C-f your files", you should replace C-x C-f with its command like this in your head: "find-file your files". All commands use verbs, I think, so don't worry. Try to recall the command from the key binding; it will help you get used to Emacs quicker. One exception though: I only say "press key" if key is a single character on the keyboard.

If you see M-x command, it means you need to M-x and type command.

A prefix key is a part of a full key binding. For example, a full key binding is C-x r l to run the command bookmark-bmenu-list, then C-x and C-x r are its prefixes. Note that key sequence such as C-x and M-x are considered a single character. Knowing prefix key is handy: if you forget key bindings of some commands that use the same prefix key, and remember the prefix, you can press the prefix key and C-h to get a list of commands with that prefix.

For example, C-x r is the prefix for register and bookmark commands in Emacs. However, you forget a specific key binding for a command in those features. C-x r C-h lists all key bindings that have prefix C-x r.

Finally, C-g executes the command keyboard-quit, which cancels anything Emacs is executing. If you press any key sequence wrongly, C-g to cancel that incorrectly pressed key sequence and start again.

As you gradually learn Emacs, you will see the key bindings are really systematically organized and mnemonic. Whenever you see key bindings ending with n and p, it usually means next and previous; o means open; h means help; C-h is standard prefix for help commands; key bindings such as o and C-o are frequently used in many built-in tools such as Dired, Ibuffer, Occur…

The key bindings have a few simple and easy to remember rules:

• C-x prefix is for default and global binding that come with Emacs.
• C-c prefix is for users to define.
• C-u is for altering behaviors of commands. That is, one command can behave differently depending on how many C-u you pressed first before executing a command. Mostly you just have to hit C-u once.
• C-<number> like C-1, C-2… is similar to C-u, but passing a number to a command. Usually, the number specifies how many times you want to repeat a command.

You will learn about C-u and C-<number> in Prefix Arguments section.

Most commands can be organized in an easy to remember way. For example, command like helm-do-grep (the command belongs to Helm, a 3rd party extension to Emacs) can have a key binding like C-c h g. The h stands for Helm and g stands for grep. So, key bindings are not difficult to remember.

Point is your current cursor position. From now on, instead of saying "current cursor", I say "point".

Let's learn one especially handy command. M-x find-, then press TAB. You will see Emacs offers you a list of possible commands with prefix find-. Select the command find-file, either by clicking on it in the list; or keep typing a few more characters, and pressing TAB until the command is completed. After find-file is in your prompt, press RET. For quickly running find-file, you can use key binding C-x C-f.

You can use wildcard expression to select more than one file. For example, if your directory contains these file:

• file_a_1.c
• file_a_2.c
• file_a_3.c
• file_b_1.c
• file_b_1.h
• file_b_2.c

Then in find-file prompt, you can open all file with extension .c like this: file*.c. Or if you only want to select file with character a in it: *a*.c. Or if you only want to select file with 1 and extension .c. in it: *1.c. Basically, wildcard expression * accepts anything.

During the exercise, if something happens, for example, you press the wrong keys and Emacs is behaving weird, just press C-g.

The command you have just executed is for browsing and opening files in Emacs, similar to Open With in regular editors, except that instead of navigating with the mouse, you navigate with keyboard, which is much faster.

If you use find-file to navigate to an existing file in a deep directory and press RET, it opens that file. Otherwise, if the file does not exist and you press RET, you create a new file. Woot, two features in a single command, so convenient. If you intend to open a file at first, but then realize that you want to create a file there, Open With doesn't allow you to do that. You have to navigate all the way back with typical New File feature in regular editors.

Another interesting command in Emacs is find-file-at-point. What this function does is that if you have a path to a directory or file under point, M-x ffap opens that directory or file directly!

As you see in the demo, if for some reason, the directory at point does not exist, ffap tries the parent directory until one exist. In the example, only /home/ exists and got fed into the prompt.

Emacs has an interesting feature called Ido, short for Interactively Do Things. In essence, Ido is a superior interface to interactively select things in Emacs compared to a plain prompt.

To activate Ido, M-x ido-mode. Let's open a file with C-x C-f. Do you find this:

Or this:

Which is better?

Once enabled, Ido is used for most commands that require you to select something from a list.

A few things to note for when using Ido:

• If you want to use wildcard expression, you have to temporary revert to ordinary find-file via C-f.
• If you want to select the current directory, C-d. This invokes Dired file manager to open the directory and list the files in current directory. You will learn Dired in later section. For now, if you open the directory, close the current listing by C-x k and press RET.
• You select a directory in find-file prompt by pressing RET, not TAB like ordinary find-file.

Regardless, an alternative interface for completion and narrowing exists, arguably more powerful, but you have to install a 3rd party package. The package is called Helm. However, let's stick with Ido through the rest of this manual.

Buffer is where you edit your file content. Buffer holds content of a file temporarily. Anything you write into the buffer won't make it into file until you explicitly save it with save-buffer command. C-x C-s executes the command save-buffer, so you can C-x C-s your files. You can also execute this from M-x*

To save a buffer as other file ("Save As" in other editors), C-x C-w, which runs the commands write-file.

To kill a buffer, C-x k. If you want to kill the current buffer, RET immediately. Otherwise, type into the prompt the buffer name you want to kill.

In the previous section I said that point is in your file, well, actually point is not in a file but in a buffer. From now on, keep file and buffer two separate and distinct concepts. When I say file, I refer to physical file and when I say buffer, I refer to the temporary content of the file that is being displayed.

Exercise: Practice C-x b to get used to it.

Major modes provide specialized facilities for working on a particular file type, such as syntax highlighting for a programming language. Major modes are mutually exclusive; each buffer has one and only one major mode at any time.

Emacs is bundled with many major modes for editing source code in different languages: C, C++, Java, Lisp, bash, asm… For example, when opening a file with .c extension, Emacs automatically recognizes it's a C file and selects the C major mode to highlight the buffer properly.

Minor modes are optional features which you can turn on or off, not necessarily specific to a type of file or buffer. For example, Auto Fill mode is a minor mode in which SPC breaks lines between words as you type. Minor modes are independent of one another, and of the selected major mode.

So, you learn how to open file and create buffer of that file. In other editors, you got something called "tabs". Every time you open a file, you get a file tab for selecting an "opening file" (which is called buffer in Emacs). It quickly becomes a nuisance once you have lots of file tabs. If you use multi-row support for file tabs, it eats up your editing space.

How do you switch between opening buffers? C-x b opens a prompt to enter a buffer name. You can TAB to complete the buffer name similar to how you complete file names in C-x C-f.

After you open a file, and if point is in that buffer, C-x C-f prompts the current directory, so you can open another file within this directory. For example, buffer A is from ~/dir1/ and buffer B is in ~/dir2/, if point is in buffer A, C-x C-f starts in ~/dir1/; if point is in buffer B, C-x C-f starts in ~/dir2/.

In an Emacs session, you may have a lot of buffers, including non-file buffers such as shell buffers, email buffers… How do you manage buffers when it's getting large? C-x C-b executes list-buffers, provide you a list of buffer in which you can search. However, list-buffers is a simple command for buffer management. Emacs also provides ibuffer, which is a superior alternative. You will surely want to use ibuffer, but first let's replace list-buffers with ibuffer (by placing next directive to your ~/.emacs file):

(global-set-key (kbd "C-x C-b") 'ibuffer)

Remember to save into *scratch* buffer and then M-x eval-buffer for the setup to take effect.

Let's play with ibuffer.

Exercise:

• First, open many files with different extensions. The Emacs source you used for installation is an great practice target. If you use a built binary, download it and unpackage. Let's assume you download and unpackage it at ~/Downloads/emacs-24.3.
• C-x C-f, navigate to emacs-24.3/lisp/ and open all Lisp files: *.el. If you use Ido, remember to C-f before type into the prompt
• C-x C-f, navigate to emacs-24.3/src/ and open all C files: *.c.
• Open ibuffer by C-x C-b. You see a huge list of buffers.

Now the fun begins.

• Suppose that you want to work with C code. / m and enter a major mode to select buffers that belong to this major mode. Prefix / in ibuffer groups filtering commands. TAB to see a list of major modes:

  

• Enter c-mode.
• Only C buffers remain. But you open buffers in two major modes: c-mode and emacs-lisp-mode. You can create each group for one by pressing / g, and give the group a name. Only execute / g after executing any filtering commands.
• Up to this point, the filtering is still applied. Press / / to remove previous filter and return the full buffer list.
• Let's create another group based filtering. / m and enter emacs-lisp-mode. Create another group with / g and give it a name. Now, every time you open files that their buffers satisfy the filtering criteria, the buffers are put into appropriate groups.
• To open a buffer, o or C-o. o opens a buffer and switch point to it. C-o leaves point on the buffer list. Let's open a buffer with o and C-o. To switch back to the other buffer, do C-x o. C-x o executes other-window command, which cycles among the opening buffers (technically the buffers are in Emacs "windows", and you are cycling "windows", but we will get to that later).

• Either using C-o or o creates another buffer below, leaving you two horizontal buffers. You probably don't like the layout because you have a big screen. If you use o, C-x o to switch back to the list and C-x 1 to close other buffer. If you have multiple buffers opened, C-x 1 closes all others and leave the active buffer (the one with point, which is our buffer list) remains. To close an active buffer, C-x 0. C-x 3 to create a vertical buffer to the right. It creates an exact duplicate of the active buffer. Now, o on any C buffer again, and point is in that buffer:

  

• Edit something in the buffer. Switch back to ibuffer and press g, which runs the command ibuffer-update to refresh the list. You will see an asterisk on the left of your just edited buffer. It indicates that buffer has been modified.

• You can also mark a buffer by pressing m on multiple entries to perform various operations:

  • view: press A to view the marked buffers
  • save: press S to save the marked buffers
  • close: press D to close the marked buffers
  • revert: press V to discard changes to the marked buffers

  To unmark a buffer, press u on the marked entries.

• Another way to open the buffer: e (enter), f (find) or RET to bury and replace the list with selected buffer. Switch back to the list using C-x C-b again.

To sum up, I will list the key bindings your used in this section along with other useful key bindings:

• C-x C-b to open ibuffer.
• o or C-o to open a buffer at point.
• e, f or RET bury the buffer list and replace it with the buffer content.
• = to compare the current buffer content with its file.

Tip: When point is on an entry, C-x C-f starts at the current directory of buffer of that entry.

• Filtering commands:

• Filter group commands:

• Sorting commands:

To quit ibuffer, press q.

When you read books, you usually cannot read all at once and place a bookmark to go back to continue reading later. Emacs allows you to bookmark too.

Remember that key bindings are easy. You just need to remember that C-x r is the prefix for bookmark related commands. m stands for mark, meaning you mark something in some place; b stands for bookmark, meaning you can switch to any bookmark quickly, similar to C-x b switches to buffers quickly. Finally, l means list for listing bookmarks, analogous to ibuffer for listing buffers. If you want to preserve the bookmarks across Emacs sessions, C-x r l to open the bookmark list and press s to save the list to file.

If you understand how to manage buffers, managing bookmarks is the same, with different but similar key bindings. Finally, you cannot only bookmark buffers that are associated with files, you can bookmark non-file buffers too:

• Dired buffers
• Info buffers
• Man pages

A few useful key bindings when in bookmark-bmenu-list:

Exercise:

• Open files and create a few bookmarks. C-x r b to switch between them.
• C-h i to open Info. Pick a node and enter as deep as you want. Then bookmark and kill current Info buffer.
• C-x r l to open the bookmark list and practice the key bindings in the table.

These key bindings are also used by popular shells such as bash or zsh. I highly recommended you to master these key bindings.

• Move forward one char: C-f (f stands for forward)
• Move backward one char: C-b (b stands for backward)
• Move upward one line: C-p (p stands for previous)
• Move downward one line: C-n (n stands for next)

The above operations can also be done with arrow keys. If you don't like the above key bindings, the arrow keys offer equivalent features.

• Move to beginning of line: C-a
• Move to end of line: C-e
• Move forward one word, M-f.
• Move backward one word, M-b.

These key bindings are in Emacs only:

• Scroll forward one screen: C-v, page down
• Scroll backward one screen: M-v, page up
• Move to the beginning of a sentence: M-a
• Move to the end of a sentence: M-e
• Recenter a screen: C-l
• Re-position point to the top, middle and bottom of the current screen: M-r
• Move to top of the buffer: M-<
• Move to end of the buffer: M->
• Move to the nth character: M-g c (c stands for character)
• Move to the nth line: M-g l for Emacs < 23.2, M-g g for emacs >= 23.2) (l/g stands for line)

Recenter means making the current line point the center of your screen.

Exercise: execute the above commands using the key bindings at least 10 times or until you remember. You can perform these motion commands on any buffer.

• C-M-f binds to forward-sexp, move forward over a balanced expression. Demo:

  

• C-M-b binds to backward-sexp, move backward over a balanced expression. Demo:

  

• C-M-k binds to kill-sexp, kill balanced expression forward. Demo:

  

• C-M-t binds to transpose-sexps, transpose expressions. Demo:

  

• C-M-<SPC> or C-M-@ binds to mark-sexp, put mark after following expression. Demo:

  

In Emacs, kill means Cut in other editors. These key bindings also work under the terminal.

• Kill a character at the point: C-d
• Kill entire line: C-S-DEL (remember, DEL is your <backspace> key)
• Kill forward to the end of a word from current point: M-d
• Kill backward to the beginning of a word from the current point: M-DEL
• Kill all spaces at point: M-\
• Kill all spaces except one at point: M-SPC
• Kill to the end of line: C-k
• Kill a sentence: M-k

When you kill something, the killed content is put into the Kill Ring.

If you write code, you can also quickly add comments or comment/uncomment code with M-;:

• If you do not highlight a text region, M-; adds a comment to the end of line.
• If you highlight a region (i.e. with a mouse), M-; comments out the region.

Dynamic Abbreviations are a completion feature in Emacs, but work for text and is context-independent. After you type a word once, if you type that word again, you can type it partially and M-/ to complete it. If you type a prefix that has many candidates, M-/ cycles the candidates. This is a really cool feature and you ought to try it.

Exercise:

• Type "thisIsaVeryVeryVeryVeryLongWord" into a buffer of your choice.
• Add newline or whitespace.
• Type "thisIs" and M-/. Great, Emacs automatically completes for you.
• Type "random" into your buffer and M-/. You will see Emacs tell your that no dynamic abbreviations found.
• Type "randomWord" and add a whitespace. Now, type "random" and M-/ again. Emacs can now happily complete "random" for you. Remember that to let Emacs remember your words, you have to type a complete word.

Kill ring is the list of previously killed contents. You can insert the most recently killed element by C-y.

If you supply a number, using C-<number> - <number> can be any number - before you C-y, to paste the nth entry in the kill ring. The most recent entry is 1st entry. C-1 C-y is the same as C-y; C-2 C-y is the 2nd most recent entry, make that entry the head of the list and so on…

Let's play with the kill ring for a while. Open a buffer and insert these 3 lines:

Then:

• Kill the three lines with C-k, from top to bottom.
• C-y or C-1 C-y, you will see ccc got inserted.
• C-2 C-y, you will see bbb got inserted; C-y again, you will see bbb got inserted again. bbb now becomes head of the list.
• C-2 C-y, you will see aaa got inserted; C-y again, you will see aaa got inserted again. aaa now bedcomes head of the list.
• Insert the 3 lines and kill all again.
• C-3 C-y, you will see aaa got inserted; C-y again, you will see aaa got inserted again. aaa now bedcomes head of the list
• … and so on …

C-<number> is called prefix argument. Basically it's for altering the behavior of you command. You will learn about prefix argument in later section.

Alternatively to the above sequence, you can use M-y which runs yank-pop. By default, when C-y, it inserts the most recent killed text. If you want to retrieve earlier kill texts, after C-y, M-y to cycle through the entries in kill-ring. You must first run C-y, otherwise M-y has no effect.

You may wonder, what happens if the kill ring getting really large, how can you remember where is which? That's right. It's a problem, and that's when the 3rd party plugins shine. However, you can view the kill ring with C-h v, then enter kill-ring. After this, you will see the kill-ring content, but in its code form, which is not really pretty and friendly.

Mark is a record of a position in a buffer. It's like when reading a book, you record various places in a book and these records are called bookmarks. It is similar, except it is buffer mark in Emacs (Emacs also has bookmark, but we will discuss later).

When you set mark between two points in a buffer, the text between two points are highlighted. We call the highlighted text a region. When the region is highlighted, we say the region is active; to deactivate a region, press C-g or move point around, just like in other text editors.

Exercise:

• Place a mark in buffer with C-SPC C-SPC. Let's call this mark A.
• Move to another place in the buffer, place another mark with C-SPC C-SPC. this is mark B.
• Move to another place and C-SPC C-SPC again. This is mark C.
• Now press C-u C-SPC. You can see point goes back to mark B.
• C-u C-SPC again. Point goes back to mark A.
• C-u C-SPC again. Point goes back to mark C.
• Let's create a region: C-SPC, then move point forward. What happened?
• The highlighted area is called a region. You can perform editing commands on the region:
  • C-w to kill the region
  • M-w to copy the region
  • C-y to yank (equivalent to paste) the region.

• Let's copy or kill a region; you should select a big region. Now yank (paste) it elsewhere. After yanking, you notice point is not at the original location anymore. If you want to return to the where you yanked, C-u C-SPC or C-x C-x.

  When you yank, you create a mark at point before the new content is inserted. After the content is inserted, point moves according to the size of the content. In general, most Emacs commands that create sudden displacement push marks, so you can go back to previous locations without having to tediously scroll the whole buffer.

  C-x C-x executes the command exchange-point-and-mark, which exchanges the point and the mark created when you yank with C-y. Try and see. When this command is executed, region bounded by the mark and point is activated. Using C-x C-x is really convenient. Instead of highlighting line by line for Copy or Kill, you can do this:

  

  Remember when you have to highlight a big region and for some reason, you lose the highlighting and have to do it all over again. C-x C-x saves you from that tedium.

  C-u C-SPC simply returns you to previous mark location inserted when you C-y. This command won't activate region.

  Practice until you get used to these two commands.

Emacs stores buffer marks in a list, that's why you are able to cycle through various marks in the exercise above. You can cycle through the list to jump to a mark, or with extension packages, you can have a list and interactively select it. Helm is an excellent example of such an extension. We will discuss more on extension packages later.

Mark ring is local to each buffer. If you switch to another buffer, you have a new local mark ring.

Global mark ring is like mark ring, but they persist across buffers. Each time you set a mark, that mark is set in global mark ring in addition to the buffer's mark ring.

You cycle the global mark ring by C-x C-SPC.

To undo: C-/ or C-x u

To redo, it's quite tricky to do because you have to understand how undo in emacs works. When you edit, emacs tracks changes in your current editing file. For example, you insert the following line in your file:

Then, Emacs tracks the history like this:

• insert: "aaa"
• insert: "bbb"
• insert: "ccc"

Now, execute undo twice. Your file becomes:

aaa

The history of the file changes:

• insert: "aaa"
• insert: "bbb"
• insert: "ccc"
• undo insert: "ccc"
• undo insert: "bbb"

How do insert back bbb and ccc. By undo your previous undos! ook closely at the above change history again. You see that Emacs keeps track your recent undo actions. execute some motion command, i.e C-f, then try C-/ twice and see what happens.

Great, you get your old content, bbb and ccc back. That is because you have just undone the latest "undo insert: …" entries in the file history.

When you was execute a series of undoing, without any other commands in between, Emacs keeps reverting to the older content. The series of undo insert: … got inserted into your file history when you break the undo series with other commands.

Again, two features in one command, but a bit confusing this time.

Exercise: Practice undoing/redoing until you get used to.

Content search is an essential feature in every editor. Emacs has many built-in tools for this problem.

The mode line is the empty area below the buffer. It has useful summary information about the buffer shown in the window.

The text displayed in the mode line has the following format:

cs describes the character set of the text in the buffer. Do you see the character U in the picture? It means your text is represented by UTF-8 coding system.

If you type text in different human languages, and if the input method is on, to the left of the U appears the symbol of that language, i.e. \U, the backslash means TeX input method. C-\ prompts you to select a language. After selecting, subsequent C-\ toggles the selected input method on and off. You can set the input method again with M-x set-input-method.

ch describes editing state of current buffer:

• This shows two dashes (‘–’) if the buffer displayed in the window has the same contents as the corresponding file on the disk; i.e., if the buffer is “unmodified”.
• If the buffer is modified, it shows two stars (‘**’). For a read-only buffer, it shows ‘%*’ if the buffer is modified, and ‘%%’ otherwise. You can see that in the picture, the buffer is modified.

fr gives the selected frame name. A frame is a Emacs window in your OS. For example, these are two Emacs frames:

If you are using the GUI version of Emacs, it will always be a dash. However, if you use Emacs in terminal, you cannot have multiple frame window like the above screenshot. Instead, Emacs creates virtual frames with names like F1, F2…, Fn like this (notice my mouse pointer):

buf is buffer name. Buffer name is usually file name; but they can have different names.

pos is display the current position of your viewing screen. If your viewing screen starts from the first line, it displays as Top. If you viewing screen contains the last line of your buffer, it displays as Bottom. Otherwise, it displays % position, i.e. 20% means you viewing screen is 20% away from the top.

line displays the current line number.

major displays the current major mode.

minor displays the current minor mode.

Minibuffer is the small area at the bottom of your Emacs screen.

The Minibuffer is where Emacs commands read complicated arguments, such as file names, buffer names, Emacs command names, or Lisp expressions. When you execute find-file, it asks for your file from the Minibuffer, which is one of find-file required argument. Remember I said earlier that in Emacs, everything is a function. find-file is a command, in other words, it's an interactive function. As a function, it also takes arguments. Minibuffer is where users can feed arguments to the interactive functions.

Minibuffer has an input history. If you enter anything into the minibuffer and RET, minibuffer remembers the input and you can access the input again with:

• M-p moves to the previous input in minibuffer history.
• M-n moves to the next input in minibuffer history.
• M-r searches for an input that matches the supplied regexp.

It works on any command that get input from the minibuffer, as you already used M-p and M-n to get old inputs in Isearch.

Minibuffer can be used for output as well. The echo area is used for displaying messages made with the message primitive, and for echoing keystrokes.

Both Minibuffer and Echo Area, although serve different purposes, share the same physical space. You should not be confused between the two.

An application window in an operating system is called a Frame in Emacs. So, you execute Emacs from the command line and open Emacs, that's a frame that contains your Emacs session. Emacs can have multiple frames to hold different parts of Emacs, such as a separate frame to hold the minibuffer.

Personally, I only use a single frame. However, frames can be useful if you want to organize buffers into different groups. For example, each frame can be a project: frame F1 holds buffers related to my C programming projects, frame F2 holds buffers related to customizing Emacs, frame F3 holds buffers related to emails and reading, newsgroups…

As stated earlier, multiple frames under the terminal have names F1, F2 …. Fn for each frame.

These are the key bindings for manipulating frames:

Unlike other editors, Emacs can split your frame area into multiple smaller areas. Each such area is called a window. You can divide a frame into as many windows as you want and each window can have anything in it, i.e. your current editing buffer, file management buffer, help buffer, a shell… Basically anything that Emacs can display. Let's try them out:

Exercise:

C-x 2 to split the current window into two horizontal windows. After splitting, you will have the exact duplicate of your current editing buffer. split-window-below is bound to C-x 2.

C-x 3 to split your current window into two vertical windows. After splitting, you will have the exact duplicate of your current editing buffer. split-window-right is bound to C-x 3.

Now, after you execute the two commands above, you will have three windows: two above and one below. Each window can hold a buffer. With the above two commands, you can create arbitrary window layout. In Emacs, a window layout is called a window configuration.

To navigate through the windows, use C-x o which runs the command other-window. Try cycle around the windows a few times to get used to it.

In Emacs, <next> is the PageDown key, <prior> is the PageUp key. M-<next> runs scroll-other-window and scroll the other window forward; M-<prior> runs scroll-other-window-down and scroll the other window backward. Other window is the window that you visit when C-x o.

C-x 0 closes the window at point.

C-x 1 closes all other windows except the current selected one. Create another window, then try C-x 1.

C-x 4 is a common prefix for opening things in other buffer. Things here can be files, shell, or a tree explorer. Here are standard C-x 4 bindings:

That's quite a long table, eh? If you forget, you can either:

• Visit my manual again :)
• Or much faster, access it directly from Emacs with it amazing help system. So, if you want to know all key bindings to prefix C-x 4, just C-x 4 and then C-h. If you enter a prefix key and enter C-h after it, it will list all of the key bindings and commands start with that prefix. This is really nice, compare to other editors that hide all this information deep within layers of menus.

Help system will be discussed in later section.

In Emacs, behind anything is a function. Functions can accept arguments. You can also pass arguments into Emacs commands to modify its behaviours. However, you don't have to write code that calls a function with its arguments and then compile or evaluate it. You can pass arguments interactively.

Exercise:

Earlier, you learned motion commands such as C-f, C-b, C-p and C-n, remember? But, you can only move forward 1 character with C-f, move backward 1 character with C-b, 1 line upward with C-p and 1 line downward with C-n.

Now, try C-4 before any of those commands. See anything different? Great, instead of executing the commands once (i.e. Move forward 1 character …), you repeat the commands 4 times (i.e. Move forward 4 characters…).

Many commands allow multiple repetitions with prefix arguments.

You can even pass negative prefix arguments. Try executing the above commands with C–4, that's right, Control and - and 4 (minus 4). You see that you also execute the commands 4 times, but in reverse. That is, with C-f, instead of moving forward 4 characters, you move backward 4 times. You might wonder, what does it differ from C-4 C-b? You are right, it is the same. But, many commands do not have their reversed versions, so negative argument is always useful in those circumstances.

Now, try executing C-u 4 C-f. You will see it does the same thing as C-4 C-f. Again, why do we need C-u? It is because in a terminal, you can not use Control with digit keys. C-u tells Emacs that you are about to enter a numeric argument, and it will be ready to accept the input. It's just a different way to do thing.

If you do not supply any prefix argument, such as you directly execute C-u C-f, then the numeric argument is default to 4. Try C-u C-f, and see that it moves 4 characters forward. Try it a few times to get used to.

If you execute C-u consecutively, the numeric argument is a power of 4. If you press C-u, the resulting argument is 4¹; C-u C-u, the result is 4², which is 16; C-u C-u C-u, the result is 4³, or 64. I know large powers are hard to calculate, but there is a plugin that displays the calculation and display these numbers. That plugin is Helm, but I will discuss that later in part 2.

Why number 4 for C-u? I don't know.

Emacs has a built-in one called Dired, short for (Dir)ectory (Ed)itor.

This section is a shortened version of Dired in GNU Emacs Manual. After you read and practice these commands, read the Dired Manual if possible.

When I first heard about registers in Emacs, it scared me. I thought "Wow, what is this "register" thing? Am I going to work directly with CPU registers?" As it turned out, despite the name "Register", it's not something that complicated to understand. Although, an Emacs register is similar to a CPU register in the sense that it allows quick access to temporal data.

Each register has a name that consists of a single character, which we will denote by r; r can be a letter (such as ‘a’) or a number (such as ‘1’); case matters, so register ‘a’ is not the same as register ‘A’.

In Emacs, registers are for quick access to things. Things can be a position, a piece of text, a rectangle, a number, a file name, or a window configuration (yes, you can save how Emacs organizes its screens and restore it later!).

Saving different types of objects has different key bindings, but to jump to a register, you use a single command C-x r j REG; REG is a register of your choice.

The prefix key for register commands is C-x r. If you forget the key bindings, C-x r C-h to get the list of key bindings.

Macro records your actions in Emacs and play back later.

Personally, I use f3 and f4 for recording/playback, so I don't have to press many keys. To repeat a macro many times, use prefix argument. For example, C-u 10 <f4> executes a macro 10 times. If you want to cancel recording, C-g.

Exercise 1:

Copy these lines into a buffer of your choice:

aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd
aaaaabbbbbbbccccccdddddd

Now, you want to separate each line into different groups, each group contains their own character, like this:

In many editors, you have have to do it manually. In Emacs, you don't have to repeat yourself, using macro. Follow these steps:

• Place point at the beginning of the first line.
• Press <f3>.
• Use C-s to search-and-jump to the beginning of each character group (or C-f if you want something simple) and add whitespace.
• Return to the beginning of next line. Press <f4> to finish recording.
• Continuously press <f4> and see Emacs playbacks the whole action sequence you've just recorded.
• If you want to repeat more than 1 time, using prefix argument. If you want to repeat until the end of file, use prefix argument 0: C-u 0 <f4>. Alternatively, highlight the region of remaining lines, and C-x C-k r: run the last keyboard macro on each line that begins in the region (apply-macro-to-region-lines).

After a macro is defined, it is saved in the keyboard macro ring. There is only one keyboard macro ring, shared by all buffers. All commands which operate on the keyboard macro ring use the same C-x C-k prefix. Just remember the prefix C-x C-k = macro commands, and you won't find macro key bindings difficult to remember.

Exercise 2: Transform data from one format to another

For example, I have this table with some data:

machine1=(aa:bb:cc:dd:ee:a1 aa:bb:cc:dd:ee:a2 aa:bb:cc:dd:ee:a3)
machine2=(aa:bb:cc:dd:ee:b1 aa:bb:cc:dd:ee:b2 aa:bb:cc:dd:ee:b3)
machine3=(aa:bb:cc:dd:ee:c1 aa:bb:cc:dd:ee:c2 aa:bb:cc:dd:ee:c3)
machine4=(aa:bb:cc:dd:ee:d1 aa:bb:cc:dd:ee:d2 aa:bb:cc:dd:ee:d3)
machine5=(aa:bb:cc:dd:ee:e1 aa:bb:cc:dd:ee:e2 aa:bb:cc:dd:ee:e3)
machine6=(aa:bb:cc:dd:ee:f1 aa:bb:cc:dd:ee:f2 aa:bb:cc:dd:ee:f3)

Basically, each row contains the MAC addresses of Ethernet interfaces of a machine in the server cluster at my workplace. The data are stored in a plain text file. But then, we want to integrate these data inside our YAML file to do something else. I have to basically transform the data in the above format to the one below:

machine 1:
    mac1: aa:bb:cc:dd:ee:a1
    mac2: aa:bb:cc:dd:ee:a2
    mac3: aa:bb:cc:dd:ee:a3

In the real data file, it contains around 50 entries. Manually transforming text would be tiresome. Thanks to Emacs, I solved this problem with a keyboard macro.

• Pre-recording setup: Before recording a macro to automate this transformation, we need to properly set things up:
  • Create two buffers side by side with C-x b. Name the left buffer buf1 and right buffer buf2.

  • Yank the original data into buf1. Move point back to beginning of buffer.

    That's set and done. Here is how it should look like:

    

• Record:

  Point should be at buf1, at the first line of the data.

  • Press <f3> to start.

  • C-SPC then M-f. This marks the word machine1. Store this word into register a with C-x r s a.

    

  • Move point to the beginning of the first MAC address. C-SPC then C-s and search to the first delimiter, which is an empty space " " in this case. C-b to move back to the end of the first MAC address. Store this region into register b with C-x r s b.

    

  • After that, move point to the beginning of the 2nd MAC address, C-s to space and C-b to go back one character. Save the region into register c with C-x r s c.

    

  • Repeat for the last MAC address and save it in register d.

    

  • Switch to the second buffer with C-x o:

  • Insert the register from a to d according to the template:

    

  • After inserting, move point to the next empty line.
  • Switch back to buf1 with C-x o.
  • Move to the beginning of next line.
  • Press <f4> to stop.

• Play:

  Now you can play back your new keyboard macro to transform the remaining entries.

Here is the whole process:

This section is taken directly from GNU Emacs Tour, with improvements.

Emacs helps you manipulate and edit files stored in version control. Emacs supports CVS, Subversion, bzr, git, hg, and other systems, but it offers a uniform interface, called VC, regardless of the version control system you are using. The benefit of a unified interface is that even if you aren't familiar with some version control system (VCS), you can still work with that VCS quickly, without the burden of learning all the little details of a particular VCS.

Emacs automatically detects when a file you're editing is under version control, and displays something like this in the mode line: CVS-1.14 to indicate the version control system in use, and the current version.

M-x vc-next-action or C-x v v commits the current file (prompting you for a log message) if you've modified it. (Under version control systems that require locking, this command also acquires a lock for you.)

VC provides other commands for version control-related tasks:

You can list more operations with C-x v C-h.

If you use git, a more specialized package exists dedicated to Git only: Magit offers much better features than the general interface that Emacs provides, except for some features, such as C-x v =, C-x v ~ and C-x v u .

The prefix key bindings for all VC related commands are C-x v. The above are just a few commands that I found most useful and used frequently, even when I use Magit.

Exercise: Let's practice this nice Emacs feature.

• First, download a random Git repository.
• Open any file in the repository.
• Edit that file and save. Do it in various places, so we have many hunks.
• C-x v = to know precise what changes you made.
• C-x v g to view who changes what line on what commit.
• C-x v ~, select a commit. After selecting, the version of that revision will be displayed in another buffer.
• C-x v u to revert the buffer back to its original state, after you done playing with it.
• Rinse and repeat until it becomes part of your workflow.

In Emacs, you have 3 types of shell commands: shell, term and eshell.

I will just quote a very good answer on StackExchange:

shell is the oldest of these 3 choices. It uses Emacs's comint-mode to run a subshell (e.g. bash). In this mode, you're using Emacs to edit a command line. The subprocess doesn't see any input until you press Enter. Emacs is acting like a dumb terminal. It does support color codes, but not things like moving the cursor around, so you can't run curses-based applications.

term is a terminal emulator written in Emacs Lisp. In this mode, the keys you press are sent directly to the subprocess; you're using whatever line editing capabilities the shell presents, not Emacs's. It also allows you to run programs that use advanced terminal capabilities like cursor movement (e.g. you could run nano or less inside Emacs).

eshell is a shell implemented directly in Emacs Lisp. You're not running bash or any other shell as a subprocess. As a result, the syntax is not quite the same as bash or sh. It allows things like redirecting the output of a process directly to an Emacs buffer (try echo hello >#<buffer results>).

What is the difference between shell, eshell, and term in Emacs?

I suggest you to use eshell, since you can use any Emacs commands within Eshell as well. However, in Eshell, to send an interrupt signal, instead of Ctrl+C, you need to press twice: Ctrl+C Ctrl+C.

You have learned quite a bit about Emacs. Now, you can immediately use Emacs to do practical thing like jumping around a big source tree like Linux kernel. However, this is just a demo. You can do much more if you learn Emacs properly.

First, you have to install GNU Global.

• Linux:

  Click here and download the latest stable GNU Global. Then change to the directory where you have just downloaded and follow these steps:

  • tar xvf global-<version>.tar.gz
  • cd global-<version>/
  • If you have ctags installed, add the option --with-exuberant-ctags and supply the installed path: ./configure [--with-exuberant-ctags=/usr/local/bin/ctags]
  • make
  • sudo make install

• Windows:

  Click here and click "DOS and Windows 32 version" to download the binary archive.

  After your download the archive, create a directory C:\root and unzip the package into that folder:

  

  Right click on Computer -> Properties -> Advanced System Settings -> Environment Variables.

  If PATH variable does not exist, click New. Then in "Variable Name", enter PATH; in "Variable Value", enter C:\root\bin. From now on, if you use ggtags, Emacs knows where to find GNU Global programs. $PATH is the variable where Emacs search for executable programs. If you want more executable programs, add more path to $PATH variable. Each path is separated by ; like this:

  

• Mac OSX: Mac OSX version is distributed by MacPorts.

Then, start Emacs, and press C-x b and switch to *scratch* buffer. A buffer is an editing area; an editing area may or may not has a file behind it (i.e. A buffer for holding a shell). I will explain more about this later.

Paste the following code into the *scratch* buffer:

(require 'package)
(add-to-list 'package-archives
       '("melpa" . "http://melpa.milkbox.net/packages/") t)

The above code you see is Emacs Lisp.

Then, M-x eval-buffer and press RET.

After runs eval-buffer, the whole *scratch* buffer is processed. Then, M-x list-package. Wait a few seconds and you will see of list of plugins for Emacs. In Emacs, a plugin is called a package. Press C-s, and type ggtags and press C-s again. Your cursor will move to the package ggtags. Be sure to select one from melpa; you should see a column written *melpa and select the row that has melpa in it. Press Enter to stay at that position. As you see, C-s is used for searching text inside a buffer.

On the ggtags entry, press i key, which stands for install. Then press x to execute the installation. Emacs will ask you to confirm the installation. Type yes and press Enter. Wait for Emacs to finish its installation.

After installation is done, close the status buffer by pressing C-x 1, switch back to *scratch* buffer by C-x b. Paste the following code using C-y:

(add-hook 'c-mode-common-hook
    (lambda ()
      (when (derived-mode-p 'c-mode 'c++-mode 'java-mode 'asm-mode)
  (ggtags-mode 1))))

You may worry that you have to write Emacs Lisp every time you install something. Don't worry. Most package authors provide code snippets to setup their package properly. All you need to do is copy and paste. The above code is taken from ggtags homepage at configuration section. The configuration is meant to activate ggtags only in a few programming modes.

That's it. Now you can browse kernel easy and fast in Emacs (instant result display).

You can enjoy exploring the kernel source tree by following these steps:

• Clone the kernel source: git clone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git ~/linux

• C-x d and navigate to ~/linux, then press Enter.

  

  Then, turn on ggtags: M-x ggtags-mode .

• Emacs has a file explorer, as you've seen above, called Dired, short for (Dir)ectory (Ed)it.
• Before start browsing the kernel, you need to create a database for quick searching. Press M-x, type ggtags-create-tags. It asks for a directory; since you're in the root directory of Linux already, press Enter; ggtags asks whether you use ctags (which is another tag generating program, works with more languages but has less features). Type no, press Enter and wait for ggtags to generate the database.

• After the tag database is done generating, a message at the bottom of your Emacs prints a message GTAGS generated in ~/linux. Now you can start going anywhere in Linux source tree in an instant instead of spending hours to grep!
• Let's find a file in Linux. Every C program, whether large or small must have a main() function, and a file containing the function. Let's find out where the main() of Linux kernel is.
• M-x, type ggtags-find-file. C-c M-f also executes ggtags-find-file. A prompt ask for a file to find. You can also invoke ggtags-find-file with C-c M-f.
• Enter main.c to the prompt and press Enter.

• You will see a list of main.c files below in various directory:

  

  You can visit each file by pressing M-n (n means next) to go down or M-p to up (p means previous).

  Press M-s s. A prompt appears waiting for something to search; type init/main.c. As you type, the candidate buffer got highlighted gradually.

• Finally you get into the correct file. This is where Linux starts after the bootloader stage.

• Now, you see a lot of names in this file: variable names, function names… Now, you want to find where all of these names are defined and where they are used. Let's scroll down a bit, either with Page Down key or scrolling with the mouse or search for it. If you want to search, press C-s and type kernel_init and press C-s repeatedly. C-s is available everywhere in Emacs. M-s s is just available in ggtags. You see a function declaration like this:

  static int kernel_init(void *);
  

  This is the whole process of finding the file:

  

  You can find definitions or references of a tag easily. Now, let's go back to the declaration static int kernel_init(void *); again. Move your cursor on kernel_init.

  Press M-. jumps to its definition. M-. again jumps to its references, where the function is called. M-. again jumps to the definition again. Basically, if the current view is definition, pressing M-. switches to references and vice verse. Usually, you will also see a list of candidates similar to the one you saw using ggtags-find-file above. Use M-n or M-p to select next/previous match.

  If you want to go back to where you were, press M-* (or M-Shift-8) brings you back to the previous place where you jumped.

  If you want to jump to a C header file, for example:

  #include <linux/kernel.h>
  

  Move your cursor onto that line and press M-..

  Again, you can search for candidates using M-s s.

  After navigating for a while, you may have jumped to many places. To view the history of where you were, press C-c M-h:

  

  If you want to have a list of all the tags you visited, press C-c M-/. The different between this command and the above command is that, C-c M-h stores the places in files you visited, while C-c M-/ stores the tag operations you performed. After press C-c M-/, if you select an entry in the result list, it displays the result list of the tag in the selected entry, along with your match candidate you selected in the past:

  

  If you create, edit or delete a source file in your project, upon saving ggtags automatically updates the database of your project. How convenient!

  That's it for basic navigation. Yes, it's just the basic. This is just the tip of the iceberg. In Emacs, you have a toolchain called CEDET, short for Collection of Emacs Development Environment Tools, which offers features such as highlighting, project, smart jump, context-sensitive completion, symbol references, code generation… And Emacs includes CEDET by default from Emacs 23.2. CEDET is also a language framework for language writers to create such tools within Emacs for their languages, but currently the best supported language in CEDET is C/C++.

  ggtags solves your navigation need, but does not offer the above features. However, with ggtags alone, it's far enough for your C/C++ projects, thanks to GNU Global for working nicely on large source tree like the Linux kernel.. After all, many people write C/C++ source code on a bare minimum editor and waste a lot of time doing things manually instead of focusing on their problems.

  After this demo, are you convinced now? If you want to harness the power of Emacs even further, you need to learn Emacs properly. Finally, close everything you don't need with C-x k

Emacs allows you to do much more than just editing. Emacs is not a mere editor like others, either in terminal or in GUI. Emacs is a development platform. Emacs is a virtual machine that interprets its own bytecode.

You can write all sorts of programs in Emacs to add more features using its own language - Emacs Lisp - in an easy way. With this extensibility, Emacs can be many things: an editor, a file manager, an email client, a news reader, a shell…

You can think of Emacs as an enhanced interpreter and evaluate any valid Emacs Lisp code anywhere in Emacs, as long as the code is visible on your screen. To illustrate my point, here is an example:

(defun hello ()
  (interactive)
  (message "Hello World"))

You can paste that code snippet anywhere - yes, anywhere - in Emacs and tell Emacs to execute that code. If the code snippet has valid syntax, Emacs executes successfully and you will have command to print "Hello World" at the bottom of screen.

A great advantage of this approach is, if you want to change the behaviour of Emacs, you write some Emacs Lisp code, execute it and immediately see the results, right inside Emacs. Emacs is beyond an editor. Emacs is a programming platform that has an editor. Don't confuse Emacs with other real editors, which can only be used for editing.

In practice, Emacs also offers many editing interfaces: built-in Emacs, Ergoemacs and Evil - or Vim inside Emacs - key bindings. Emacs has internal tools and interfaces to external tools for many programming languages. Learning Emacs means you can use the same editor for different languages. Otherwise, you will have to learn a different editor when you learn a random language.

"Why Emacs?" by Fabrice Popinea. He is the maintainer of Emacs 64 bit on Windows.

"Why Emacs?" by Bozhidar Batsov. He is the author of Emacs Prelude, an Emacs distribution with convenient packages for new people to get start with Emacs.

Why I use Emacs by Vincent Foley-Bourgon.

Why I Still Use Emacs, also by Vincent Foley-Bourgon.

Emacs is sexy.

Ever heard of a computing system called Lisp Machine? I bet many of you don't. Me, too, until I started using Emacs and gradually learned enough to know such a thing ever existed. This old article is an interesting read: The Ghost in the Lisp Machine

A friend of mine used to say that Emacs fills our yearning for a Lisp Machine. I tend to agree with him: Emacs is not just an editor, but a full integrated environment where you can perform virtually any imaginable task; and, most importantly, the inner workings of the system are open to you to explore and extend. Using, for extra fun, Lisp. No, i don’t think that Elisp is the nicest Lisp incarnation around, but is far better than, say, C, and i still prefer it to other scripting languages. Moreover, the awesome range of libraries at your disposal makes up for many of the deficiencies in the language.

Living in Emacs is addictive. Imagine an operating system where you can switch from writing code to browsing the web or chatting without leaving a consistent environment, with the same set of commands and shortcuts. Imagine a set of integrated applications where data is seamlessly shared, where any single functionality can be tweaked, extended and adapted to your particular needs. Where everything is easily scriptable. Imagine, in addition, that the environment provides powerful and complete interactive self-documentation facilities with which the user can find out what is available. I have yet to find an operating system providing such an integrated environment. Not even Mac OS X, where AppleScript support is often lacking and system services are underused.

Of course, the key ingredient here is Emacs’ extensibility. Far from being an afterthought or simply one of its features, extensibility is the central aspect of Emacs’ architecture. Actually, the whole point of this post is to recommend you reading Richard Stallman’s 1981 essay EMACS: The Extensible, Customizable Display Editor, which explains much better than I could the strong points of Emacs design, i.e., those traits that make Emacs more, much more, than just an editor. From the horse’s mouth:

Extensibility means that the user can add new editing commands or change old ones to fit his editing needs, while he is editing. EMACS is written in a modular fashion, composed of many separate and independent functions. The user extends EMACS by adding or replacing functions, writing their definitions in the same language that was used to write the original EMACS system. We will explain below why this is the only method of extension which is practical in use: others are theoretically equally good but discourage use, or discourage nontrivial use.

[…]

User customization helps in another, subtler way, by making the whole user community into a breeding and testing ground for new ideas. Users think of small changes, try them, and give them to other users–if an idea becomes popular, it can be incorporated into the core system. When we poll users on suggested changes, they can respond on the basis of actual experience rather than thought experiments.

The article goes on explaining the organization of the Emacs system, how it depends on its interpreter, Elisp’s main features and how built-in self-documentation is provided. Also interesting is the list of related systems at the end of the essay: Lisp machines, LOGO, MacLisp and Smalltalk. We’re definitely in good company!

Emacs is a miniature of a Lisp Machine. You can take a tour at the Lisp Machine online museum.