I tried Gleam for Advent of Code

https://blog.tymscar.com/posts/gleamaoc2025/

114•tymscar•2h ago

Comments

marliechiller•1h ago

One thing im wondering with the LLM age we seem to be entering: is there value in picking up a language like this if theres not going to be a corpus of training data for an LLM to learn from? Id like to invest the time to learn Gleam, but I treat a language as a tool, or a means to an end. I feel like more and more I'm reaching for the tool to get the job done most easily, which are languages that LLMs seem to gel with.

Hammershaft•1h ago

This was one of my bigger worries for LLM coding: we might develop path dependence on the largest tools and languages.

c-hendricks•1h ago

I hope this isn't the future of "new" languages. Hopefully newer AI tools can actually learn a language and they won't be the limiting factor.

positron26•1h ago

This is the answer. We need online learning for our own code bases and macros.

whimsicalism•1h ago

it’s easy enough for them as soon as they have an RL environment for the language

bbatha•1h ago

I’m more interested in what happens when a language is designed specifically for llms? When doing vibe coding a lot of code is a lot more verbose than I’d do normally. Do we drop down the abstraction level because llms are just so good a churning out boilerplate?

dugmartin•28m ago

I think as ai tools actually learn languages that functional languages will win out as they are much easier to reason about.

kace91•1h ago

If you just see language as a tool, unless you’re self employed or working in open source, wouldn’t the lack of job market demand for it be the first blocker?

macintux•17m ago

If you're fortunate, you can find companies with a passion for good code who use lesser-known languages. Picking Erlang, or Haskell, or OCaml generally filters out candidates who don't share your interest in seeing what can be done outside the mainstream.

armchairhacker•1h ago

Gleam isn’t a very unique language. The loss from generalizing may be less than the improved ergonomics, if not now then as LLMs improve.

mikepurvis•1h ago

I don't know Gleam at all so I can't comment on that specifically, but I think everyone has the experience of a coworker who writes C++ as if it's C or Python as if its Java or whatever else.

A language doesn't have to be unique to still have a particular taste associated with its patterns and idioms, and it would unfortunate if LLM influence had the effect of suppressing the ability for that new style to develop.

ModernMech•1h ago

Yes, because LLMs don't change the fact that different programming languages have different expressive capabilities. It's easier to say some things in some languages over others. That doesn't change if it's an LLM writing the code; LLMs have finite context windows and limited attention. If you can express an algorithm in 3000 loc in one language but 30 loc in another, the more expressive language is still preferred, even if the LLM can spit out the 3000 lines in 1s. The reason being if the resulting codebase is 10 - 100x larger than it needs to be, that has real costs that are not mitigated by LLMs or agents. All things being equal, you'd still prefer the right tool for the job, which does not imply we should use Python for everything because it dominates the training set, it means we should make sure LLMs have capabilities to write other programming languages equally well before we rely on them too much.

victorbjorklund•1h ago

I feel that was more true 1-2 years ago. These days I find Claude Code write almost as good (or as bad depending on your perspective) Elixir code as JavaScript code and there must be less Elixir code in the training data.

stanmancan•1h ago

There's certainly a lot more JS code out there to train on, but the quality of the Elixir code is likely overall much better.

jszymborski•56m ago

I personally find it much more painful to generate valid Rust code that compiles and does what I want than e.g. valid python code that runs and does what I want.

dnautics•31m ago

i think it's pretty clear that some of "the things you expect to make an LLM good at a language" (like strong typing) are not actually the case. other things like "don't indirect your code by jumping to something unexpected" might be more important.

manquer•19m ago

If anything llms would be poorer in codegen for static languages because they are more verbose - More tokens to generate and use limited context windows parsing code.

The advantage rather for llms in strongly typed languages is that compilers can catch errors early and give the model early automated feedback so you don’t have to.

With weakly typed (and typically interpreted) languages they will need to run the code which maybe quite slow to do so or not realistic.

Simply put agentic coding loops prefer stronger static analysis capabilities.

agos•45m ago

in my daily experience Claude Code writes better Elixir code than JS (React). Surely this has to do with the quality of the training material

jedbrooke•1h ago

where do you think the corpus of training data comes from?

dragonwriter•1h ago

Its pretty much the same thing as in every previous age, where not having a community of experience and the supporting materials they produce has been a disadvantage to early adopters of a new language, so the people that used it first were people with a particular need that it seemed to address that offset that for them, or that had a particular interest in being in the vanguard.

And those people are the people that develop the body of material that later people (and now LLMs) learn from.

timeon•1h ago

Seems like you are not target audience for these new languages and that is OK. But I guess there are still many people that want to try new things (on their own even).

thefaux•1h ago

