Skip to content

Instantly share code, notes, and snippets.

Last active April 13, 2017 23:00
What would you like to do?
Notes from emacs meetup at skills matter london April 2017

2017-04-13 Emacs meeting at skills matter


These notes are the noter-taker’s interpretation of the interesting information in the talks.

The order of the material is not maintained, and some content is omitted. These notes were taken quite quickly so their may be factual errors

Additional interpretation of the material has been added and though some of this is marked as such, other interpretations likely are not.

I would like to thank the authors for their talks.

Interesting things

There is (apparently) a London emacs users mailing list

clj-refactor 2017-04-13

Author had quiet complete notes in org mode format

Clojure is yet another lisp

Interpretation: Themes

Some anthropology on open source

Open source in general

The clojure ecosystem in emacs


Lots of writing on slides because they are both notes and a presentation

Companies structure often coincide with open source projects

Emacs clojure ecosystem

clojure mode


Minimal REPL


Supports intelligent code jumping (and more)
RPC model (similar to jedi)



Philosophical content

The value of refactorings

Refactorings define scope of project
Constraints within which to be creative
Interpretation: See Vi Harts 12 tone composition video

Trade offs of open source development

Expert people
Limited interaction: compared to business
Who are your users
What do they care about?
Interpretation: Is this actually different from companies (with the exception of SAAS spying)
Bleeding edge
Some problems are harder in open source land

Good place to learn skills (e.g. git)

Life cycle of a pull request

“Pull requests welcome”
“Pull requests not welcome - risk of regression”
Meta: how to even reason about this
Interpretation: Minimalism / orthogonality neatness concerns in open source land
Is this a unique problem?
Interpretation: Young languages tend to splurge a bit (“here is everything I’ve written in one useful package”)
“guess I get a bit defensive”
Your users don’t necessarily even think that they are users
Supply chain
Demanding users
Function rename caused regression in spacemacs

This is the standard interface issue, but I imagine this is more of an issue in emacs because of the lack of function hiding

Some conversations about testing
Thought: Unit testing would not have caught this, this is between projects
c.f contract testing

Interesting points

How do you correctly reason about “risk of changes causing regression”?

Three levels of language features in emacs

Emacs level
Language aware

Need RPC

AST aware

Non performant

Extensive use of “:” in namespacing

AST parsing performance is an issue

Simpler AST parsers seem to exist in clojure ecosystem

analogous to pylint versus pyflakes



Rpc protocol in clojure



Indirection layer for talking to different schemes (?)

Remacs 2017-04-13

Porting emacs to rust


“Project objectives high-level overview talk”

Lots of people here are from finance-land

This might reflect the location of this talk

Everyone is using emacs for their slides presentations…




Python Tox for emacs (remacs is on evm)

Analogous to neovim

The innards of emacs


The internal emacs lisp interpreter

What is the code?

More than 70% of the code is in lisp
Most of the rest of C
Lots of ported libraries

Standard “here are a bunch of general case libraries in C pattern”

20kloc of Makefile(!)


Memory map of entire emacs image
Breaks malloc
(lol) Was forcing glibc to maintain legacy code for a while
Alternative implementation Idea
Binary representations of different types of things rather than a memory map
Idea generalize caching of state after load

At the moment a memory map of emacs without your packages is created. If this could be generalized then the load times of your packages could be made faster.

Remacs goals

Maintains emacs lisp

Reimplements things in core

Maintain performance

What remacs is not

Hostile fork

Author has commit rights in emacs core

(Aggressive) Redesign

Justification for goals

The code is old (First vcs commit in 1985)

Lots of workarounds

Inconsistent code

Indentation style is different

Interpretation: Force emacs to use github….

Rust has a good kitchen sink that we can use

Exception handing in rust


rust is thread safe

Prior forks

Interpretation: i.e. we aren’t evil

Guile emacs



Interpretation: At what stage does the fork become hostile :)

Either it’s slightly hostile or unused

Interpretation: Does multithreading actually help when you are using emacs lisp?

Internal functions could be parallelized

Interpretation: Concerns

Overly aggressive whitebox testing of rust code risks being an anti-feature


OS X can be used on travis

Similar to neovim

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment