Distilling the Essence of Emacs

• The next System Crafters video will be about Embark, perhaps next week!
• Flux Harmonic will be starting up again soon! Subscribe if you haven’t yet: https://youtube.com/FluxHarmonicLive
• Support the channel! Buy Mastering Emacs with this link https://www.masteringemacs.org/r/systemcrafters

As you may have already suspected, Emacs is probably the most hackable and customizable program that has ever existed. But how does it accomplish that?

Today I’d like to spend some time discussing the unique aspects of Emacs that enable this ultimate hackability so that we can basically produce a blueprint for other programs that might hope to replicate what Emacs has accomplished.

What I really want is to get your ideas and feedback here so that I don’t miss anything!

The purpose for discussing this is that I would really like to experiment with building Emacs-like applications for other use cases. We’ll be looking into this on the Flux Harmonic channel when I start producing videos there again.

• The text-focused interface
• Defining user-facing actions as commands
• The flexibility of the minibuffer
• Theming and visual customization with faces
• Window and frame management
• Mode line (you can put whatever you want in there)

Question: could a more graphical representation still be as effective or hackable?

(How does Blender accomplish UI extensibility?)

• Prefix key system
• Binding keys directly to commands
• Ability to totally change input style (evil-mode, etc)
• Mode maps

Question: does a program need such extensive ability to control key bindings to be considered hackable?

What are the unique aspects of Emacs Lisp that make it especially effective as a configuration language?

• Lack of module namespaces
• Simplicity of libraries
• Hooks as a core extensibility point
• You can hook/hack any function with advice
• You can redefine any function no matter where it’s defined (as long as it wasn’t a C function)
• Core program behavior (buffers, windows, frames) represented as first class objects
• Major and minor modes
• Self-documenting and source is easily accessible
• You can inspect any variable or function at any time
• Easy to pull in community-authored packages

Question: could you still achieve the same hackability with a better language?

• Having a clear documentation/manual strategy that isn’t hard to keep up to date is critical for a hackable application

Anything major that we’re missing from the previous items?

• The fact that you can re-evaluate code and extend Emacs while the program is running!

What could be done better?

• The way you manipulate buffers is not very convenient (especially when you need to have a more structured representation of data)
• Emacs was designed in a totally different era, lots of legacy design decisions
• Asychrony should be easier to manage (not so in Emacs Lisp) - but how do you deal with the inevitable concurrency issues
• Being able to make use of modern computing resources (more memory, more cores)
• Immutable data types?