In the medium to long term, if LLMs are unable to easily learn new languages and remap the knowledge they gained from training on different languages, then they will have failed in their mission of becoming a general intelligence.

dnautics•33m ago

claude is really good at elixir. IME, It's really really good with a few "unofficial" tweaks to the language/frameworks, but this could be my bias. the LLM cutoff was a fear of mine, but i think it's actually the opposite. we know that as few as 250 documents can "poison" an LLM, i suspect that (for now) a small language with very higg quality examples can "poison" LLMs for the better.

bbkane•1h ago

I keep running into Gleam posts and podcasts and videos. I think it could be an especially attractive alternative to JS for UI with the Lustre library. Haven't tried it yet, my backlog is ever growing...

threethirtytwo•1h ago

It’s really good. But it needs generics. This is a huge downside. It’s a typed and clean functional programming language but it arbitrarily followed golangs early philosophy of no generics. Ironically golang is one of the most hated languages among many fp advocates.

By the developers own action of adding generics ultimately the golang team admits they were wrong or that generics are better. If gleam gets popular I think much of the same will occur.

There’s simply too much repeated code without generics. I tried writing a parser combinator in gleam and it wasn’t pretty.

kace91•1h ago

Perhaps this is a silly question but how do you do functional with no generics? Arent they pretty much required for map/reduce/filter?

threethirtytwo•1h ago

Sorry my comment was wrong. It’s been a while when I messed with gleam and I remember it was missing a critical thing but I misremembered what it was.

Gleam doesn’t support interfaces. Not generics. You are completely right.

chongli•56m ago

There are multiple levels of possible generics at play here: the container type and the element type. You can have a map/reduce/filter that operate on any element type (generic elements) while still being specialized to linked lists. On the other hand, you might prefer a generic map that can operate on any container type and any element type, so that you can use the same map method and the same function to map over arrays of numbers, sets of numbers, lists of numbers, trees of numbers, or even functions of numbers!

Haskell allows both sorts of generics. In Haskell parlance they call this higher-kinded polymorphism and the generic version of map they call fmap (as a method of the class Functor).

lpil•12m ago

Gleam does have generics.

NathanaelRea•1h ago

I saw your other comment that you meant interface. But an example of a language that went without a feature people thought the language desperately needed was Go with generics. They only added them more than ten years later, when they figured out the best way to implement them.

It might be the same with gleam, with first version in 2019 and 1.0 in 2024. The language authors might think they are either uneeded and lead to anti patterns, or are waiting to see the best way to implement them.

akkad33•55m ago

Why does it need generics? There's a great blog post about how you can replace a lot of trait behaviour with just functions. Maybe something like that can be done for generics

nonethewiser•41m ago

Go touted it's lack of features as simplicity. And it is: on the language writing side. Go is an incomplete language masquerading as a simple one.

ljlolel•33m ago

That’s the worse is better philosophy which maybe doesn’t matter as much anymore especially with AI

lpil•12m ago

Gleam has always had generics! There’s no Gleam version without them

bnchrch•1h ago

Gleam is a beautiful language, and what I wish Elixir would become (re:typing).

For those that don't know its also built upon OTP, the erlang vm that makes concurrency and queues a trivial problem in my opinion.

Absolutely wonderful ecosystem.

I've been wanting to make Gleam my primary language, but I fear LLMs have frozen programming language advancement and adoption for anything past 2021.

But I am hopeful that Gleam has slid just under the closing door and LLMs will get up to speed on it fast.

sbuttgereit•59m ago

> For those that don't know its also built upon OTP, the erlang vm

This isn't correct. It can compile to run on the BEAM: that is the Erlang VM. OTP isn't the Erlang VM; rather, "OTP is set of Erlang libraries and design principles providing middle-ware to develop [concurrent/distributed/fault tolerant] systems."

Gleam itself provides what I believe is a substantial subset of OTP support via a library: https://github.com/gleam-lang/otp

Importantly: "Gleam has its own version of OTP which is type safe, but has a smaller feature set. [vs. Elixir, another BEAM language with OTP support]"

lpil•18m ago

Hi, I’m the creator of Gleam!

The comment you are replying to is correct, and you are incorrect.

All OTP APIs are usable as normal within Gleam, the language is designed with it in mind, and there’s an additional set of Gleam specific additions to OTP (which you have linked there).

Gleam does not have access to only a subset of OTP, and it does not have its own distinct OTP inspired OTP. It uses the OTP framework.

agos•47m ago

the Erlang vm is called BEAM, not OTP. sadly, Gleam's implementation of OTP is not at the same level as Elixir's or Erlang.

lpil•16m ago

Gleam uses regular OTP, it doesn’t have a distinct OTP inspired framework. Source: I’m the author of Gleam.

Uehreka•18m ago

