In an age of AI, is static typing even necessary?

Static typing will be always useful because it reduces the problem search surface for any computer, be it a strict algorithm or an LLM. Less assumptions + more certainty = better solutions.

I voted other. 1) I think we’re a long ways away from LLMs/AI getting to the point where where types are superfluous. 2) As an engineer I’ve simultaneously enjoyed the wild west of Ruby and and more “locked down” languages with modern type systems. I could honestly go either way (right tool for the job, etc.). But I do think types will be invaluable for the next ~5 years. LLMs perform best when they have access to quick self correcting feedback loops. Right now types and tests serve that role.

image1200×678 33.2 KB

Here’s a screenshot from the Matz keynote at RubyKaigi 2025 where he talks about this very topic. My only wish is for better subtitles since the ones there are from the live translation during the talk so it’s a bit hard to understand the context.

Whole video here:

Perhaps this should be in the related thread, but someone mentioned Scala as having a ‘next level’ type system. I asked G2.5P about this in ref to Elixir’s plans:

https://github.com/nshkrdotcom/notes/blob/main/A_TECHNICAL_DEEP_DIVE_INTO_SCALAS_NEXT_LEVEL_TYPE_SYSTEM.md

LOL to be clear this was a joke But ya, I actually didn’t even really consider if there was any truth to it. I think it will always be useful since vibe coding doesn’t sound fun (and I don’t really think it’ll take off like some think it will).

The main benefit of a type system is providing a clear format for documentation. After that, the main benefit of a type checker is ensuring the documentation is correct After that, you get the additional benefit of quickly catching small mistakes as you write code, which is convenient for a tighter feedback loop.

Of course if the model is writing code for you then the documentation is for it rather than you, so the question is really “is documentation useful for LLMs?”, and thus far it seems like the answer is “yes, critically”.

Type systems and even unit tests are wholly inadequate for proper correctness testing, you need fuzz/property-based tests and, for distributed systems and things which touch the disk or network, you need a deterministic simulator as well. This requires putting at least as much creative effort into designing tests as you do into designing the program itself, if not more. I doubt current models are as yet capable of that, but who knows where the goalposts will end up!

One other that I like on the topic is this rant from Rich Hickey

Death By Specificity1200×681 57.4 KB

the video excerpt from the rant(in the description has a link for the full talk

I have an impression that people that really like static typing are the ones that are attached to the editor. While people that prefers dynamic typing is more driven by the repl. whenever i’m working the first thing I do is start iex and then I start doing my changes and call recompile on the repl.

I guess the reason of my pet peeve with static typing is that very few typing systems that I had experience with had a good feedback loop(I guess only Elm was a pleasant experience). Most of the time I was trying to please the type system just to try and test some changes. But I really like the idea of types as first and foremost documentation.

If I don’t typespec my functions I eventually forget what shape of data they accept. Elixir is better than most in that we can pattern match/guard the signatures, but there are still glaring blind spots (you can’t pattern match [{non_neg_integer, %MyStruct{}}]). For that reason, I look forward to the type system!

Obviously you can also write docstrings but those are even harder to keep in sync with the functions; I find I often leave them out of date by accident in practice. That’s what I mean when I say the type checker is useful for ensuring the documentation is correct

I also write typespecs as documentation for the functions. One thing that I’d like to see in the new type system is the possibility to define types with literals other then atoms. it would be really good to explicitly work with functions that transforms external data. But althought the type system allows it, doesn’t seems that they’re going in that directon