Here's your regular reminder that #LFE is a very cool #Lisp (and a very cool #Erlang).
https://github.com/lfe/lfe

Underack: A Eurorack-inspired, modular, MIDI generation and manipulation system, written by @oubiwann in Lisp Flavoured Erlang (@lfe). https://github.com/ut-proj/underack
#LFE #Erlang

“they run on the BEAM, which also runs code written in #LFE (#Lisp Flavored Erlang)”

@jotaemei yeah, Erlang is a pretty good language. I have learned a little bit about it, although I don’t know enough about the OTP to really write any apps with it.

@ramin_hal9001 I have been a little interested in these ActivityHub-inplementing platforms written in Elixir, as they run on the BEAM, which also runs code written in #LFE (#Lisp Flavored Erlang).

Here's all the BEAM language tracks on Exercism:

#LFE: https://exercism.org/tracks/LFE
#Erlang: https://exercism.org/tracks/erlang
#Elixir: https://exercism.org/tracks/elixir
#Gleam: https://exercism.org/tracks/gleam
[Disclaimer: I never did any of those but they look like fun if you plan to learn a new language]

@passthesaltcon @quarkslab @unixb0y @seemoo @virtualabs for those wondering it's BEAM as in #elixir #gleam #lfe #erlang

I always wondered how to do forensics on these things. Once on a node one can deploy modules on other nodes. (and the attacked node can deploy code on the attacker node as well ;)
```
$erl -setcookie secret -name password
% compile the module
c(ourmodule).
% connect to remote node
net_kernel:connect_node('remote@node.lxd').
nodes().
% copy ourmodule on all connected nodes
nl(ourmodule).
% profit
```
The attacker can even pivot from within BEAM via ssh.

@arpunk heh, yes, long live "la LFE". #LFE cc @lfe

«Structs for #Erlang». Btw, Robert also has added Elixir structs support to #LFE.
https://www.youtube.com/watch?v=3m1JSq75C3g

Oh, #AtomVM can load #LFE?

AtomVM v0.6.0 is finally out: https://github.com/atomvm/AtomVM/releases/tag/v0.6.0

For who does't know it: #AtomVM allows to run #erlang, #elixir, #gleam and also #lfe on MCUs such as the #ESP32, the #RaspberryPi Pico (2040) and some #STM32, but it also supports Linux and wasm.

#CarlSagan’s audacious search for #Lfe on #Earth has lessons for science today : Nature

The True #Nature of #AntiGravity : Medium

A 2×2 #Matrix to Help You #Prioritize the #Skills to Learn Right Now : HBR

Check our latest #KnowledgeLinks

https://knowledgezone.co.in/resources/bookmarks

#Lem needs an #LFE mode too.

The new #LFE site looks great! With a cornucopia of learning and reference material.
https://lfe.io/
#Erlang #Lisp

@mousebot Time to use pattern matching in #lfe :)

What a gem from @oubiwann in the LFE channel:

Macros are like Bebop.
Quoting Pat Metheny:
"What I look for in a musician is someone who has studied Bebop and can perform every note in any of the classic solos from that era, but never wants to play it again."

Learn and study macros. (Almost) never use them.

Metheny also said:
"What I look for in musicians is a sense of infinity".

So.... write macros that write macros? :)
#Lisp #LFE

The "Forward" to the #LFE Chinenual is now done too, again from the unpublished book "Introducing LFE": https://cnbbooks.github.io/lfe-manual/preface/forward.html

This should really be titled "what is a correct 'Hello World' program in a distributed language?" 😉

#erlang

Just added content to the #LFE "Chinenual" for the "About" section in Part I: https://cnbbooks.github.io/lfe-manual/part1/intro/about.html

Highlights include:
* What is LFE?
* (an extremely) Brief History of #Lisp
* Ditto for #Erlang
* What is LFE?

Code samples include not only LFE and Erlang, but also an M-expression, a Lisp 1.5 example, and a pre-Erlang #Parlog example :-)

Content is from an LFE book I was working on in 2015 that I eventually had to abandon. So happy it will be available now 😄

The one thing #LFE (Lisp flavoured Erlang) doesn't have is CLOS (the Common Lisp Object System). Of course not, since #LFE is not a Common Lisp. But it makes it harder to translate CL code to LFE.
Robert Virding has implemented a Lisp machine Flavours system for LFE, though :)
https://github.com/rvirding/flavors

Don't get me wrong, Bordeaux Threads and all that stuff are cool.
But don't forget to take a look at the BEAM and its #Lisp flavour (#LFE) as well. I'd certainly be interested in your opinion on it.
https://lispcookbook.github.io/cl-cookbook/process.html

What's so great about #LFE (Lisp Flavoured Erlang) is its compiled code is fully compatible with Erlang (and Elixir).
You could add LFE as a dependency to any Erlang project and continue to develop it in Lisp. (to make a point).

But why not just use #Erlang syntax, then? That's the wrong question: consider it an *offer* to developers more productive in a Lisp. And an *offer* to projects/problems that resemble Lisp-like systems but still need concurrency.
And macros.