notes.org

2017-04-13 Emacs meeting at skills matter

DISCLAIMER

These notes are the noter-takers interpretations of the interesting information in the talks.

The order of the material is not maintained, and some content is omitted.

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

Rewrites

Open source in general

The clojure ecosystem in emacs

Trivia

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

inf-clojure

Minimal REPL

cider

Supports intelligent code jumping (and more)

RPC model (similar to jedi)

“Meeko”

flycheck-clojure

Linting

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

Links

Meeko

Rpc protocol in clojure

Slime

Gazer

Indirection layer for talking to different schemes (?)

Remacs 2017-04-13

Porting emacs to rust

Trivia

“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…

Links

www.wilfred.me.uk

@_wilfredh

EVM

Python Tox for emacs (remacs is on evm)

Analogous to neovim

The innards of emacs

TEMACS

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(!)

Unexec

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

Ideo 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

Multithreading

rust is thread safe

Prior forks

Interpretation: i.e. we aren’t evil

Guile emacs

XEmacs

Questions

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

Interesting

OS X can be used on travis

Similar to neovim