Acme Editor: A Detailed Tour of its Mouse-Driven Interface and Text-Driven Programming Capabilities

Russ Cox

Introduction to Acme [0:00]

• Acme is a text editor originally created by Rob Pike for the Plan 9 operating system.
  • It was developed almost 20 years prior to the video's creation.
• Acme is now widely available on various Unix-like systems.
  • This includes FreeBSD, Linux, and OSX.
  • There is also a port for the Inferno operating system, which allows it to run on Windows.
  • Further information and downloads are available via a link in the video description.
• Acme's distinguishing feature is its philosophy of working alongside the surrounding system.
  • It does not try to be a complete, self-contained development environment.
  • It creates an experience where text is dynamic, executable, and can be assigned arbitrary meanings.
  • Plugins, written in any language, can interact with Acme and control its windows.
• The result is that users can continue using their existing tools.
  • These tools can be customized to fit well within the Acme environment.
• This screencast aims to convey the user experience of Acme.
  • It starts with basics and progresses to a short programming session.
  • The video is sized for YouTube's large player mode; fuzzy text indicates a need to switch to that mode.

User Interface Tour [1:27]

• Acme is a graphical program, not cursor-addressed, making extensive use of the mouse.
  • The screen shown is a small Acme screen, sized for the video player.
  • Normally, a larger display would be used, often full-screen or across multiple monitors (Acme on one, other applications on another).
• Acme manages window layout automatically.
  • It chooses window locations and arranges them in columns.
  • The current display has two columns; larger screens can comfortably support three or four.
• Each column contains a number of windows.
  • The left column currently shows a single window for the "quick UI tour."
  • The right column contains two windows: one showing a directory and another for a shell session.
• Each window has two primary parts:
  • The top line or "tag": Set on a light blue background, it displays the file name and various commands (e.g., "Del," "Snarf").
  • The "body": Set on a light yellow background, it shows the window's content.
• A nearly square "layout box" is present to the left of each window's tag.
  • It fills dark blue when a window has been edited, indicating it might need saving.
• Each column also has a tag.
  • It includes useful commands (e.g., "New Col," "Delcol") and its own layout box.
• Acme's UI assumes a three-button mouse and a graphical display.
  • There is no text-only mode or cursor addressing.
  • For this screencast, Acme has been modified to show which mouse buttons are held down above the pointer.
  • Buttons are referred to as Button 1 (left), Button 2 (middle), and Button 3 (right).
• The scrollbar to the left of the body is non-standard but powerful. [3:15]
  • It darkens to represent the entire content, with a light box showing the currently viewed fraction.
  • Button 2 in the bar moves to a different part of the text directly.
  • Button 1 scrolls up, Button 3 scrolls down.
  • The scroll amount depends on where in the scrollbar the click occurs (e.g., top scrolls line by line, three-quarters down scrolls by three-quarters of a window).
• The layout box also allows window manipulation: [4:03]
  • Clicking Button 1 expands the window in the column, nudging others.
  • Dragging Button 1 repositions the window without moving others.
  • Clicking Button 2 makes the window as large as possible while keeping other window tags visible.
  • Clicking Button 3 makes the window take over the entire column, hiding other windows.
  • Clicking other buttons brings hidden windows back.

Basic Mouse Interactions [4:45]

• The three mouse buttons have distinct roles for manipulating text:
  • Button 1 (left): Used for selecting text.
  • Button 2 (middle): Used for executing commands.
  • Button 3 (right): Used for searching and loading.
• Examples of Button 3 usage: [5:03]
  • Selecting "button" with Button 3 searches for the next instance of "button."
  • Selecting a file name like "sampler" with Button 3 opens a new window for that file.
  • Button 2 can then be used to execute commands like "Del" to close the window.
  • Text selection for Buttons 2 or 3 doesn't need to be precise; Acme expands clicks into a word selection.

Chorded Mouse Actions [5:40]

• Acme assigns meanings to combinations ("chords") of buttons:
  • Button 1 then Button 2: Cuts selected text.
  • Button 1 then Button 3: Pastes text over the selection.
  • Button 1, then Button 2, then Button 3 (before releasing Button 1): Performs a copy (cut then paste).
  • Button 2 then Button 1: Executes a command with an argument. Example: execute echo with "button" as the argument, displaying "button" in a new error window.

Executing Commands [6:32]

• Any text within Acme can be executed using Button 2.
  • Tags are convenient for listing useful commands, but text in the body or anywhere else can also be executed.
  • Example: Selecting "Cut" with Button 1 and then clicking with Button 2 executes the "Cut" command on itself.
  • The "Edit" command (similar to ed or sed) can apply editing language commands to the window body.
• External programs can be invoked as commands.
  • Running date executes the system's date program and puts its output into a temporary +Errors window.
  • Commands run in the directory of the current window. The +Errors window title reflects this.
