hraberg

http://typedrummer.com/1m4q5x

I started a project to port Emacs (the C parts) manually to Clojure, with the Emacs Lisp automatically transpiled into Clojure in 2012, most of the work was done in early 2013: https://github.com/hraberg/deuce

It can boot Emacs on the JVM and take simple commands, but not much more. It's my intention to eventually revisit this project, but not sure when.

I have a feeling Markus is referring to typing in machine code (in a totally opaque way) using DATA statements combined with a small loader written in Basic.[1] Here's an article discussing this approach.[2] This was very common in the computer magazines during the 80s. You learn a lot about patience and attention to detail, if nothing else. There were attempts to mitigate this..[3]

[1] http://en.wikipedia.org/wiki/Type-in_program

[2] http://www.atariarchives.org/mlb/introduction.php

[3] http://arstechnica.com/business/2012/08/experiments-in-airbo...

Thanks!

I actually had a quick look at this, and Kickstarter funding is for US residents only. Indiegogo seems like an alternative (guess there are a lot of opinions on what crowd funding platform to use).

Also, I'm not sure what "rewards" I could give, "listed as a contributor, in a file hidden deep in my git repo"?

Anyway, more code first, then maybe revisit this!

The Emacs Lisp emulator is necessary, otherwise it won't be Emacs. This part will work similar to how shen.clj[1] works. This is itself an interesting project, but as people have said, "why?"

Because new extensions can then be written in Clojure (or other JVM languages) against the same core API (with shared concepts like "buffer" and "window").

Now the line of what's core and what's extension can be blurred, and while keeping backwards compatibility, one can evolve the entire architecture in Clojure, free from the constraints of the old Emacs code base.

But, easier said than done!

[1] https://github.com/hraberg/shen.clj

Author here. Thanks for the support everyone! Seems like there is an interest in such a thing, so I'll better start hacking on this again.

There are two parts to this. First, pure learning and fun - even if it goes nowhere. Second, "Extensible" is the keyword here. The goal is to find the right balance between backwards compatibility (Emacs Lisp) and forward extensibility (Clojure / JVM), so I'm not interested in writing a new text editor from scratch.

I did consider Kickstarter (currently self funded), but felt I needed something running first.

With Enumerable.java you can use Guava like this (+ static imports):

    List<String> strings = transform(list("hello", "world"), 
        function(s, s.toUpperCase()));
    assertEquals(list("HELLO", "WORLD"), strings);

Enumerable.java (http://enumerable.org) is not really a functional library, but it does support limited closures:

boolean b = a.any(λ(s, s.equals(s.toLowerCase()));

s and λ are statically imported.

If you're still interested in closures for Java, my port of Ruby's Enumerable module, Enumerable.java, has a limited version for valid Java 5. The current release is 0.2.4, but this post is the best introduction: http://www.jroller.com/ghettoJedi/entry/closures_in_valid_ja...