Tool Time Session 1: Emacs Editing Basics

• Joe Finnegan: for making the recordings possible and enshrining all my mistakes permanently the in the clogged tubes of the Internet
• Computer Science Dept: for supporting and advertising the series
• Institute of Mathematics and its Applications: for lending us Keller 3-180 to do this session
• Students Past and Present: for showing interest in these tools, pestering me to show them how they work, and showing up today

• Default appearance is on the bland side

  • Emacs always starts with a "scratch buffer": text editing area not associated with any file
  • Menu Bar at top, beneath it the Toolbar (should be familiar to most)
  • Mode Line: Just above the bottom, usually a different color, shows info on buffer/file, state, position in buffer, editing mode, etc.
  • Minibuffer: Single line at the bottom of the screen, used for feedback from Emacs and input for certain commands

• Kauffman Customized Emacs

• Observations
  • Buffers show text of some kind, sometimes associated with a file, other times associated with a process like a running shell or compilation
  • Each buffer has an editing area with Mode Line and Mini Buffer
  • Most activities have an associated Major Mode: c-mode for editing C files, Compilation for compiling, dired-mode for viewing/editing directories, etc.
  • Emacs can have many buffers open, each doing something different
  • Must have commands: how to split into multiple windows and change between them, how to switch between open buffers

• In Emacs, most keys on the keyboard insert associated characters
  • Pressing 'A' will insert 'a' into a buffer
  • Holding 'Shift' and pressing 'A' inserts 'A'
  • Pressing 'Backspace' deletes the preceding character
  • Pressing 'Enter' inserts a newline
• Referred to as "normal", "modeless", "non-modal" behavior
• Contrast: vi / vim use Modal Editing
  • vi is always in a 'mode', usually Command or Insertion
  • In Command mode pressing 'X' deletes a character
  • In Command mode pressing 'I' changes to Insertion mode
  • In Insertion mode pressing 'X' inserts 'x'
  • In Insertion mode pressing 'Esc' changes to Command mode
• Principle: Pressing keys in runs commands in Vim Command mode
• Principle: Pressing keys in Emacs always runs commands
  • Some commands insert characters
  • Other commands move cursor, delete text, open files, etc.
  • Emacs Modes establish certain key bindings appropriate to the type of text one is editing (text, code, shell, directory, etc.)

• Emacs has complex key bindings, often called chords (like pressing multiple keys on a piano)
• Chords involve holding a bottom row key, have abbreviations
  • C-w : hold Control while pressing 'w'
  • M-f : hold Alt (Windows) / Cmd (Apple) while pressing 'f'
  • C-x b : Hold Control, press 'x', release both, then press 'b'
• Common chord conventions
  • C-x keys: global manipulations (open files, switch buffers, quit)
  • C-c keys: mode-specific commands (evaluate code, compile, comment)
  • M-x command: run interactive commands by name
  • M-: lisp: execute lisp code

• Emacs allows any key combination to bound to run a function
• Core functions are written in C and compiled as part of the Emacs source code
• Most functions are written in Emacs Lisp
• M-x will jump to the mini buffer; type the name of an interactive function to run it (not all functions are "interactive")
• All functions can be evaluated in their Lisp form via M-: which will prompt for Emacs Lisp code to evaluate
• All of the below have the same effect

• Much of text editing is position the cursor
• Efficient cursor movement -> efficient editing
• Emacs born in the pre-Mouse era, provides TONS of movement commands
• At first the quantity of movement commands seems ridiculous:
  • HOW could I ever learn all these?
  • WHY would I ever learn all these?
• Promise: if you spend a year steadily practicing and absorbing movement using the keyboard, you will edit code an order of magnitude faster; after 3 hours of coding you'll realize you never touched your mouse because the ideas flowed from your fingers directly into the buffer

• The following are among the most common movement commands
• Most are tied to easy to reach keys and have bindings that roughly reflect their effect ('f' for forward, 'b' for back, etc.)

