Cool things you’ve seen in other languages/frameworks

[AstonJ]

Inspired by a thread on the Elixir Forum about something in a framework in a non-BEAM language, have you seen any impressive or cool things in other non-BEAM languages or frameworks? If so please share!

When taking part please note…

• This is not a “I’d like to see X in Erlang" type thread.
• It is not even a thread about things that may or may not be a good fit for functional programming.
• It is just a thread to share cool things you’ve seen in other languages or frameworks

Why?

Who knows, it might spark someone’s imagination to do something cool in Erlang themselves

_{Please do not use this thread to criticise other languages or frameworks - let’s keep it focused on the positives.}

[gorenje]

I’ve done this the other way around: things that should be transported back to Javascript: all the Erlang behaviours!

Having added most of the behaviours to Erlang-Red - in node form, it would be cool if they were transported back to Node-RED. It’s difficult because of the complete different NodeJS architecture but it did get me thinking.

Perhaps something that I did find nice was the Streaming API over at NodeJS. Once one gets the hang of it, it does make for good performance when handling large datasets.

[rlipscombe]

• Dart+Flutter: save your layout code, instantly see the changes in the app on the emulator/device.

[nato]

Plan9’s rc(1) is a bit of a marvel. From that original Tom Duff whitepaper:

Rc [makes] the backquote a unary operator whose argument is a command, like this:

size = `{wc -l `{ls -t | sed 1q}}

No escapes are ever required, and the whole thing is parsed in one pass.

This is contrast to things like Bourne shell, where nesting requires escaping the nested inner backquotes, and the more nesting, the more escapes you need.

Also, really like the idea of local variables, so they don’t leak out after use. You do this by just prepending your expressions with the variable(s) you want to discard after that expression has been run:

f = '' {
  f = some_file
  spell $f > typos.todo  
}

[nzok]

This may be on the very edge of relevance, but the ddd debugger, specifically the graphical
display of data.

[dischoen]

From the lower end of the spectrum:
I like the stack and the builtin compiler of FORTH.

[carlotm]

go’s statically linked executables, maybe

[mmin]

OCaml’s application interface definition and namespace of max depth 2 (application:module:fun(Args) or application:fun(Args))

[fancycade]

I like clojure’s clj tool and how they setup the design for deps.edn. A big improvement over the previous build tools like leiningen and boot. A big plus that it’s all one cli tool.

link

[vkatsuba]

One neat idea I’ve seen outside the BEAM world is Livebook in Elixir’s broader ecosystem, which is inspired by Jupyter notebooks (from Python). The core idea of combining documentation, executable code, and visual output in a single notebook-style UI is incredibly powerful for experimentation and education. It’s not strictly BEAM-originated, but it blends functional programming with interactivity in a way that’s rare.

Another cool feature I admire is from Rust’s cargo ecosystem:
The seamless integration of formatting, linting, testing, building, and dependency management in one tool (cargo fmt, cargo clippy, cargo test, etc.) makes the developer experience feel very “tight” and low-friction.

Also worth mentioning:
Gleam (a BEAM language, but inspired by Elm/Rust) has very user-friendly compile-time error messages - clearly formatted, colorized, and often include suggested fixes. That’s something I’ve always appreciated in Elm as well.

From Go:
The simplicity of go install and the way Go binaries are statically linked and trivially deployable (just one binary) - even if not suitable for Erlang-style systems, it’s conceptually appealing how self-contained everything is.

From TypeScript world (specifically Next.js):
I find the concept of file-based routing very elegant for simple cases - just drop a file into a folder and it’s automatically available as a route. Again, not something Erlang would necessarily want, but the discoverability and low setup cost is attractive.

[MGreim]

FORTH on the BEAM !!!