Skip to content

Instantly share code, notes, and snippets.

@talwrii
Created April 13, 2017 22:52
Show Gist options
  • Save talwrii/dfbd7ab30f5c6a8870867e21ac5eab98 to your computer and use it in GitHub Desktop.
Save talwrii/dfbd7ab30f5c6a8870867e21ac5eab98 to your computer and use it in GitHub Desktop.

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

@_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

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