Lisp Flavoured Erlang 1.0 released after 8 years of development

[eggy]

Great news! I wanted to learn BEAM/OTP, but had tried Erlang briefly years ago, and then went back to Common Lisp. Now I can try to learn BEAM/OTP in a syntax that is more appealing to me than Elixir's Ruby-like syntax. I like Elixir, and it is very popular, but true runtime macros are available in LFE 1.0. In addition, Robert Virding was one of the co-creators of Erlang, so his devotion to bringing the best Lisp he could to the BEAM platform within its confines, comes with some authority. The Google Group Lisp Flavoured Erlang is a very responsive community and resource for getting started. Congratulations LFE on your v1.0! OT, but I also use Extempore - the music, graphics livecoding environment with a great language, xtlang that I believe was based upon S7 scheme and has an LLVM backend [1]. There are some s-expression to WebAssembly projects floating around too. All around good news for all the choices to work with up front no matter your preferences.

   [1]  http://extempore.moso.com.au/

[sjtgraham]

Elixir is really not similar to Ruby and the comparison wears thin. This is my opinion after having used Elixir daily for the last 1.5 years and Ruby for 10 years before that.

Elixir really is a brilliant language and José et al have made the developer experience second to none with hex, mix, the language guide and docs. Compare how you bring up a repl: Elixir, type iex; LFE, cd into LFE dir, type ./bin/lfe. (EDIT: this is incorrect, see child) Trivial example and something easily fixed if it bothers you, but it's emblematic of the attention to detail that has gone into devx. I am deeply in love with Elixir. That Robert co-authored Erlang should not mean giving Elixir any less consideration IMO.

That said I sincerely wish to congratulate Robert on this 1.0, I look forward to using LFE in anger for something very soon now it is 1.0 (and it will be easy to slip in an LFE module into one of my OTP apps). Exciting times for the Erlang ecosystem.

[pmarreck]

I think the JVM can use some good competition and BEAM is ideally geared towards the next generation of immutable/functional/concurrent languages

[vvanders]

WRT to macros how does LFE differ from Elixir? My understanding was that Elixir macros were incredibly powerful(hence most of the language constructs being built in them).

[vdaniuk]

Robert Virding has just announced the release on twitter https://twitter.com/rvirding/status/710259707819249664

I feel that this LFE release further validates BEAM as a promising platform for future development of new programming languages. Also I look forward to reading SICP converted to LFE. Available chapters can be found here https://www.gitbook.com/book/lfe/sicp

[emmanueloga_]

Given you mentioned SICP... SICP is cool for its math and its puzzle-like problems, but I found http://scheme.com/tspl4/ a much better introduction to Scheme and more likely to help me solve problems with Scheme in the real world (i.e. a good reference book).

[akavel]

I've stumbled into an interesting related comment on twitter, didn't know:

"#Erlang based language ecosystem is more diverse than many know: #efene #reia #lfe #luaerl #erlog #elixir #mercury"

https://twitter.com/BillBarnhill/status/670601359016771584

edit: Wow, and many of them seem to actually be by the same rvirding who authored lfe:

https://github.com/rvirding/luerl

https://github.com/rvirding/erlog

[vvanders]

Shame about luerl not supporting __metatable properly. That's half of why Lua is awesome.

Still a massive achievement, awesome stuff.

[i_feel_great]

http://the-concurrent-schemer.github.io/scm-doc/

[eric_bullington]

rvirding was also one of the creators of Erlang itself at Ericsson.

[rvirding]

I do want to point out that LFE has been release ready and of production quality for a long time but I tend to suffer from a "Jag ska bara"* syndrome which has delayed things. :-)

* I am just going to ...

[piokuc]

Thank you so much for this wonderful stuff!

[Kuytu]

Robert Virding gave a short talk on LFE at ClojuTRE last year: https://www.youtube.com/watch?v=BvCBTpnlqs8

[jb1991]

Virding's YouTube presentation at a Clojure conference about this new lisp says this in the caption:

>LFE (Lisp Flavoured Erlang) has been designed to run efficiently on the Erlang VM and at the same time be a "real lisp" providing Lisp's good bits.

It also knocks Clojure a bit. What do you all think are the "good bits" of lisp that Clojure lacks?

[ska]

   What do you all think are the "good bits" of lisp that Clojure lacks?

Compared to common lisp off the top of my head (correct me if I am misrepresenting Clojure from memory): condition system, multiple return values and &key, CLOS with all that entails, and I seem to remember that clojure had some fiddly issues with macros and reader macros.

Not intended as a knock on Clojure, btw, but the JVM is somewhat limiting, in the same way you can't do a "proper" common lisp on the CLR.

[kaeluka]

FWIW, reading this sentence w/o any extra context, it doesn't seem to imply anything bad about clojure.

[eggy]

Readable stack traces. Unfortunately, the JVM is the culprit here. I like Clojure's syntax, and some other bits, but if I were to chose a Lisp that runs under another system like Clojure, I'd choose Shen [1].

   [1]  http://shenlanguage.org/