• Text can be "piped" through a command.
  • A command prefixed with | (pipe) sends the selected text as input to the command and replaces the selection with the command's output.
  • Example: Piping text through rot13 encrypts/decrypts it.
  • A command prefixed with > (greater than arrow) sends the selected text to the command but does not read output back into the selection.
  • Example: Using >spell to check spelling shows results in the +Errors window.
  • A command prefixed with < (less than arrow) reads the command's output into the selection, running the command with no input.
  • Example: <astro runs the astro program, which outputs astronomical information.
• Commands are commonly kept in tags for easy access. [8:44]
  • The presenter uses personal scripts (a+, a-) in the tag for indenting/unindenting code.

Loading and Hyperlinking [9:10]

• Button 3 is used for loading, searching, or acquiring content.
  • It can load files or directories into new windows.
  • It uses a rich file address syntax:
    • file.go:3: Opens file.go and moves to line 3.
    • file.go:3:+8: Opens file.go, moves to line 3, then moves forward 8 Unicode characters.
    • file.go:3:9: A shorthand in local Acme settings for line 3, column 9.
    • file.go:/func/: Opens file.go and searches for the regular expression func at the beginning of a line.
    • /usr/src/go/pkg/encoding/json/stream_test.go: Example of a specific file path.
  • These addresses effectively act as hyperlinks within text files.
  • Unix tools like compilers or grep often generate addresses in the file:line format.
  • Acme supports Unicode and UTF-8, being one of the first editors to do so. [11:24]
• Loading can also involve existing tools.
  • For example, clicking on a comment referencing sysfile.c can open that file.
• The "plumber" program is central to advanced loading. [18:15]
  • The plumber is controlled by a rule file (/mnt/plumb/rules) that contains patterns.
  • These patterns are matched against text clicked with Button 3.
  • Rules define actions: e.g., if text ends in .pdf and names an existing file, it's passed to the Plan 9 page program (a PDF viewer).
  • If text looks like a URL (starts with http://), it's handed to the web browser.
  • Users can write their own rules to customize text interpretation and actions.

Acme as an Integrating Development Environment (IDE) [11:37]

• Acme is presented as an "integrating development environment," differing from traditional IDEs.
  • Traditional IDEs try to do "everything" (source code editor, build tools, debugger, compiler/interpreter).
  • Acme provides the editor part but assumes the user already has other tools (compilers, debuggers) and focuses on integrating them effectively.
  • It helps users leverage their existing tools more efficiently, fitting into the surrounding system (Unix, Plan 9).
• Acme interacts with other tools through a file system interface. [12:23]
  • On Plan 9, Acme serves its internal state as a file system.
  • On Unix, Acme still serves the Plan 9 file protocol, and FUSE (Filesystem in Userspace) allows mounting Acme's state directly into the kernel file tree. (FUSE is not a strict requirement).
  • Each Acme window appears as a subdirectory under /mnt/acme/ (or the equivalent mount point).
  • The index file lists all windows and their tags.
  • Users can cat (read) the tag and body files of a window.
  • Users can echo (write) directly to the body file of a window from the shell.
• This file system interface allows running external programs that are "aware" of Acme. [13:25]
  • Examples:
    • The slide+ script (written in shell) advances slides for presentations, showing how it uses control messages to update window tags and reload content.
    • The adict program (a dictionary client for Acme) shows how Button 3's "load" functionality can be redefined within a specific window to perform dictionary lookups.
    • The win program (a terminal window) creates a new shell session linked to an Acme window, allowing command-line editing within the Acme environment, with history and live output updates.
    • Other Acme client programs include mail readers, debuggers, chat clients, and music players, written in various languages (shell, C, Go, Python, E-Lisp).
• Advanced Loading with the Plumber: [17:01]
  • The plumber program extends Button 3's loading capabilities.
  • It can synthesize new window content (e.g., acme[<a href="https://youtube.com/watch?v=dP1xVpMPn8M&t=1">1</a>] brings up Acme's man page).
  • It can invoke external programs based on context (e.g., right-clicking a Mercurial commit hash shows the commit details; right-clicking a UPS tracking number shows shipment status).
  • It also handled phone numbers to dial them.
  • The "link logic" (how text is interpreted and what action it triggers) is separate from text formatting, giving users control over how unlinked text is reinterpreted.
• Example of Fixing a Go Issue [19:34]
  • The presenter demonstrates fixing a Go deadlocking issue by using Button 3 to look up issue details.
  • They copy the test code into an Acme window.
  • They use watch go test -short to continuously run the test suite while making changes.
  • Compiler errors are identified and corrected (e.g., adding import "net").
  • A deadlock is encountered, and the debugger output is reviewed.
  • They find the root cause (JSON array handling) by inspecting the code, realizing a previous fix only applied to JSON objects, not arrays.
  • They modify the code to treat arrays like objects for scan-end logic.
  • The test passes, indicating the bug is fixed.

Conclusion [22:29]

• Acme is a text-driven programming system.
• It is an integrating development environment.
• It offers language-independent extensibility.
• For more information and to try it out, visit the blog post linked on the screen and in the video description.