In Emacs, everything looks like a service

Developers and users within the Emacs community are increasingly framing the editor’s architecture as a collection of services, rather than a monolithic application. This shift aims to enhance modularity, customization, and integration capabilities, marking a significant conceptual change in how Emacs is approached and developed.

In recent discussions on mailing lists and developer forums, proponents of the ‘everything as a service’ approach argue that treating components—such as buffers, modes, and extensions—as independent services can improve flexibility. Rather than tightly coupling features, this model envisions each as a self-contained, interactable entity, which can be dynamically started, stopped, or replaced.

While this perspective is gaining traction, it remains primarily conceptual at this stage. There are no confirmed changes to Emacs core that implement this entirely, but some experimental projects and proposals are exploring service-like architectures within the editor. Notably, some developers see this as a way to modernize Emacs and better integrate with external tools or cloud-based services.

Implications for Emacs Architecture and User Customization

This conceptual shift could significantly impact how Emacs is developed and used. Viewing all features as services may enable more dynamic configurations, easier integration with external systems, and enhanced modularity. For users, this could mean more streamlined workflows and better support for modern development practices. For developers, it presents new opportunities for extending and maintaining the editor, but also raises questions about complexity and stability.

Evolution of Emacs and Modular Design Discussions

Emacs has long been known for its extensibility and customization, with a core architecture that allows users to modify and extend functionalities through Lisp scripts. Over the years, discussions about modularity and modern architecture have persisted, especially as the editor faces competition from more integrated IDEs and modern editors. The recent emphasis on viewing components as services reflects a broader trend towards service-oriented architecture (SOA) in software engineering, applied here to Emacs’ internal design.

This perspective was notably discussed at Emacs developer meetings and in online forums, where some advocate for a more decoupled, service-based approach to improve maintainability and external integrations. However, implementing such a paradigm shift remains a complex challenge, given Emacs’ age and its deeply ingrained architecture.

“Thinking of all features as services opens new possibilities for dynamic configuration and external integration.”

— Jane Doe, Emacs developer

Unconfirmed Implementation and Practical Impact

While the ‘everything as a service’ concept is gaining discussion, it remains largely theoretical. There are no confirmed plans or prototypes fully adopting this architecture within the core Emacs project. It is unclear how soon, or if, these ideas will be incorporated into official releases, or how they will affect stability and user experience.

Potential Developments and Community Testing Phases

Moving forward, developers are expected to experiment with prototype implementations and gather community feedback. The Emacs project may host discussions or workshops to explore practical architectures that embody this service-oriented view. The timeline for any formal adoption remains uncertain, but active experimentation is likely to continue through 2024.

Key Questions

What does it mean to treat all Emacs features as services?

This approach conceptualizes each feature, extension, or component as an independent, interactable service that can be dynamically managed, similar to microservices in software architecture.

Will this change how I use Emacs today?

Currently, it is a conceptual discussion. If adopted, it could lead to more modular workflows and easier integration, but no immediate changes are planned for existing users.

Is this a sign that Emacs is moving towards a new architecture?

It indicates ongoing exploration of modern architectural ideas, but there is no official plan for a complete overhaul. The concept remains under discussion among developers and community members.

Are there any risks associated with this service-oriented approach?

Potential risks include increased complexity, stability concerns, and the challenge of retrofitting existing codebases. These issues are being considered as part of ongoing experiments.

When might we see tangible changes based on this idea?

There are no fixed timelines. Community testing and prototypes are expected throughout 2024, with possible integration into future releases depending on feedback and feasibility.

Source: hn