I remember playing with Alpaca a few years ago, and it was fun though I didn’t find the resulting code to significantly less error-prone than when I wrote regular Erlang. It’s inelegant, but I find that Erlang’s quasi-runtime-typing with pattern matching gets you pretty far and it falls into Erlang’s “let it crash” philosophy nicely.<p>Honestly, and I realize that this might get me a bit of flack here and that’s obviously fine, but I find type systems start losing utility with distributed applications. Ultimately everything being sent over the wire is just bits. The wire doesn’t care about monads or integers or characters or strings or functors, just 1’s and 0’s, and ultimately I feel like imposing a type system can often get in the way more than it helps. There’s so much weirdness and uncertainty associated with stuff going over the wire, and pretty types often don’t really capture that.<p>I haven’t tried Gleam yet, and I will give it a go, and it’s entirely possible it will change my opinion on this, so I am willing to have my mind changed.
I don’t understand this comment, yes everything going over the wire is bits, but both endpoints need to know how to interpret this data, right? Types are a great tool to do this. They can even drive the exact wire protocol, verification of both data and protocol version.<p>So it’s hard to see how types get in the way instead of being the ultimate toolset for shaping distributed communication protocols.
A recent post about using Gleam for Advent of Code:<p><a href="https://news.ycombinator.com/item?id=46255991">https://news.ycombinator.com/item?id=46255991</a>
I really like the idea of gleam but I don't want to hand implement serialization for every type (even with an LSP action) in 2026.
Biggest issue with this language. But... fairly trivial to implement codegen with gleam/glance[0]. No good libraries do this well right now (e.g. support for discriminated unions).<p>[0] <a href="https://hexdocs.pm/glance/glance.html" rel="nofollow">https://hexdocs.pm/glance/glance.html</a>
Dart has the same glaring issue (yes, yes, you can use a codegen library but it's not the same).
I rarely serialise every type in my gleam code, My quick back of the napkin math is less than 5%.
Now here's a type-safe functional programming language I recently bumped into, which with their focus on simplicity, ease of use, and developer experience, and compiling to either Erlang or Javascript, is really tempting to delve in deeper.