However, their endgame isn't to eliminate human labor (I doubt they would for software engineering). The final outcome of this general trend is them inserting themselves as a gratuitous extra step in the process where people babysit agents and pretend the agents did all the work

i mostly thought of this in the context of vega's array API (that isn't implemented yet). what's pretty unique about vega is that the default array is going to be a size indexed array where `[1,2,3]` has type `Array(3, Int)`...

weird PL syntax idea: maybe type aliases should have some special syntax to distinguish them from regular types? (something like `sum : IntArray! -> Int` with `type IntArray! = Array(Int)`)

not only did haskell and rust release their survey results at the same time, they're also almost exactly the same amount of gay (10.59% vs 10.66%) (which is the important stat obviously) discourse.haskell.org/t/state-of-h... blog.rust-lang.org/2026/03/02/2...

i still think it's funny that reallyUnsafePtrEquality# isn't actually unsafe

interesting how some people nearly vanished from my feed since i muted "claude"

i'm sorry ghc it won't happen again

llvm is so interesting. basically no function on the instruction builder has docs and you're just supposed to guess what the parameters do, but apparently we all really need to know that LLVMGetTypeAttributeValue gets the type attribute's value

it's cute how rust people say "interior mutability" when they mean mutability

so that bug where vega is trying to compile code to core even though it has a type error doesn't happen if i run it as part of my test suite (which literally copies the file over and calls `vega build` just like i would do manually) i love compilers

Into is such a ridiculous trait. "yeah i just want to call a function that turns into type into another. no, i don't want to specify which types"

no one wants to talk about the inclusiveness of the SAS community willcrichton.net/so-lang-dive...

i still can't get over how many people are actually taking this seriously. like, i know programmers are bad at critical thinking but how is noone but waffle questioning that more rust people are queer than not or that the majority of programming languages is like 2x above the general population

let's say you have a large enum like this in rust enum Blah { Large(VeryLargeStruct), Small(i64) } is there a world where rustc can optimize Box<Blah> such that `Box::new(Small(5))` only allocates a small object on the heap? (similarly to how haskell or ocaml would represent a boxed sum)

(periodic 2am vega post) I really like how vega's anonymous records work. they're pretty unusual in that they're extremely simple and not very powerful, but that's exactly what I like about them!

The Dalai Lama walks into a union-find shop and says can you make me one with everything

so, on one hand, persistent data structures that use mutation internally but are very careful to expose a pure interface are really cool. on the other hand my QuickCheck test is failing and if i type the failing input in manually *it passes* how do i even start to debug this omg

you would think the hard part of very low level haskell would be threading state threads around correctly and avoiding invalid writes but no, it's actually trying to figure out why getSizeofMutableByteArray# returns -4597893732363977331

type propagation via go channels. distributed type checking with Kafka. Using Amazon sns / sqs for type checking in the cloud. Type checking as a service. Watch out, I'm going to publish an update for your unification variable. Help my skolem ended up in dead letter queue. I won't ack this type.

hey uhhh. I got fired yesterday. if anyone has rust positions in the Netherlands let me know!

so like, how does `tail` work in llvm? i know it's only a hint to the compiler but like, why would i ever leave it off? like, in this random rust code, llvm optimizes it to include a `tail` annotation on the call, even though it's *not even in tail position*! godbolt.org/z/46GMaxv86

Next Rust in Paris speaker is @wffl.ihatereality.space, member of the Rust compiler team. Their talk will be: "Little rust delights" where they will talk about some nice but lesser known tricks and tips in Rust. www.rustinparis.com To buy your ticket: ti.to/xperhub/rust... See you there!

i'm a good influence

this was surprisingly good (it's about ai for programming in case you don't want to read that) www.lelanthran.com/chap14/conte...

Ragebaiting anti-ai compiler devs by calling the lexer the tokenizer, parser decoder and code gen inference.

hot take: extensible syntax is bad and macros are usually worse than more limited forms of metaprogramming like GHC.Generics/compile time reflection (whatever that actually means) or simpler splices

how controversial would it be to say that the module system is the worst part of ocaml?

related fun llvm discovery of the day: llvm segfaults if you pass a non-function type to LLVMBuildCall2

"strong" type systems are such a silly concept. it's actually really simple: there are statically typed languages like python and dynamically typed ones like LLVM's C api

most haskell tutorials are bad enough already, do we really have to add LLM slop this time?

haskell quiz: given the following module, print the contents of `pattern` in a module that has PatternSynonyms enabled. you cannot turn off PatternSynonyms or define any other modules {-# LANGUAGE NoPatternSynonyms #-} module A (pattern) where pattern :: Int pattern = {- secret -}

I tried out vibe coding yet again over the weekend and was disappointed with the results: haskellforall.com/2026/02/my-e...

i think i'm getting close to the lethal dose of combinatorics to do in a day

hypergraphs are hard but at least "i'm struggling with hypergraphs" is a sentence everyone is going to believe

Specifically, the kind of person who, despite being largely on "the same side" as you on the broader issues, will come out knives swinging at the smallest slight, real or perceived, and then deflect and blame-shift and put words in your mouth to justify it. I don't need people like that in my life.

the error messages here are nice and all but what stuck out to me: flix doesn't support FlexibleInstances? why?? this is such an unnecessary restriction that Haskell fixed in *2007* blog.flix.dev/blog/making-...

haskell's ffi is soo good

why is libclang like this

i wish people would stop talking about AI being built on "theft". that's not what theft is. if someone steals your car, the problem isn't that they now also have a car that looks like yours, it's that you don't have one anymore.

saw a post on my feed that said "anti-AI people are making me want to go and use LLMs for good!" and can't help but think of that one comic

You aren't going to convince anyone with trivially falsifiable claims and misinformation. I detest the AI craze and even I can accept that LLMs (as a general technology) can do *some* useful things (even ethical ones), never mind other forms of AI/ML.

I'm watching a Haskell livestream on one screen and playing Hades on another. Where's my complimentary hormone bottle with that?

TIL ghc allows comments in pragmas {-# LANGUAGE Lambda Case {- , TypeFamilies -} #-}

omg ocaml.org supports displaying source code in api docs now! (like haddock or rustdoc) and they support jump to definition! (like haddock but unlike rustdoc) when did that happen, that's really awesome!

java: AbstractBeanBuilderFactory haskell:

(I'm picking on anti-AI journalism here but pro-AI journalism is equally as bad on this matter)

So that's why AI Journalism sucks. Journalists see an article that affirms their priors, don't have the experience to fact check it, don't bother to do the basic due diligence of making sure the author isn't an actual child, and push it to their audience as proving a "mathematical limit" of LLMs

Jesus Christ, AI journalism is so bad right now. Exhibit one, Gizmodo is raving about an article that 'proves' LLMs have a "mathematical limit" and can't possibly do tasks that are too complex. Let's look at the actual paper, shall we? gizmodo.com/ai-agents-ar...