Erlang/OTP 27 Highlights | Hacker News Reader

Erlang/OTP 27 Highlights

erlang.org

220 pointsasabil49 comments

Reading about Erlang always feels like getting messages from an alternate dimension where we as an industry made much better choices in the 90s about how we write distributed software.

this. Erlang's concurrency support is one of those things you can't unsee. Going back to sequential-by-design languages (which is pretty much every other industrial quality language bar go[1]) just feels cumbersome:

C/C++/C#/Python/...: "You want concurrency? Sure. We have OS processes, and threads, and this cool new async doohickey. Pick whatever you fancy! Oh, but by the way: you can't use very many processes cos they're _really_ heavyweight. You can have lots more threads, but not too many, and beware corrupting the shared state. Asyc though, you can have _loads_ of things going on at once. Just, y'know, don't mix the colours up".

With Erlang/Elixir it's just:

"You want concurrency? Sure, here's Erlang processes. You can have millions of them. Oh, you need to communicate between them? Yep, no probs, messages and mailboxes. What's that? Error handling? Yep, got that covered too - meet the Supervisors"

[1] Counting Elixir as "Erlang" in this context given it also sits on the BEAM VM.

C# tasks are lightweight, and I'd expect for per-task overhead to be significantly lower than that of Erlang's.

e.g.:

    var delay = Task.Delay(3_000);
    var tasks = Enumerable
        .Repeat(async () => await delay, 1_000_000)
        .Select(f => f());

    Console.WriteLine("Waiting for 1M tasks...");
    await Task.WhenAll(tasks);
    Console.WriteLine("Finished!");

edit: consider suggesting a comparable example in Erlang before downvoting :)

Do they have isolated heaps and can they be preempted, even if they spin in an infinite loop doing some CPU intensive things?

Tasks are not processes, and that would be a wrong thing to do, and so would be "isolated heaps" given performance requirements faced by .NET - you do want to share memory through concurrent data structures (which e.g. channels are despite what go apologists say), and easily await them when you want to.

CSP, while is nice on paper, has the same issues as e.g. partitioning in Kafka, just at a much lower level where it becomes critical bottleneck - you can't trivially "fork" and "join" the flows of execution, which well-implemented async model enables.

It's not "what about x" but rather how you end up applying the concurrent model in practice, and C# tasks allow you to idiomatically mix in concurrency and/or parallelism in otherwise regular code (as you can see in the example).

I'm just clarifying on the parent comment that concurrency in .NET is not like in Java/C++/Python (even if the latter does share similarities, there are constraints of Python itself).

> and that would be a wrong thing to do, and so would be "isolated heaps" - you do want to share memory through concurrent data structures (which e.g. channels are despite what go apologists say), and easily await them when you want to.

It depends on the context. In some contexts absolutely not. If we share memory, and these tasks start modifying global data or taking locks and then crash, can those tasks be safely restarted, can we reason about the state of the whole node any longer?

> CSP, while is nice on paper

Not sure if Erlang's module is CSP or Actor's (it started as neither actually) but it's not just nice on paper. We have nodes with millions of concurrent processes running comfortably, I know they can crash or I can restart various subsets of them safely. That's no small thing and it's not just paper-theoretical.

What value does isolated heap offer for memory-safe languages?

Task exceptions can simply be handled via try-catch at the desired level. Millions of concurrently handled tasks is not that high of a number for .NET's threadpool. It's one thing among many that is "nothingburger" in .NET ecosystem which somehow ends up being sold as major advantage in other languages (you can see it with other features too - Nest.js as a "major improvement" for back-end, while it just looks like something we had 10 years ago, "structured concurrency" which is simple task interleaving, etc.).

It's a different, lower-level model, but it comes with the fact that you are not locked into particular (even if good) way of doing concurrency in Erlang.

GC determinism is one of the things you get. Another one is non cooperative asynchronous termination.

Pretty much all efficient GC implementations are inherently non-deterministic, even if predictable.

