NOT "Vi vs. Emacs" -- Despite twenty or thirty years of abuse thrown at each other by adherents of the Church of Vi vs the Church of Emacs, I feel the two editors are complementary, rather than antagonistic. They have a very different "look and feel", but that's not a real reason for choosing one over the other. They were designed for different jobs, they are better at different things, and I use both of them, depending on the job.
Specifically, I use GNU Emacs and Vim, and every time I say "Emacs" or "Vi", assume these programs unless proven otherwise.
Vi and Emacs are alike:
Full-function editors
TTY and GUI versions.
Implemented on many platforms:
Widespread Availability
Several versions available:
Vi and Emacs are different:
Most simply, Vi was designed to write PROGRAMS, with all other types of file possible. Emacs was designed to write TEXT, with all other types of file possible.
Vi is much smaller and loads much faster; it will fit on a diskette while Emacs quite definitely will not.
The Biggie: Emacs is modeless, Vi has modes.
This relates to how an editor performs its two main functions: entering text and executing commands relating to the text. Most modern editors and word processors are modeless, so that a user may enter text (e.g., typing "A") or a command (^S to save the file) at any time.
Vi has three modes:
Text insert mode
Keystroke command mode (vi mode)
Command line mode (ex mode)
Plus and Minus for modeless (Emacs):
(+) Familiar.
(+) Easily adapts to standard GUI pull-down menu style.
(-) Commands have complicated syntax and hard-to-type keystrokes, since a limited number of keys are available for commands.
(-) Some needed keys might not be available on all keyboards.
Plus and Minus for modes (Vi):
(-) Confusion about which mode program is currently in.
(-) Nuisance of switching modes frequently.
(+) Many more keystrokes (~90) available for commands.
(+) Touch typists tend to become very proficient because the fingers can stay in their normal positions almost all the time.
The bash shell can be configured for either style through the commands set -o emacs (the default) or set -o vi
Vi and Emacs Keystroke Usage
Here are a few typical commands, showing the differences between "mode" style and "modeless" style:
VI EMACS
--
Right one column k ^f
Right one word w Esc,f
Left one word b Esc,b
Next sentence ) Esc,e
Previous sentence ( Esc,a
Save file :w ^x,^s
Delete paragraph d} Esc,x,kill-p[TAB],[RET]
Edit a new file :ename ^x,^f,name
RegEx search for "foo" /foo Esc,^sfoo
Repeat search n ^s,[RET]
Exit :q or QQ ^x,^c
Save and Exit :x ^x,^s,^x,k,[RET]
Repeat last search n ^s,[RET]
Paste from clipboard p ^y
Delete 7 lines 7dd ^a,Esc,7,^k
Undo u ^x,u or ^/
Change a letter to "x" rx ^d,x
Go to line 6 :6[RET] Esc,<,Esc,5,^n
..or 6G Esc,x,goto-l[TAB][RET],6[RET]
You can easily see Vi tends to have simpler commands (in command mode) because it has all the "ordinary" letters and numbers available for navigational use.
Note that the Emacs documentation makes frequent mention of the "Meta" key, including key sequences like M-a, etc. Since most keyboards do not have such a key, M-a, for example, can be done two different ways:
Esc,a That is, hit the Escape key, let go, then hit the "a" key. This will work on all keyboards.
Alt-a That is, while holding down the Alt key, press "a", then release both. This will usually work on a local PC keyboard (one actually attached to the machine where the editing is taking place), but almost certainly will not work on a remote terminal.
Vi Mode Navigation
[ESC] always enters vi (keystroke command) mode. If already there, it just beeps. (Hint: Bottom line is blank)
From vi mode, colon (:) enters ex (command line) mode. (Hint: colon (:) and cursor show on bottom line)
From vi mode, various commands enter insert mode: i (insert), a(append), o (open line), cw (change word), etc. (Hint: Cursor doesn't move, --INSERT-- shows on bottom line)
GUI vs TTY
The Vi TTY program loads very quickly, and is particularly useful for small changes to files.
SSH and Telnet are text-only, so you need to use the TTY version of either editor if remotely connected.
If you plan to spend a long time in the editor, the GUI versions are the better choice:
They start in different windows, so the command line is still there.
Font size, color scheme, window dimensions easily adjustable.
Editing several files at once is easier.
Emacs LISP
Emacs actually consists of a LISP interpreter executing a few pre-compiled primitive routines written in C plus about 200,000 lines of LISP code to implement all the functions of the editor. This makes Emacs extremely flexible, since an experienced LISP programmer can change anything and everything, as well as create new actions the program's author never thought of.
Emacs can be made into an e-mail client, a web browser, a chess opponent, etc. by simply adding the proper code. A single keystroke can be mapped to execute an entire LISP program, which uses the file being edited as its subject matter. For example, here is a segment of my .emacs file, which defines a function called lookat-file and then "binds" it to the CTRL-F key.
(defun lookat-file ()
"Edit file with name delimited by colon at beginning of current line."
(interactive)
(save-excursion
(save-match-data
(beginning-of-line)
(search-forward-regexp "^\\(.*\\):")
(find-file (match-string 1)))))
(define-key global-map "^F" 'lookat-file)
LISP functions are all defined the same way:
(funcname arg1 arg2 ...)
The last line in the example calls the function define-key with three arguments: the variable global-map, the literal ^F (the CTRL-F key), and the function name lookat-file, previously defined.
All built-in functions (like define-key and variables (like global-map) are fully documented in the extensive Emacs help system. In the definition of lookat-file shown above, every single keyword is a built-in LISP function.
Note that Emacs is fairly easy to port to a new architecture, because the "look and feel" is entirely defined by the LISP code, and that is unchanged whether Emacs is running on Solaris, Linux, Win98, or whatever. The only code that has to be modified is the LISP interpreter itself plus the primitives that handle platform-dependent stuff like file i/o and the other interfaces to the OS.
LISP Structure
LISP is actually very simple, because everything has the same form, namely a list of items enclosed in parentheses, and all program operations are function calls. Variables are untyped. For example:
(+ 2 3) ; add 2 and 3, return 5 as the value of the function.
(setq foo "John") ; store the string "John" into the variable foo.
(setq foo (+ 2 3)) ; store 5 into foo
(setq foo (and huey dewey louie))
; set foo true if all three are true, else false
(setq bar (* (+ 2 3) (- 6 2) (* 2 2) (sqrt 9)))
; store 240 into bar.
(setq ans (if (< foo bar) 1 2))
; ans is 1 if foo is less than bar, 2 otherwise
(defun myfun (arglist) statements)
; define function myfun
From these examples, it is easy to see why it's a standard joke that LISP (which really stands for LISt Processor) is an acronym for "Lots of Irritating Silly Parentheses". BTW, Vi enthusiasts tend to claim that Emacs is an acronym for "Eight Meg and Continuously Swapping". Note that this joke has been around since the days when eight MB was a lot of memory. On the other hand, Emacs bigots will refer to Vi as "six". (In which case Vim would be what, 994?)
I have to correct one statement I made earlier. Actually, Emacs also has a command-line. Typing Alt-x (or Esc,x) puts the cursor into what Emacs calls the "mini-buffer" at the bottom of the screen, where the user can execute thousands of built-in or user-defined LISP routines. For example, I could execute my lookat-file function by typing Alt-x lookat-file[ENTER]. (Emacs has tab completion just like bash or zsh, so in practice I would have typed Alt,x loo[TAB][ENTER], there being no other LISP function on my machine that starts with those three letters.) Bottom Line
I use both editors regularly. Sometimes the choice is random, but for some tasks I will always use either Vi or Emacs.
Emacs GUI is much easier to use for large text jobs - writing the Great American Novel or whatever - and producing a "clean" file.
Vi TTY is always used for editing .rc files, producing quick-and-dirty scripts, etc.
I have extended Emacs to perform a couple of tasks that neither editor will do automatically in their virgin state.
Gvim is better integrated with Xwindows - easier "look and feel", better fonts, better syntax highlighting, a button bar, etc. It looks very different from the TTY version, whereas the TTY and GUI versions of Emacs look very much the same, but some of that is because Emacs managed to implement a "pull-down" menu system in TTY mode!
Emacs is better at editing many files at once. It is simple, for example, to switch to a directory containing a programming project and say: emacs Makefile *.[ch] to edit the whole project at the same time. Both editors can issue the actual "make" from within the editor, capture and parse the error messages, and position the cursor on the correct line in the correct file.