[yurrriq]

Tail recursion optimization, for one. Clojure makes up for it with recur though, so in practice, it's not that big of a deal.

[jarpineh]

This looks really interesting. I installed it easily through Brew. REPL seems to work fast.

Now if my Clojure flawored Lisp starter level knowledge could be somehow transformed into Erlang flawor...

I wrote this:

    > (map (lists:seq 1 10) (lambda (a) (io:format a)))

and this happened:

    #M((1 2 3 4 5 6 7 8 9 10) #Fun<lfe_eval.12.88887576>)

So, I'm not quite there yet. Hopefully somebody can make a Clojure to LFE comparison.

And using Elixir based things like Phoenix springs to mind...

[strmpnk]

Map is a constructor in this case. You'll want lists:map/2 (fn comes first). I don't know LFE much so there may be sugar of sorts for this, perhaps a comprehension syntax.

[namelezz]

> A proper Lisp-2, based on the features and limitations of the Erlang VM

What are limitations?

[jsnell]

One obvious example is that AFAIK the VM doesn't support functions with a variable number of arguments (foo/1 and foo/2 are two separate functions). This means that you can't have CL-style &rest or &key arguments.

[rvirding]

Some limitations (?): are no global data; no shared data; all data is immutable; the modules are different from CL packages; functions can't have variable number of arguments[]. It does however have support for decent pattern matching and full access to all of Erlang's concurrency, fault-tolerance and scalability properties. Plus real macros as god intended.

[] The macro handling can go part way to hide this.

[aidenn0]

The users manual has a stub section for macros; does anybody know how LFE macros work? It says "lisp style" but that allows at least 4 options (syntax pattern-matching versus classic defmacro, and capturing versus non-capturing).

[aweinstock]

There's some more in-depth documentation in the repo in doc/user_guide.txt, at around line 520-ish.

It has Common Lisp style defmacro (augmented with pattern matching), and Scheme-inspired defsyntax. The documentation warns that both are unhygienic, and `grep -ri gensym` didn't find anything in the repo.

[clw8]

My exposure to the Erlang world is limited to having read the first few chapters of Programming Elixir. Is interop trivial? Can you easily use Erlang, Elixir, and LFE in the same project?

[lpil]

Yes, compiling a module where the source was written in another language is no different from calling a module written in the same one. In Elixir any time you call a module that starts with a `:` it has most likely been written in Erlang.

[im_down_w_otp]

The docs are sadly very incomplete still. :-(

How do I go about sponsoring a technical writer to complete them?

[philjackson]

I'd love to see a comparison with Clojure, anyone know of such a thing yet?

[oubiwann]

It's a work in progress, but this might be useful:

* http://lfex.github.io/hyperpolyglot/

[StreamBright]

You can answer this from many angle:

- Clojure vs LFE

- JVM vs BEAM

- Lisp-1 vs Lisp-2

Etc, if you are interested only in the syntax differences, there is not much difference there (there are obviously some though!). I think generally speaking Erlang has fewer libraries than Java so that is a big difference in my opinion.

[alberth]

Slightly off topic: does anyone have an update on BEAM JIT?

[andrewvijay]

Just waiting for the day when someone launches a js version then the whole world is gonna be coding on erlang vm I think.

[sjtgraham]

I doubt it. IMO Erlang is fundamentally a different model of programming than JS and what about mutability and things such as pattern matching? It quickly becomes apparent that it would not be much like JS if it was to take advantage of all of Erlang's best bits.

[rvirding]

There have been "hints" that why don't I implement JS on top of erlang as well. Would love to try, and some of the problems have been solved in my luerl implementation, but the main problem is time, the lack of it.

[diskcat]

Could you believe that 2016 is the year of the beginning of the LISP renaissance.

Im going to buy some spare paren keys, they might become scarce in the immediate future.

[macmac]

It started in 2007 with the release of Clojure and there are still plenty of paren keys around.

[dang]

Please keep programming language flamewars off HN.

[phamilton]

Nope. Elixir was created because of the gap in functionality in Erlang, specifically around documentation and tooling as well as the lack of macros and polymorphism. [0]

The fact that it looks Rubyish at times is just the creator's aesthetic preference, but it wasn't the motivator.

[0] http://www.sitepoint.com/an-interview-with-elixir-creator-jo...

[pmarreck]

> It's like their brains would shatter into a brillion pieces if they ever had to think about tail recursion.

Come on, man. Your anti-Rubyist bias is showing way too clearly. I switched to Elixir from Ruby (or rather, am still trying to move all my project work over), and I grokked tail recursion just fine.

> LFE is a nice project that grows as people use it without trying to form an army/cult around it like so many other languages do these days

No product (language or otherwise; trying to include Apple, here) ever "tried to form a cult around itself." That is just a natural happening when a new thing is really really cool. So discounting something because of its popularity is sort of an "argumentum ad populum" fallacy in reverse (arguing for OR against something because of its popularity).