
Joxa – A Modern Lisp for the Erlang VM - giancarlostoro
http://joxa.org/
======
osense
Interesting - can anyone provide an in-depth comparison to LFE [1]? From a
quick look, it looks like Joxa is more similar to Clojure than it is to Common
Lisp, whereas LFE takes the opposite appoach.

[1] [https://github.com/rvirding/lfe](https://github.com/rvirding/lfe)

~~~
cyberlync
Its mostly about approach. LFE (literally Lisp Flavored Erlang) is Erlang with
an S-expression based syntax. Joxa is a self contained Lisp that happens to
run on the Erlang VM.

Those are the core differences. Joxa also has some very clear and distinct
goals of its own. Those goals are not really relevant to this discussion
though.

~~~
rvirding
Not quite, LFE is a self-contained Lisp system with all the things you would
expect a lisp system to have. It has been designed to run on the Erlang/OTP
system and to efficiently use all the features of that system and its VM. This
means that LFE has a clean interface to Erlang/OTP so it can easily be used
together with applications written in Erlang. Mixing components written in
Erlang and in LFE to write a larger application is straight-forward and
painless.

If I could rename it then a better name would be EFL (Erlang Flavoured Lisp),
which is what it is. The "Flavoured" in the name comes from that I had earlier
implemented a Lisp machines flavors system on another lisp, with an english
spelling thrown in as a joke.

~~~
oubiwann
Oh, wow -- that's a great tidbit! I hadn't heard that before, Robert (one for
the LFE Lore files ...)

------
Mandar
I really like the idea of both Joxa and LFE (a Lisp on the Erlang VM!), but
the main factor keeping me from using them for general purpose programming is
the lack of "modern" collections. I would love to see them implement
persistent data structures à la Clojure, with a unified interface for vectors,
sets, etc. I know the Joxa stance is "make a good macro system and let users
implement these" but as a (new) user, the task looks too intimidating.

The Elixir approach looks great, but it's unfortunately not a Lisp.

~~~
drkrab
Indeed, it would be nice to have an EFL: Elixir Flavoured Lisp. (Lazy) Streams
and clojure'ish protocols (lispy virtual methods) makes a big difference in
abstraction. Erlang as it is, supports ADTs but not object abstraction (i.e.
different kinds of set implementations with different
implementation/representation) See
[http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf](http://www.cs.utexas.edu/~wcook/Drafts/2009/essay.pdf)
for discussion.

------
dj-wonk
> Joxa is a small semantically clean, functional lisp.

What does "semantically clean" mean?

~~~
PuercoPop
I read that to mean that the semantics don't have edge or ad-hoc cases.

~~~
cyberlync
Thats exactly what it means. Its has a very simple syntax that is a nice mix
of the semantics of Core Erlang laid on very straightforward and minimal lisp.
The goal was to build up more semantically complex structures in the language
itself. In effect, Joxa is designed as a platform for language design more
then a language in and of itself. Now I just need to find the time to get back
to it.

~~~
rvirding
If you replace "Joxa" with "LFE" here you would get a good description of LFE.

------
bitteralmond
Is the link in the top-right broken?
[http://i.imgur.com/U08DB9p.png](http://i.imgur.com/U08DB9p.png)