> I fear LLMs have frozen programming language advancement and adoption for anything past 2021.

Why would that be the case? Many models have knowledge cutoffs in this calendar year. Furthermore I’ve found that LLMs are generally pretty good at picking up new (or just obscure) languages as long as you have a few examples. As wide and varied as programming languages are, syntactically and ideologically they can only be so different.

scuff3d•1h ago

Gleam is a great language. It didn't click for me when I was trying it out, but I'm glad to see more people enjoying it.

And I wonder if Gleam + Lustre could become the new Elm.

tempest_•1h ago

As a mostly back end dev Elm looked really nice but all the conflict with the creator and then the lack of compiler releases made me shy away a bit.

I have bumped into "the Elm architecture" in other projects though and it was nice.

styluss•1h ago

Which conflicts? Gleam seems to be released often?

OtomotO•57m ago

The elm drama

rapind•35m ago

> all the conflict with the creator

Just so no one misunderstands this. The creator (Evan) didn't get into, or start, any drama himself that I ever noticed. I'd argue he's a very chill and nice dude.

I've been on the edges of the community for probably a decade now (lurker), and all of the drama came from other people who simply didn't like the BDFL and slow releases strategy.

scuff3d•30m ago

Yeah I'm not a front end dev but I do kind of keep track of what's going on in that space. From what I saw it seemed Elm was all but dead. Maybe that's not true, but that was the impression from the outside looking in.

rapind•38m ago

I recently used Gleam + Lustre for a small app that I normally would have built with Elm + PostgREST. It went very well, and I'm now planning to use it for a larger rewrite (of a rails app).

croisillon•1h ago

fortunately the blog title police stepped in as soon as possible https://news.ycombinator.com/item?id=45426996

periodjet•50m ago

Ruined by ligatures. Use them in your own private coding time, not when trying to communicate with others. It obfuscates rather than clarifies.

tymscar•47m ago

I actually agree. I don’t even use them in my private code. I will look into removing them from my blog!

seritools•45m ago

For a quick fix: `font-variant-ligatures: none;` on body or similar.

toastal•26m ago

I have this as !important in a global userStyle for code, pre, kbd, samp elements.

bmacho•20m ago

For users: paste the following in console

  document.body.style.setProperty('font-variant-ligatures','none','important');

mono442•34m ago

I've looked at Gleam before but it didn't seem to have any mechanism for dynamic dispatch like interfaces or type classes. Did it change in the meantime?

stuartaxelowen•21m ago

The answer I’ve seen is “just pass structs of functions around”, which is just one step more explicit than the implicit version we’re all use to, but honestly I kinda like it to free ourselves of all the ceremony around generics.

lpil•9m ago

It’s discouraged to pass around structs of functions to replicate type classes in Gleam. Instead the preference is to not type class style patterns in your projects, favouring a concrete style instead.

lpil•20m ago

Gleam has first class functions, so it has dynamic dispatch.

Both of type classes and interfaces desugar to high order functions, so anything you write with them can be written with first class functions, though with a less concise API.

the_duke•18m ago

What you are saying is: no, it doesn't.

Of course dynamic dispatch can be implemented in almost every language. The Linux kernel uses dynamic dispatch with C!

But that's a hack, not a language feature.

lpil•14m ago

I think you might mean “ad hoc polymorphism” rather than “dynamic dispatch”. Gleam, C, Erlang, etc have the former, not so much the latter.

WJW•15m ago

Gleam is really quite a nice language. I did AoC in it this year as well and came away with the following: (incomplete list for both positive and negative, these are mainly things that come to mind immediately)

Positive: - It can be pretty performant if you do it right. For example, with some thought I got many days down to double digit microseconds. That said, you do need to be careful how you write it and many patterns that work well in other languages fall flat in Gleam. - The language server is *incredibly* good. It autoformats, autocompletes even with functions from not-yet-imported-but-known-to-the-compiler packages, shows hints with regarding to code style and can autofix many of these, autofills missing patterns in pattern matches, automatically imports new packages when you start using them and much much more. It has definitely redefined my view of what an LSP can do for a language. - The language is generally a joy to work with. The core team has put a lot of effort into devex and it shows. The pipe operator is nice as always, the type system is no haskell but is expressive enough, and in general it has a lot of well-thought out interactions that you only notice after using it for a while.

Negative: - The autoformatter can be a bit overly aggressive in rewriting (for example) a single line function call with many arguments to a function call with each argument on a different line. I get that not using "too much" horizontal space is important, but using up all my vertical space instead is not always better. - The language (on purpose) focuses a lot on simplicity over terseness, but sometimes it gets a little bit much. Having to type `list.map` instead of `map` or `dict.Dict` instead `Dict` a hundred times does add up over the course of a few weeks, and does not really add a lot of extra readability. OTOH, I have also seen people who really really like this part of Gleam so YMMV. - Sometimes the libraries are a bit lacking. There are no matrix libraries as far as I could find. One memoisation library had a mid-AoC update to fix it after the v1.0 release had broken it but nobody noticed for months. The maintainer did push out a fix within a day of realizing it was broken though. The ones that exist and are maintained are great though.