How can this improve predictability of GC impact?

No global GC. Each erlang process does its own GC, and the GC only happens when the process runs out of space (ie. the heap and stack meet).

You can for example configure a process to have enough initial memory so as not to ever run into GC, this is especially useful if you have a process that does a specific task before terminating. Once terminated the entire process memory is reclaimed.

There is no free lunch in software - the tradeoff is binary serialization and/or data copying over simple function calls. The same goes for GC - for efficient GC, it has to come with quite involved state which has additional cost of spawning. At this point, might use bump allocator, or an arena. Either way, Gen0 (it's a generational GC) in .NET acts like one, STW pauses can be sub-millisecond and are pretty much non-issue, given that you don't even need to allocate that often compared to many other high-level languages.

Briefly, the tradeoff that Erlang and its independent process heaps model make is that garbage collection (and execution in general) occurs per-process. In practical terms, this means you have lots of little garbage collections and much fewer "large" (think "full OS process heap") collections.

This provides value in a few ways:

- conceptually: it is very simple. i.e., the garbage collection of one process is not logically tied to the garbage collection of another.

- practically: it lends itself well to low-latency operations, where the garbage collection of one process is able to happen concurrently to the the normal operation of another process.

Please note that I am not claiming this model is superior to any other. That is of course situational. I am just trying to be informative.

This is a good post with more information, if you're interested: https://hamidreza-s.github.io/erlang%20garbage%20collection%...

Thanks!

RE: locks and concurrently modified data-structures

It comes down to the kind of lock being used. Scenarios which require strict data sharing handle them as they see fit - for recoverable states the lock can simply be released in a `finally` block. Synchronous/blocking `lock` statement does this automatically. All concurrent containers offered by standard library either do not throw or their exceptions indicate a wrong operation/failed precondition/etc. and can be recovered from (most exceptions in C# are, in general).

This does not preclude the use of channel/mailbox and other actor patterns (after all, .NET has Channel<T> and ConcurrentQueue<T> or if you would like to go from 0 to 100 - Akka and Orleans, and the language offers all the tools to write your own fast implementation should you want that).

Overall, I can see value of switching to Erlang if you are using a platform/language with much worse concurrency primitives, but with F# and C#, personally, Erlang and Elixir appear to be a sidegrade as .NET applications tend to scale really well with cores even when implemented sloppily.

If you use an 96 core machine, or 96 individual machines with single core each, the Erlang code is going to look pretty much the same.

I'm not really sure what this proves, since there aren't really good reasons for spawning 1 million processes that do nothing except sleeping. A more convincing demonstration would be spawning 1 million state machines that each maintain their own state and process messages or otherwise do useful work. But examples of that on the BEAM have been around for years.

So, in interest of matching this code I wrote an example of spawning 1_000_000 processes that each wait for 3 seconds and then exit.

This is Elixir, but this is trivial to do on the BEAM and could easily be done in Erlang as well:

    #!/usr/bin/env elixir
    
    [process_count | _] = System.argv()
    
    count = String.to_integer(process_count)
    
    IO.puts "spawning #{count} processes"
    
    1..count
    |> Enum.map(fn _c ->
      Task.async(fn -> 
        Process.sleep(3_000) 
      end)
    end)
    |> Task.await_many()

The default process limit is 262,000-ish for historical reasons but it is easy to override when running the script:

    » time elixir --erl "+P 1000001" process_demo.exs 1000000
    spawning 1000000 processes
    
    ________________________________________________________
    Executed in    6.85 secs    fish           external
       usr time   11.79 secs   60.00 micros   11.79 secs
       sys time   15.81 secs  714.00 micros   15.81 secs

I tried to get dotnet set up on my mac to run the code in your example to provide a timing comparison, but it has been a few years since I wrote C# professionally and I wasn't able to quickly finish the required boilerplate set up to run it.

Ultimately, although imo the BEAM performs quite well here, I think these kind of showy-but-simple tests miss the advantages of what OTP provides: unparalleled introspection abilities in production on a running system. Unfortunately, it is more difficult to demonstrate the runtime tools in a small code example.

The argument regarding representativeness is fair. But I think it is just as important for the basics to be fast, as they represent a constant overhead most other code makes use of. There are edge cases where unconsumed results get optimized away and other issues that make the results impossible to interpret, and these must be accounted for, but there is also a risk of just reducing the discussion to "No true Scotsman" which is not helpful in pursuit of "how do we write fast concurrent code without unnecessary complexity".

I have adjusted the example to match yours and be more expensive on .NET - previous one was spawning 1 million tasks waiting for the same asynchronous timer captured by a closure, each with own state machine, but nonetheless as cheap as it gets - spawning an asynchronously yielding C# task still costs 96B[0] even if we count state machine box allocation (closer to 112B in this case iirc).

To match your snippet, this now spawns 1M tasks that wait the respective 1M asynchronous timers, approximately tripling the allocation traffic.

    var count = int.Parse(args[0]);

    Console.WriteLine($"spawning {count} tasks");

    var tasks = Enumerable
        .Range(0, count)
        .Select(async _ => await Task.Delay(3_000));

    await Task.WhenAll(tasks);

In order to run this, you only need an SDK from https://dot.net/download. You can also get it from homebrew with `brew install dotnet-sdk` but I do not recommend daily driving this type of installation as Homebrew using separate path sometimes conflicts with other tooling and breaks SDK packs discovery of .NET's build system should you install another SDK in a different location.

After that, the setup process is just

    mkdir CSTasks && cd CSTasks
    dotnet new console --aot
    echo '{snippet above}' > Program.cs
    dotnet publish -o .
    time ./CSTasks

Note: The use of AOT here is to avoid it spamming files as the default publish mode is "separate file per assembly + host-provided runtime" which is not as nice to use (historical default). Otherwise, the impact on the code execution time is minimal. Keep in mind that upon doing the first AOT compilation, it will have to pull IL AOT compiler from nuget feed.

Once done, you can just nuke the `/usr/local/share/dotnet` folder if you don't wish to keep the SDK.

Either way, thank you for putting together your comment - Elixir does seem like a REPL-friendly language[1] in many ways similar to F#. It would be impolite for me to not give it a try as you are willing to do the same for .NET.

[0]: https://devblogs.microsoft.com/dotnet/performance-improvemen...

[1]: there exist dotnet fsi as well as dotnet-script which allow using F# and C# for shell files in a similar way, but I found the startup latency of the latter underwhelming even with the cached compilation it does. It's okay, but not sub-100ms an sub-20ms you get with properly compiled JIT and AOT executables.

C++: zero-cost leaky abstraction with unlimited cognitive and development cost

Functional programming languages: Unlimited good abstractions of unknown cost

I don't feel like there's a great third option. Go is pretty good.

I hate to be that guy, but if you want "C++ but also functional programming" then... Well, then Rust is in fact the language which you're looking for.

If anything the cognitive load of rust is worse than C++

Rust is certainly challenging, even copilot finds it difficult to write correct rust, it's fun to see the AI fight the compiler.

I guess the way I feel about using rust is kind of the opposite of how I feel about using Go. Go has such plain and straightforward semantics that it’s very easy to make simple, straightforward packages with it. It is actually even simpler than Python. In C++, it’s a pain to get there, but those simple anbstractions are still at least _possible_. In Rust, the nuances of the semantics are not only convoluted, but also very hard to encapsulate and abstract over. It’s not that the abstractions leak quite as much as it is that the nuances of the semantics are inextricably and necessarily _part of the package API_.

It could probably be argued that this is simply acknowledging reality, and that C++ lets you get away with murder if you want to. But maybe that’s what I want.

I think a good feature for C++ would be a “safe” (or “verified”?) block or method decorator that could enforce some set of restrictions on semantics, e.g. single mutable borrow. The problem is that those functionalities are part of the compiler APIs and not standardized.

The Rust compiler is also not standardized, but they can get away with it.

> where we as an industry made much better choices in the 90s about how we write distributed software.

Erlang is a nice piece of software.

However, let us not dismiss the massive progress the world of distributed software has made since 1990s _not_ involving Erlang too.

Look at the scale at which we _reliably_ access video, audio, email, messaging, e-commerce/trading on distributed systems around the world ! At high reliability too ! Google, Facebook, Amazon, Netflix, Microsoft, NYSE/NASDAQ, ... -- Imagine the millions or even billions of computer systems working, cooperating in various private and public "clouds".

Apart from a few prominent systems here and there (e.g. erlang at WhatsApp), most of these systems _DONT_ use erlang. For various reasons Erlang has _not_ been chosen by thousands of software architects when they choose to build their next distributed system. Even though erlang lets us build a distributed system with lots of properties out-of-the box easily, let's talk about some failings of Erlang:

- Erlang is not statically typed language unlike Java, Rust, C/C++ etc. This means an erlang compiler cannot create code that will run as fast as the aforementioned languages. The compiler simply just does not have that much information available during compile time

- Not being statically typed also makes it a bit more difficult to refactor the codebase. Would you be able to refactor a 1 million line Rust code base more easily or a 100,000 line erlang code base (even if you have used Dialyzer). My money is on Rust.

- Not being statically typed also means that you cannot verify or mathematically prove properties about your system using various techniques as easily

TL;DR -- A small team can build a highly capable system on erlang quite easily in 2024. That small team would probbly take longer if they used Rust/C++/Java because those languages are more low level and take more time for development. But if you can throw some $$ on the project, in the long run a system built in Rust/C++/JVM can run more efficiently (and be maintained more easily) on a fewer machines using specialized code written in Rust/C++/Java etc. In other words it's not everyday you need to build a distributed system -- when you do, it makes sense to specialize and build it on a technology stack that may be a bit lower-level and statically typed.

This comment is already too long enough.

I like Erlang, it has some nice properties but when building distributed systems other technology stacks can also offer some other great advantages too.

> - Not being statically typed also makes it a bit more difficult to refactor

> the codebase. Would you be able to refactor a 1 million line Rust code base

> more easily or a 100,000 line erlang code base (even if you have used

> Dialyzer). My money is on Rust.

I have found that refactoring erlang is NOT like refactoring code in other languages, non trivial refactoring in rust is a LOT more complicated however I do understand the fuzzy feelings you get when type-safe code compiles correctly.

Most erlang refactoring that I see needing to be done is simply reapplying a different pattern to the gen_server or distributing load differently. I believe if refactoring is a "complex problem", the development team had not designed with OTP behaviors in mind. My view may be because I have limited experience in refactoring my erlang due to being a solo developer and my mind is stuck in OTP land, please correct me if you've experienced it differently, I feel that you're perhaps painting the picture a little unfairly there.

If programmers need type-safeness for BEAM and I believe Gleam Language supplies the security blanket that other languages provide. From my limited experience it does NOT provide any additional "speed" (I expect there are not many compiler optimisations that end up down on the BEAM level) however it does give you that level of confidence that you're not going to be passing garbage data through your functions.

I haven't taken anything you have said as a personal (or even against erlang), thank you for the discussion points.

Really like the new Erlang 27 docs https://www.erlang.org/doc/readme.html

What a breath of fresh air, the old docs really were showing their age.

Woah! They copied the excellent hexdocs format, this is great.

https://hexdocs.pm/nanoid/readme.html

Better still—they didn’t copy ExDoc, they are using it exactly as it is! It’s really refreshing to see the sharing between Erlang and Elixir.

Having been stuck in the js world my whole career, it’s really cool to watch a community that’s rooted in collaboration instead of competition.

It’s a nice example of cross-polination, they essentially adapted Elixir’s documentation system for Erlang.

Finally. I never liked erlang doc style.

Hyped about json becoming a first class citizen. As an Elixir engineer and daily Jason user it will be great to rely on stdlib functionality. Jason is great, regardless!

Reading the notes it appears it was implemented by Michał Muskała who also implemented Jason (and seems it is faster too)

Indeed it is: https://zeroclarkthirty.com/2024-04-21-benchmarking-erlangs-...

I think I’m going to just break down and learn erlang. I’ve been interested in it for awhile but mostly work in f#. I recently started looking at gleam but I don’t think learning it with no knowledge of OTP is a good idea.

this link might help you with learn otp with gleam https://github.com/bcpeinhardt/learn_otp_with_gleam

I think you can use it without OTP with very little issues,

I did write this, which is a port of the erlang design principals for gleam:

https://github.com/wmealing/gleam-otp-design-principals/blob...

I would learn Elixir instead (unless you want to specifically learn Erlang) as it is a sort of a more modern Erlang and you get access to all Erlang ecosystem for free. Years ago, I switched a codebase from Erlang to Elixir and it was a breath of fresh air. Note that I like Erlang a lot, but Elixir even more.

Just mentioning gleam https://gleam.run/ which is a typed (and very opinionated) languages that runs on the BEAM

The `maybe_expr' meta pattern matching fallback mechanic is nice, and can surely help avoid a lot of boilerplate code while simultaneously encapsulating the logic in a structure which is easy to read and reason about. It's also not a thing in any other programming language I've learned- C, Java/Scala/C#/C++, Go, Javascript, Tcl, Bash(lol), PHP, Forth, ML, and so on.

I had to look up it's usage though, because I'm new to both Erlang/BEAM and Elixir.

https://chiroptical.dev/posts/2024-03-04-erlang-maybe_expr.h...

You do realize that Rust, C#/F#, Kotlin/Scala, now Java to an extent, pretty much all FP and many other languages have extensive pattern matching support?

In fairness, it's doing a bit more than "just" pattern matching. It's very similar to the `with` expression in elixir: https://hexdocs.pm/elixir/1.16.3/Kernel.SpecialForms.html#wi...

You can use it to execute a series of functions returning `either`-ish tuples and build up a railway oriented program.

It goes beyond your typical pattern matching, check out the link in my first post if you're curious to learn!

I really appreciate that this software has been under continuous development, maintenance and improvement for so long. Its nice to see such long term support, no better way to preserve engineering insights, than continuing to use them in production.

JSON is a big one, great job Erlang folks!

> The Erlang/OTP documentation before Erlang/OTP 27 was authored in XML

ouch

I love the new documentation site: https://www.erlang.org/doc/apps/stdlib/lists#duplicate/2

Looks a lot like Elixir's. The previous one was functional, but a little barebones. A little colour, hyperlinking and syntax highlighting goes a long way. Also, navigation seems to be improved. I always lost my way navigating across Erlang modules to find a specific function.

The entire Erlang/OTP ecosystem got a boost of mind share with the explosion in popularity of Elixir, and it's so nice to see it improve at breakneck pace [1], with some cross-pollination between Erlang itself and Elixir. The ideas of Armstrong, Virding and Williams are in many ways far ahead than a lot of mainstream languages, and they were long overdue a revival under the spotlight.

Keep up the good work!

1: yet, it's still the most rock-solid platform to build services upon, and you can quote me on that.

I love that the Erlang guys seem to be so open to Elixir being a big part of their ecosystem even relying on ExDoc for their new documentation system (I think everyone can see it's a big improvement over the brutalist UI that was there before). A lot of software projects would be ego driven rather than pragmatic on something like this.

ExDoc is arguably one of the nicest documentation systems out there, and Erlang moving to it means two things: 1. The Erlang devs do not need to implement and maintain their own anymore. 2. ExDoc will improve faster since people previously working on Erlang’s documentation system shift to it.

It’s really a win for both, and I love it.

It doesn’t just look like Elixir’s docs, Erlang has adopted ExDoc, Elixir’s documentation system.

Reply on news.ycombinator.com