Beautiful Architecture

1. Emacs: A powerful, extensible text editor with a devoted following

Emacs outshines all other editing software in approximately the same way that the noonday sun does the stars. It is not just bigger and brighter; it simply makes everything else vanish.

Unparalleled versatility. Emacs is more than just a text editor; it's a complete computing environment. With over 1.1 million lines of Emacs Lisp code, it offers functionality ranging from basic text editing to debugging programs, reading email, browsing directories, and even solving symbolic algebra problems.

Unique user experience. Unlike traditional editors, Emacs is designed to be started once and left running. Users can edit multiple files within a single session, keeping their work readily accessible. The interface is built around three key concepts:

• Frames: Emacs' term for windows in a graphical user interface
• Windows: Subdivisions of frames for displaying content
• Buffers: Containers for editable text, which may or may not be associated with files

Editable everything. One of Emacs' most powerful features is that almost all content, including help messages, search results, and directory listings, is presented in editable buffers. This allows users to manipulate and reuse information flexibly, making Emacs uniquely suited for complex text manipulation tasks.

2. Emacs architecture: Model-View-Controller pattern with Lisp at its core

Emacs's architecture follows the widely used Model-View-Controller pattern for interactive applications.

Architectural breakdown. Emacs' architecture can be divided into three main components:

• Model: The buffer, which holds text and associated metadata
• View: The redisplay engine, responsible for updating the screen
• Controller: Emacs Lisp code, which handles user input and manipulates the model

Buffer as model. The heart of Emacs' model is the buffer, a simple flat string with newline characters marking line endings. Buffers support various operations:

• Insertion and deletion of text
• Extraction of portions as strings
• Searching for matches of exact strings or regular expressions
• Support for multiple character sets
• Undo logging for reversing changes

Automatic redisplay. Emacs' view component, the redisplay engine, updates the display automatically without explicit guidance from Lisp code. This simplifies extension development by allowing programmers to focus on manipulating the model without worrying about display updates.

3. Emacs Lisp: The engine driving Emacs' extensibility and customization

Emacs Lisp is interactive. You can enter definitions and expressions into an Emacs buffer and evaluate them immediately.

Powerful extension language. Emacs Lisp is the core of Emacs' extensibility. It offers several key features:

• Low bureaucracy: Small customizations can be easily added to the .emacs file
• Interactive development: Changes can be made and evaluated without restarting Emacs
• First-class citizenship: User-written Lisp code has the same access and privileges as built-in code
• Full programming language: Suitable for writing large, complex programs
• Safety: Buggy Lisp code can't crash Emacs, encouraging experimentation
• Easy documentation: Functions can include docstrings for instant help

Drawbacks and trade-offs. Despite its power, Emacs Lisp has some limitations:

• No module system: Naming conventions are used to avoid conflicts between packages
• Global visibility: All functions in a package are visible to other packages
• No object system: This can make certain programming paradigms more challenging

4. Creeping featurism: A strength, not a weakness, in Emacs' design

Emacs's creeping featurism is a direct consequence of its architecture.

Feature growth cycle. Emacs' architecture encourages organic growth of features:

1. Easy implementation of new ideas due to low entry barrier
2. Personal customizations added to .emacs files
3. Popular customizations grow into sharable packages
4. Best packages incorporated into the standard Emacs distribution

Managing complexity. Despite the constant addition of features, Emacs manages to avoid becoming unmanageable:

• User interface complexity is mitigated by allowing users to discover features gradually
• Maintainability is preserved by treating Emacs as a collection of packages rather than a monolithic whole
• The Lisp language acts as an abstraction boundary, allowing core C code to evolve without breaking compatibility

Community-driven development. The growth of Emacs features is largely a grass-roots process, reflecting users' interests and needs. This ensures that new features are genuinely useful and well-tested before becoming part of the standard distribution.

5. Emacs vs. other architectures: Eclipse and Firefox as comparisons

Eclipse's architecture is nothing if not open-ended, as plug-ins provide nearly all significant functionality.

Eclipse: Powerful but complex. Eclipse offers a plug-in architecture that provides extensive functionality but has drawbacks:

• Plug-in development is not safe; bugs can crash the entire system
• Writing plug-ins requires dealing with complex interfaces
• Significant boilerplate code is needed, even for simple extensions

Firefox: A middle ground. Firefox's architecture shares some similarities with Emacs:

• Uses JavaScript, an interpreted, dynamic language like Emacs Lisp
• Provides automatic display management
• Allows for incremental development of extensions

Emacs' advantage. Emacs' architecture offers a unique combination of power and simplicity:

• Safe execution environment for extensions
• Low barrier to entry for simple customizations
• Ability to scale up to complex, full-featured extensions
• Consistent interface for both built-in and user-created functionality

6. The power of composability in user interfaces

How easy is it to use the results of one command as input to another? Do the interface's commands compose with each other? Or have the results reached a dead end once they've been displayed?

Emacs' composable interface. Emacs excels at allowing users to combine and reuse command outputs:

• All content is presented in editable buffers
• Standard text manipulation commands apply to all types of content
• Results from one command can easily serve as input for another

Benefits of composability. This approach offers several advantages:

• Increased flexibility in how users interact with data
• Ability to create complex workflows from simple building blocks
• Encourages experimentation and discovery of new ways to use the system

Comparison with other systems. Many modern applications, such as Microsoft Visual Studio, limit how users can interact with command outputs, reducing flexibility and potential for creative problem-solving.

7. Evaluating extension languages and plug-in facilities

Is the extension language the preferred way to implement most new features for the application?

Key questions for evaluating extensibility:

1. What interfaces are available for plug-ins to use?
2. Are they simple enough to allow rapid development?
3. Can developers work at a high level of abstraction, close to the problem domain?
4. How is the application's data protected from buggy plug-in code?

Emacs' approach. Emacs excels in these areas:

• Emacs Lisp is used for implementing most new features
• The extension language has full access to Emacs' internal functionality
• Lisp's high-level abstraction allows for rapid development
• The Lisp interpreter provides a safe execution environment

Importance of first-class extensions. When an application's extension language is powerful and well-integrated, it encourages a vibrant ecosystem of user-created functionality. This can lead to unexpected and innovative uses of the application, far beyond what its original creators envisioned.

Last updated: September 7, 2024