• Side benefit: default Shell command line interpreter bash uses similar bindings for movement when editing command lines

  Keys	Effect	In Bash?
  C-f	Forward character	Same
  C-b	Backward character	Same
  M-f	Forward word	Same
  M-b	Backward word	Same
  C-a	Beginning of line	Same
  C-e	End of line	Same
  C-p	Previous line	Prev Command
  C-n	Next line	Next Command
  M-e	Forward/End of sentence	-
  M-a	Backward/Beginning of sentence	-
  M-}	Forward/End of paragraph	-
  M-{	Backward/End of paragraph	-
  M->	End of file
  M-<	Beginning of file

• Emacs aware of some structural features of text docs
• Parenthesized expressions in code modes
• Heading in outline modes

• Modes provide commands/key bindings for structural movement

  Keys	Command	Effect
  C-M-f	forward-sexp	Forward over pren expression
  C-M-b	backward-sexp	Backward over paren expression
  C-M-u	backward-up-list	Move "up" one level of parens
  C-M-d	down-list	Move "down" one level of parens
  M-n	*-next-heading	Move to next heading
  M-p	*-prev-heading	Move to previous heading

• Interactive Search Forward/Backward: Extremely useful for navigation and search, TONS of cursor movement should be done via C-s or C-r
• Search is SUPER easy to start up and uses Minibuffer for reporting
• Versions that honor regular expressions available also

• Some situations dictate moving cursor to specific locations
• Usually going to specific line associated with an error: later associated with compilation

• Emacs also has a "bookmarking" facility to remember locations in files of interest AND an ability to store locations in "registers" for quick access

Point

The Cursor in Emacs (aside for the sake all that his holy run cursor-blink-mode to disable blinking)

Mark

An invisible position that is "remembered" in the buffer, used to jump around and edit

Region

The text that is between the Point and the Mark. Many commands affect the Region. Equivalent to the "highlighted text" in modern editors but always present and somewhat quirkier.

Emacs has Copy/Cut/Paste commands under slightly different names

Kill ~ Cut

Killing text is like "Cut" in most editors but there is a "history" of killed text called the Kill Ring

Yank ~ Paste

Put the top of the Kill Ring in at the point. Yanking multiple times in a row will Yank lower items in the Kill Ring.

Copy

Kill-ring-save will Copy text into the kill ring but don't remove it from the buffer

• Emacs has Undo/Redo facilities for mistakes

  Key / Command	Command Name	Effect
  C-/	undo	Undo the last action
  C-x u	undo	Same as above
  C-/ C-/	undo	Undo the last 2 actions
  C-u 10 C-/	undo	Undo the last 10 actions

• Interestingly, any undone action can be redone by taking an arbitrary action (entering a character of text) and the repeatedly undoing
  1. Enter the text "apple orange banana"
  2. Press C-/ repeatedly until the text is gone
  3. Press Space to enter a space
  4. Press C-/ repeatedly to undo the space and recover "apple orange banana"
• Undo/Redo history is kept in a Ring (like the Kill Ring) so has some interesting properties but most undo problems can be solved by typing a few characters and then pounding C-/ for dear life

• Emacs can record editing commands to automate repeated tasks that might otherwise require shell scripts

• Can save macros to be used as named functions later

  Key / Command	Command Name	Effect
  C-x (	kmacro-start-macro	Start recording a keyboard macro
  C-x )	kmacro-end-macro	Stop recording a macro
  C-x e	kmacro-end-and-call-macro	Execute the last keyboard macro once
  C-x e e e		Repeatedly execute the last macro (3x)
  C-x h	mark-whole-buffer	Make the region the whole buffer
  C-x C-k r	apply-macro-to-region-lines	Repeatedly apply the macro through the whole region
  	edit-last-kbd-macro	Show macro /comments in a buffer allowing changes
  C-x C-k n	name-last-kbd-macro	Give a name to the last macro for further use
  	insert-kbd-macro	Insert a named macro as executable Lisp code

• Demonstrate this for quick text transformation on the text in the survey-results/ directory

• A common feature of modern editors is 'multiple cursors' : change text in columns
• Emacs (and Vi) have this capability as well
• Emacs calls them Rectangles and has chords/commands to edit them

• Rectangle commands shift text left/right on all lines that the affect

  Key / Command	Command Name	Effect
  C-x r t	string-rectangle	Insert text in Rectangle defined by Point/Mark
  C-x r d	delete-rectangle	Delete text in Rectangle defined by Point/Mark
  C-x r k	kill-rectangle	Kill text in Rectangle defined by Point/Mark
  C-x r y	yank-rectangle	Yank last killed rectangle at the Point

• Demo this using a buffer of numbers
  • Open a scratch buffer
  • Then C-u M-! seq 100 to populate with numbers
  • Play with various rectangle commands

• Some commands can be modified by typing C-u before the command : C-u is the "Universal" argument
• C-u followed numbers passes a numeric argument to a function

• Both are used here and there in Emacs, effect varies by command, Examples:

  Key / Command	Command Name	Effect
  M-!	shell-command	Run a shell command typed into the minbuffer
  C-u M-!	shell-command	Run shell command and insert results at point
  C-f	forward-char	Move forward one character
  C-u 20 C-f	forward-char	Move forward 20 characters

• Common to replace some text in a buffer with other
• Interactive and non-interactive functions for this

• Also good spell-checking support

  Key / Command	Command Name	Effect
  M-%	query-replace	Prompt for text to search and replace
  		Scan forwards replacing interactively
  C-M-%	query-replace-regexp	Regex version of above
  	replace-string	Prompt for query/replacement
  		Non-interactively replace
  	replace-regexp	Regex version of above
  	ispell	Interactively check text for spelling
  	ispell-comments-and-strings	Better for code

• Opening files will automatically create buffers
• Switch between buffers or call up a listing of those buffers and pick one (in buffer)
• Running sub-processes like Shells also creates buffers but these aren't tied to a file
• Almost everything happens in buffers

• One killer kind of buffer is a Dired buffer for "Directory Editor"
• Allows one to navigate the file system in Emacs
• Also allows changes to files/folders in Emacs using familiar editing techniques

• It is worth emphasizing that the last two commands are EXTREMELY powerful
• Allow text operations to be used to rename files with extreme efficiency

• Emacs notion of a window is a pane within the same window
• Common to split windows horizontally and vertically for various tasks
• Windows may show same buffer or different buffers

• Commands exist to change window sizes with keyboard but haven't found that they are tremendously useful

• Emacs has GUI support for multiple "Windows" called "Frames" in Emacs parlance; single Emacs instance with multiple frames
• Have not found this particularly useful but they exist, most commands start with C-x 5 ... such as C-x 5 f to find a file in a new frame.

• Haven't found a language yet for which someone hasn't written a Major Mode: Emacs code that supports editing that specific programming language
• Most are named sensibly: c-mode, java-mode, python-mode, shell-script-mode etc.
• Sometimes named strangely, Ex: Ocaml's "Tuareg Mode"
• Major modes exist for other things like text-mode, org-mode, etc.

With compile and error jumping, can quickly edit files to get code up and running.

• Works mostly like a standard terminal/shell
• Can edit it like a normal text file except hitting "Enter" in front of the prompt sends commands
• NOT a fully function terminal so commands like top and nano will usually fail

• Inferior shells for interpreted languages (python, ocaml, ruby, octave, etc.)
• Demo: Python is fairly well supported via run-python, commands in python file can be sent to the interpreter easily, see
• Demo: Emacs features Advanced interaction with debuggers via the Grand Unified Debugger interface (GUD); try M-x gdb in the c-list-applicaton/directory

• Worth a look if you plan to edit binaries (not recommended)
• Provides a few conveniences such as ASCII string recognition and raw byte entry

• When you need to talk to someone, try M-x doctor
• Any insights you might gain were always there

• When the code just won't cooperate, take a break
• Just don't lose too much time after discovering M-x tetris