vips7L•10m ago

> Having to type `list.map` instead of `map` or `dict.Dict` instead `Dict` a hundred times does add up over the course of a few weeks, and does not really add a lot of extra readability.

I did it in F# this year and this was my feeling as well. All of the List.map and Seq.filter would have just been better to be called off of the actual list or Seq. Not having the functions attached to the objects really hurts discoverability too.

ngruhn•7m ago

I can live with these negatives. What irritates me the most is the lack of if/else or guards or some kind of dedicated case-distinction on booleans. Pattern matching is great but for booleans it can be kinda verbose. E.g.

   case x < 0 {
     True -> ...
     False -> 
       case x > 10 {
          True -> ...
          False -> 
            case x <= 10 {
               True -> ...
               False -> ...
            }
       }
   }

WJW•1m ago

There are (some) guards available though? You could rewrite your example as:

    case x {
      n if x < 0 -> ...
      n if x > 10 -> ...
      n if x <= 10 -> ...
    }

Guards are a bit limited in that they cannot contain function calls, but that's a problem of the BEAM and not something Gleam could control.

titanomachy•2m ago

I don’t know gleam, but surely

    list.map(fn(line) { line |> calculate_instruction })

Could be written

   list.map(calculate_instruction)

?

I tried Gleam for Advent of Code

SSE sucks for transporting LLM tokens

Cryptids

Analysis finds anytime electricity from solar available as battery costs plummet

Useful patterns for building HTML tools

Dick Van Dyke turns 100

macOS 26.2 enables fast AI clusters with RDMA over Thunderbolt

Java FFM zero-copy transport using io_uring

Show HN: I audited 500 K8s pods. Java wastes ~48% RAM, Go ~18%

EasyPost (YC S13) Is Hiring

Photographer built a medium-format rangefinder

Ask HN: How can I get better at using AI for programming?

How exchanges turn order books into distributed logs

What is the nicest thing a stranger has ever done for you?

Go Proposal: Secret Mode

Researchers seeking better measures of cognitive fatigue

GNU Unifont

A Lisp Interpreter Implemented in Conway's Game of Life (2021)

Using Python for Scripting

A 'toaster with a lens': The story behind the first handheld digital camera

Dynamic Pong Wars

Z8086: Rebuilding the 8086 from Original Microcode

Rats Play DOOM

Show HN: LinkedQL – Live Queries over Postgres, MySQL, MariaDB

Will West Coast Jazz Get Some Respect?

Indexing 100M vectors in 20 minutes on PostgreSQL with 12GB RAM

A Giant Ball Will Help This Man Survive a Year on an Iceberg

Computer Animator and Amiga fanatic Dick Van Dyke turns 100

Beautiful Abelian Sandpiles

OpenAI are quietly adopting skills, now available in ChatGPT and Codex CLI

I tried Gleam for Advent of Code

SSE sucks for transporting LLM tokens

Cryptids

Analysis finds anytime electricity from solar available as battery costs plummet

Useful patterns for building HTML tools

Dick Van Dyke turns 100

macOS 26.2 enables fast AI clusters with RDMA over Thunderbolt

Java FFM zero-copy transport using io_uring

Show HN: I audited 500 K8s pods. Java wastes ~48% RAM, Go ~18%

EasyPost (YC S13) Is Hiring

Photographer built a medium-format rangefinder

Ask HN: How can I get better at using AI for programming?

How exchanges turn order books into distributed logs

What is the nicest thing a stranger has ever done for you?

Go Proposal: Secret Mode

Researchers seeking better measures of cognitive fatigue

GNU Unifont

A Lisp Interpreter Implemented in Conway's Game of Life (2021)

Using Python for Scripting

A 'toaster with a lens': The story behind the first handheld digital camera

Dynamic Pong Wars

Z8086: Rebuilding the 8086 from Original Microcode

Rats Play DOOM

Show HN: LinkedQL – Live Queries over Postgres, MySQL, MariaDB

Will West Coast Jazz Get Some Respect?

Indexing 100M vectors in 20 minutes on PostgreSQL with 12GB RAM

A Giant Ball Will Help This Man Survive a Year on an Iceberg

Computer Animator and Amiga fanatic Dick Van Dyke turns 100

Beautiful Abelian Sandpiles

OpenAI are quietly adopting skills, now available in ChatGPT and Codex CLI

I tried Gleam for Advent of Code

Comments