Our great sponsors
-
armstrong-distributed-systems
Notes on how we potentially could build reliable, scalable and maintainable computer systems.
-
WorkOS
The modern identity platform for B2B SaaS. The APIs are flexible and easy-to-use, supporting authentication, user identity, and complex enterprise features like SSO and SCIM provisioning.
-
-
ergo
An actor-based Framework with network transparency for creating event-driven architecture in Golang. Inspired by Erlang. Zero dependencies.
-
-
-
InfluxDB
Power Real-Time Data Analytics at Scale. Get real-time insights from all types of time series data with InfluxDB. Ingest, query, and analyze billions of data points in real-time with unbounded cardinality.
-
Not sure this is what GP is talking about but to implement the actor model in https://letlang.dev I use tokio.
I'm the author of something related https://github.com/lunatic-solutions/lunatic
https://stackoverflow.com/a/73932230/312907 I found this answer.
I can't find the original announcement, but I found the accepted Go proposal: https://github.com/golang/go/issues/24543
I remember that being the straw that made me drop Elixir (which I love, to be clear). Go excels in many, many places where Elixir does, but it's way faster.
I do think Elixir has immutability on their side, which is huge for new developers, but there are way less developers in Elixir than Go, so the end result doesn't change unfortunately.
I wrote a preemptive 1:M:N scheduler in C, Rust and Java.
https://github.com/samsquire/preemptible-thread
It is a 1:M:N scheduler where there is one scheduler thread, M kernel threads and N lightweight threads. I take advantage that loop indexes can be structures and can be modified by other threads. So we can set the thread's looping variable to the limit to end the current loop and pause it and then schedule another thread.
A used this a couple of times in production: https://github.com/asynkron/protoactor-go.
No problem launching a 100k actors on a laptop.
> Creating a language with the feel of a lisp, the environment of Smalltalk, and the concurrency of Erlang has been my dream for a long time.
I'm trying to eventually accomplish something like this: https://github.com/sin-ack/zigself
It's an implementation of the Self programming language in Zig, with an actor model inspired by Erlang.
The main thing to realize is that Lisp and Smalltalk are very much symmetrical in terms of structure. There is no real distinction between the two other than syntax and basic computation unit (closures vs. objects). And even closures can be used as objects and vice versa.
That only leaves the concurrency model. I have a basic implementation of actors using objects as the "context". It still has a long way to go to reach the supervisor tree model of Erlang, but interestingly enough, the ideas in the article are reflected here heavily; behaviorism is at the core of Self.
Erlang is definitely more fault tolerant than most languages, but I've found that static typing tends to catch a lot of errors in development that would otherwise crash an application in production. The compiler won't catch every bug, and you'll still typically have to restart a crashed service periodically (via systemd, or a container orchestrator, or whatever process manager you use), but it definitely helps.
Gleam is a pretty good choice if you need type safety and you want to run on the BEAM https://gleam.run/. It still has the same performance characteristics of Erlang (which it compiles to), but at least it gives you type safety.