

Clojure-scheme: Compiling Clojure to Native Code via Scheme [video] - takeoutweight
http://www.infoq.com/presentations/clojure-scheme

======
mjt0229
I'm interested in this, but why not just write natively in Scheme? I really
like Clojure, but if you don't need the Java interop, Scheme seems just as
nice.

~~~
slyrus
For one thing, one might get interoperability with clojure libraries (at least
those that aren't just wrappers around java libraries). For another thing,
clojure has some nice language features and I'm all for supporting multiple
lispy dialects on top of various compiler/runtime environments. My personal
wish is to have clojure running on SBCL with trivial interoperability between
common lisp and clojure code.

~~~
DigitalJack
Clojure was initially implemented on cl. You should be able to find the lisp
version in the history of the repo somewhere. Might be an interesting starting
point.

~~~
arohner
I'm pretty sure this is wrong.

Rich originally made two other JVM/lisp hybrids, one was running java code
inside CL, the other was CL on the JVM. [1]

Clojure originally targeted the JVM and CLR, but AFAIK, one of the main
motivators was always to run on a major platform.

[http://sourceforge.net/projects/jfli/](http://sourceforge.net/projects/jfli/)

~~~
lispm
He did not made any Lisp/JVM hybrids. More like foreign object interfaces to
Java and .net.

One was a Lisp(Works) FFI to Java (jfli) and the other was a generalized
version of that (foil).

I have seen too the early sketch of Clojure in CL.

Look here: [http://clojure.googlecode.com/svn-
history/r454/trunk/src/lis...](http://clojure.googlecode.com/svn-
history/r454/trunk/src/lisp/)

~~~
arohner
Right, I didn't mean to imply that jfli and foil were new languages.

I didn't realize there was a CL version of the compiler, cool! Thanks for the
link.

------
terhechte
Also don't forget about Clojure-c, which recently got fairly good iOS /
Android bindings:

[https://github.com/schani/clojurec](https://github.com/schani/clojurec)

------
bitsai
Fascinating! We use Clojure heavily, but the JVM is sometimes a bit of a
headache-inducer in our environment (especially w.r.t. its eager gobbling of
memory), so I'm always excited to see new potential runtimes/backends for
Clojure.

------
jlongster
I love it when several incredible technologies come together to allow things
you wouldn't think possible. Take this thing over there, stir in some of that,
and boom, you've got a working project that is crazy full of potential. Great
work Nathan.

Really, when I think about it, it's why I love the world of programming.

------
dktbs
This is great, especially since it removes the TCO limitation from running on
the JVM. I will definitely give this a try.

~~~
roryokane
I don’t know much Clojure, but I thought that lack of TCO was not a problem
because you can just manually add `recur`
([http://clojure.org/special_forms#Special%20Forms--%28recur%2...](http://clojure.org/special_forms#Special%20Forms--%28recur%20exprs*%29))
when you need it. Are there situations where `recur` doesn’t work but tail-
call optimization would help?

~~~
takeoutweight
In my talk I use a finite state machine as an example of something that can
really benefit from proper tail calls. In this case, the difference between
proper tail calls and loop/recur is the difference between "compiling" the FSM
and running the FSM in an interpreter loop.

------
moomin
Also in this space is Tim Baldridge's mjolnir project, which generates native
code directly from Clojure using LLVM. It looks very promising, although there
haven't been any commits in the last few months.

------
unz
There's also other jvm lisps that you give you natives too. Kawa scheme
(native chicken,bigloo,racket). Armed bear common lisp (native sbcl,clisp).

