5 ms·

LFE: Lisp Flavored Erlang

143 points by whynotwhynot 6y ago

dang 6y ago
If curious see also 2018 https://news.ycombinator.com/item?id=17901451 https://news.ycombinator.com/item?id=17901451 2016 https://news.ycombinator.com/item?id=12157293 https://news.ycombinator.com/item?id=12157293 2015 https://news.ycombinator.com/item?id=8943268 https://news.ycombinator.com/item?id=8943268 https://news.ycombinator.com/threads?id=rvirding https://news.ycombinator.com/threads?id=rvirding
grantjpowell 6y ago
LFE is really cool, but I think the biggest thing that LFE has going against it in terms of mainstream/industry adoption is that Elixir is _roughly_ a Lisp (pretending it's not). LFE is competing against a language that has some _very_ well polished edges, and IMO it doesn't feel like LFE brings to much to the table for industry over the Lisp-y features that Elixir already has[0][1][2][3][4]. What I'd really like to see is a Mix LFE compiler[7] that lets you write LFE modules in a bigger Elixir project[5], plus a set of mix tasks like `mix lfe.repl` that integrates with the other BEAM components of your Mix projects. Long term I think it would be cool if the BEAM community comes together around the excellent tooling (mix, ExUnit, Iex) that the Elixir Team is bringing, I'd love to see other BEAM languages (LFE, Gleam[6]) with top notch integrations that let a mix project include them side by side. I think the BEAM is a really cool piece of technology, and many of these new BEAM languages offer pretty neat advantages, I'm excited to see the interop story grow over time [0] https://elixir-lang.org/getting-started/meta/macros.html https://elixir-lang.org/getting-started/meta/macros.html [1] https://elixir-lang.org/getting-started/comprehensions.html https://elixir-lang.org/getting-started/comprehensions.html [2] https://elixir-lang.org/getting-started/protocols.html https://elixir-lang.org/getting-started/protocols.html [3] https://elixir-lang.org/getting-started/basic-types.html#linked-lists https://elixir-lang.org/getting-started/basic-types.html#lin... [4] https://elixir-lang.org/getting-started/basic-types.html#anonymous-functions https://elixir-lang.org/getting-started/basic-types.html#ano... [5] This exists, but looks unmaintained https://hex.pm/packages/mix_lfe https://hex.pm/packages/mix_lfe [6] https://gleam.run/ https://gleam.run/ [7] https://hexdocs.pm/mix/1.10.2/Mix.Task.Compiler.html https://hexdocs.pm/mix/1.10.2/Mix.Task.Compiler.html
- rkangel 6y ago
  I completely agree. There's a higher abstraction level than the BEAM itself that it should be possible to integrate a new BEAM language at.
- whynotwhynot 6y ago
  I'd like to invite you to the Other Side Of The Force, Grant. http://www.petecorey.com/blog/2017/08/07/what-if-elixir-were-homoiconic/ http://www.petecorey.com/blog/2017/08/07/what-if-elixir-were... It's much more pretty over there. I haven't looked at Elixir but I have read a bit about Supervisors which I think are an excellent idea for fault tolerant systems. However, the phrase "self healing" is thrown around a lot in talks about Elixir, as if it's a magical feature of the language, without much explanation as to what it means to universally heal from faults (I think maybe they mean self healing strategies that the programmer authors and implements, not some AGI that rewrites the code on the fly to fix it, lol, but that's my gripe, mostly the hype around that... and "coding for the happy path" which is not really a rigorous statement either... maybe someone can tell me what is the happy path for an algorithm in my head without knowing the algorithm, because that somebody is me, and I don't really know my algorithms until I have thought through the not-so-happy path... I mostly code to explore what I need to specify rather than describe some specification I already have.) Maybe Elixir is not for me. Or maybe it is. I need to learn more, and go past the hype. For me, Lisp is an alien technology with great power that will never be matched, except by another Lisp. So it was great to find out about LFE! I even appreciate the separate var/fn namespaces, like nouns and verbs in natural language, e.g. fight the good fight, and I can see how it comes in handy, yet it's a new PL concept for me, so I'm still processing it.
  - 67868018 6y ago
    > coding for the happy path It's not that complicated. A relatable example would be writing an API endpoint that receives data and then you do something with that data. 1. Write the endpoint so it works for the expected data. 2. You're done That's it. You don't need to worry about anyone sending you malformed payloads or fuzzing your API. You can ignore it. They cannot exploit anything, they cannot crash BEAM. It will keep working. Maybe they'll run you out of memory or CPU or bandwidth, but those are problems solved at other layers (unless you include rate limiting in your application). Ignore all errors you do not need to explicitly handle. That's the whole point. It's wonderful. Maybe you can do this in other languages with worker pools and supervisors, but it will be very expensive and high latency due to the cost of OS process forking and you're also wasting a lot of resource on context switches with that design anyway.
hackingthenews 6y ago
Can someone direct me to some code where I can see the full potential of Lisp? I have programmed in Scheme before while taking a course using SICP. Final project was a Scheme interpreter. But I didn't have any epiphany/awakening like many others seems to have.
- capableweb 6y ago
  I think you will have to program with it to get it. It's not so much about a final, static copy of code that you can look at and be amazed, but more about how fluid and well oiled the journey there was. Try to build something with Clojure (bit easier to get started with than LFE, Common Lisp or others, except maybe Racket) and try to focus on a REPL heavy flow (with integration with your favorite editor) to see the full potential of Lisp.
- phoe-krk 6y ago
  > Can someone direct me to some code where I can see the full potential of Lisp? There's exists no code that shows the full potential of Lisp because its potential lies not in the code itself, but in the way of working with it. The language is interactive and image-based, meaning that you do not program in it by passing code through a compiler into executables, but instead you modify the running Lisp image until it contains the program you want. This is usually done by connecting the editor to the running Lisp image and sending commands to it: usually that is to compile-and-load (or compile-and-replace) individual forms/functions/variables, or whole files, or whole systems, or to work with the read-eval-print loop, or to interactively inspect objects, or to interactively resolve signaled errors via the debugger. This provides a lot of introspection into how the Lisp image and the program contained within works, and drastically reduces the feedback loop since the overhead of compiling-and-loading individual functions or even whole files is unnoticeable. Disclosure: I am a Common Lisp programmer.
  - smabie 6y ago
    Yeah but none of what you said applies to Scheme.
capableweb 6y ago
Also related is clojerl which is Clojure running on Erlang VM: https://github.com/clojerl/clojerl https://github.com/clojerl/clojerl (http://clojerl.org/ http://clojerl.org/) Some past submissions of clojerl: - https://news.ycombinator.com/item?id=21965469 https://news.ycombinator.com/item?id=21965469 - https://news.ycombinator.com/item?id=20219563 https://news.ycombinator.com/item?id=20219563
macintux 6y ago
There are quite a few languages targeting the BEAM by now, with LFE one of the oldest. I've been trying to keep track of them all: https://gist.github.com/macintux/6349828#alternative-languages-targeting-the-erlang-vm https://gist.github.com/macintux/6349828#alternative-languag... Gleam is one of the more interesting recent additions: - https://gleam.run https://gleam.run - https://news.ycombinator.com/item?id=22902462 https://news.ycombinator.com/item?id=22902462
badhabit 6y ago
no openbsd port for lfe yet?
elongatedMusku 6y ago
Hey guys, I've done SICP in the past and I like scheme a lot. I've since then moved to Haskell. How do I get a functional programming job (say lfe)? A lot of the job listings ask for experience of 2 years. Any suggestions on where I should look would be really helpful.
tarkin2 6y ago
Despite this being obvious hn catnip, I’m interested. I loved the little and seasoned schemer books, yet found both racket and CL somehow divergent and unappealing. Does anyone here use it? I can’t find if it deals with continuations well. I’ve never used many languages that allow eloquent use.

143 points by whynotwhynot 6y ago

dang 6y ago

If curious see also 2018 https://news.ycombinator.com/item?id=17901451 https://news.ycombinator.com/item?id=17901451 2016 https://news.ycombinator.com/item?id=12157293 https://news.ycombinator.com/item?id=12157293 2015 https://news.ycombinator.com/item?id=8943268 https://news.ycombinator.com/item?id=8943268 https://news.ycombinator.com/threads?id=rvirding https://news.ycombinator.com/threads?id=rvirding

grantjpowell 6y ago

LFE is really cool, but I think the biggest thing that LFE has going against it in terms of mainstream/industry adoption is that Elixir is _roughly_ a Lisp (pretending it's not). LFE is competing against a language that has some _very_ well polished edges, and IMO it doesn't feel like LFE brings to much to the table for industry over the Lisp-y features that Elixir already has[0][1][2][3][4]. What I'd really like to see is a Mix LFE compiler[7] that lets you write LFE modules in a bigger Elixir project[5], plus a set of mix tasks like `mix lfe.repl` that integrates with the other BEAM components of your Mix projects. Long term I think it would be cool if the BEAM community comes together around the excellent tooling (mix, ExUnit, Iex) that the Elixir Team is bringing, I'd love to see other BEAM languages (LFE, Gleam[6]) with top notch integrations that let a mix project include them side by side. I think the BEAM is a really cool piece of technology, and many of these new BEAM languages offer pretty neat advantages, I'm excited to see the interop story grow over time [0] https://elixir-lang.org/getting-started/meta/macros.html https://elixir-lang.org/getting-started/meta/macros.html [1] https://elixir-lang.org/getting-started/comprehensions.html https://elixir-lang.org/getting-started/comprehensions.html [2] https://elixir-lang.org/getting-started/protocols.html https://elixir-lang.org/getting-started/protocols.html [3] https://elixir-lang.org/getting-started/basic-types.html#linked-lists https://elixir-lang.org/getting-started/basic-types.html#lin... [4] https://elixir-lang.org/getting-started/basic-types.html#anonymous-functions https://elixir-lang.org/getting-started/basic-types.html#ano... [5] This exists, but looks unmaintained https://hex.pm/packages/mix_lfe https://hex.pm/packages/mix_lfe [6] https://gleam.run/ https://gleam.run/ [7] https://hexdocs.pm/mix/1.10.2/Mix.Task.Compiler.html https://hexdocs.pm/mix/1.10.2/Mix.Task.Compiler.html

rkangel 6y ago
I completely agree. There's a higher abstraction level than the BEAM itself that it should be possible to integrate a new BEAM language at.
whynotwhynot 6y ago
I'd like to invite you to the Other Side Of The Force, Grant. http://www.petecorey.com/blog/2017/08/07/what-if-elixir-were-homoiconic/ http://www.petecorey.com/blog/2017/08/07/what-if-elixir-were... It's much more pretty over there. I haven't looked at Elixir but I have read a bit about Supervisors which I think are an excellent idea for fault tolerant systems. However, the phrase "self healing" is thrown around a lot in talks about Elixir, as if it's a magical feature of the language, without much explanation as to what it means to universally heal from faults (I think maybe they mean self healing strategies that the programmer authors and implements, not some AGI that rewrites the code on the fly to fix it, lol, but that's my gripe, mostly the hype around that... and "coding for the happy path" which is not really a rigorous statement either... maybe someone can tell me what is the happy path for an algorithm in my head without knowing the algorithm, because that somebody is me, and I don't really know my algorithms until I have thought through the not-so-happy path... I mostly code to explore what I need to specify rather than describe some specification I already have.) Maybe Elixir is not for me. Or maybe it is. I need to learn more, and go past the hype. For me, Lisp is an alien technology with great power that will never be matched, except by another Lisp. So it was great to find out about LFE! I even appreciate the separate var/fn namespaces, like nouns and verbs in natural language, e.g. fight the good fight, and I can see how it comes in handy, yet it's a new PL concept for me, so I'm still processing it.
- 67868018 6y ago
  > coding for the happy path It's not that complicated. A relatable example would be writing an API endpoint that receives data and then you do something with that data. 1. Write the endpoint so it works for the expected data. 2. You're done That's it. You don't need to worry about anyone sending you malformed payloads or fuzzing your API. You can ignore it. They cannot exploit anything, they cannot crash BEAM. It will keep working. Maybe they'll run you out of memory or CPU or bandwidth, but those are problems solved at other layers (unless you include rate limiting in your application). Ignore all errors you do not need to explicitly handle. That's the whole point. It's wonderful. Maybe you can do this in other languages with worker pools and supervisors, but it will be very expensive and high latency due to the cost of OS process forking and you're also wasting a lot of resource on context switches with that design anyway.

hackingthenews 6y ago

Can someone direct me to some code where I can see the full potential of Lisp? I have programmed in Scheme before while taking a course using SICP. Final project was a Scheme interpreter. But I didn't have any epiphany/awakening like many others seems to have.

capableweb 6y ago
I think you will have to program with it to get it. It's not so much about a final, static copy of code that you can look at and be amazed, but more about how fluid and well oiled the journey there was. Try to build something with Clojure (bit easier to get started with than LFE, Common Lisp or others, except maybe Racket) and try to focus on a REPL heavy flow (with integration with your favorite editor) to see the full potential of Lisp.
phoe-krk 6y ago
> Can someone direct me to some code where I can see the full potential of Lisp? There's exists no code that shows the full potential of Lisp because its potential lies not in the code itself, but in the way of working with it. The language is interactive and image-based, meaning that you do not program in it by passing code through a compiler into executables, but instead you modify the running Lisp image until it contains the program you want. This is usually done by connecting the editor to the running Lisp image and sending commands to it: usually that is to compile-and-load (or compile-and-replace) individual forms/functions/variables, or whole files, or whole systems, or to work with the read-eval-print loop, or to interactively inspect objects, or to interactively resolve signaled errors via the debugger. This provides a lot of introspection into how the Lisp image and the program contained within works, and drastically reduces the feedback loop since the overhead of compiling-and-loading individual functions or even whole files is unnoticeable. Disclosure: I am a Common Lisp programmer.
- smabie 6y ago
  Yeah but none of what you said applies to Scheme.

capableweb 6y ago

Also related is clojerl which is Clojure running on Erlang VM: https://github.com/clojerl/clojerl https://github.com/clojerl/clojerl (http://clojerl.org/ http://clojerl.org/) Some past submissions of clojerl: - https://news.ycombinator.com/item?id=21965469 https://news.ycombinator.com/item?id=21965469 - https://news.ycombinator.com/item?id=20219563 https://news.ycombinator.com/item?id=20219563

macintux 6y ago

There are quite a few languages targeting the BEAM by now, with LFE one of the oldest. I've been trying to keep track of them all: https://gist.github.com/macintux/6349828#alternative-languages-targeting-the-erlang-vm https://gist.github.com/macintux/6349828#alternative-languag... Gleam is one of the more interesting recent additions: - https://gleam.run https://gleam.run - https://news.ycombinator.com/item?id=22902462 https://news.ycombinator.com/item?id=22902462

badhabit 6y ago

no openbsd port for lfe yet?

elongatedMusku 6y ago

Hey guys, I've done SICP in the past and I like scheme a lot. I've since then moved to Haskell. How do I get a functional programming job (say lfe)? A lot of the job listings ask for experience of 2 years. Any suggestions on where I should look would be really helpful.

tarkin2 6y ago

Despite this being obvious hn catnip, I’m interested. I loved the little and seasoned schemer books, yet found both racket and CL somehow divergent and unappealing. Does anyone here use it? I can’t find if it deals with continuations well. I’ve never used many languages that allow eloquent use.