existentials are so underrated

here is something fun (periodic 2 am vega post): i might add monomorphizable existentials to vega! this might not make a ton of sense initially so i'll start with a motivating example.

is there anything more attractive than a man with a french accent omg

the first rule of compilers is to have fun

Who is on the line when something goes wrong? an engineer. It's outsourcing the work but having your staff fix mistakes they didn't make. You get none of the domain knowledge or insight into technical challenges with all of the burden of maintenance. Cracking open black boxes in a crisis... great

Can you afford to not understand a system or a piece of it? No? Then don't vibe code it. Seriously, you'll either be forced to understand it eventually or replace it, but it won't be on your terms then. The only "legit" way I see is when it's a fire-and-forget situation, but those are rare!

Compiler goes to programmer. "Programmer, I am in rough shape. Mutable references abound and the tiniest changes break API compatibility." Programmer replies, "The treatment is simple! Rewrite in Haskell and GHC will sort you right out." Compiler bursts into tears: "But I am GHC!"

so, what is the most efficient sum type encoding in JS? the most common one i know is { tag: "blah", field1: ..., field2: ... } but i heard jits don't like this one because the shape of the object changes too much?

i just love waking up in the middle of the night because my insulin pump loudly (very loudly) died. (better than dying silently i guess but wow)

lol llvm depends on libgcc?

AI is profoundly unpopular. A recent NBC News poll found that among 18-34 year-olds, AI's net favorability rating is -44. *Negative 44*. Those are basically serial killer numbers. It's not much better among women 18-49. (Men over 50 and upper class are the only ones who like AI, and just barely.)

fil-c is so cool

Hi! We build fast verilog simulators using just in time compilation. Our simulator outperforms existing verilog simulators by up to x100. verijit is a project by @cfbolz.bsky.social and Can Joshua Lehmann. Check out out demo video here: www. youtube.com/watch?v=PXgUsEjvAOY

the fun part is that i posted this at 2am so i can just pretend that when i said "tomorrow", i totally meant saturday and not friday

i might do a surprise vega stream tomorrow (no promises though)

very happy to see haskell doing more to reach women en.wikipedia.org/wiki/GHC_Wom...

it's still so great that in haskell, "safe" ffi calls actually make it much easier to cause undefined behavior than "unsafe" ffi calls

type based anti aliasing

have you ever thought javascript spent too much effort on type safety? have you ever wished that runtime error could have been a segfault? do you just hate useful documentation that takes the fun away from guessing how a function should be used? then you should try llvm's c api!

employment status update: i am! starting 1-st of may i'll be working full time as a rust maintainer in @rustnl.bsky.social's maintainers team. a dream come true :) i'll be continuing work on maintaining the rust compiler & related projects, but now full time & paid ^^'

vega fixes this btw (well, non-monomorphizable type parameters are kind of broken for silly reasons atm but when I fix them it will fix this ^^) www.reddit.com/r/rust/s/to6...

typo of the day: "keepAlice#"

New blog post! I really hope I'll get a decent amount of people mad with this one 😈😈😈 #programming #computing #floatingpoint #geometry lisyarus.github.io/blog/posts/i...

i wonder how much of a difference it would make if you could annotate haskell packages as "expensive" and make cabal/stack compile them earlier for better parallelism.

The gcc source has some good finds:

are there ever situations where one would want more than a word of alignment? i know one is a hack where you really really want two objects to go on different cache lines (although it feels like there's got to be a better way to do that) but is there anything else?

sooo anyone looking for a Staff-level Rust person somewhere that doesn't push vibe coding down your throat... asking for a friend

oh it's just stackoverflowing lol

so, uh, is it normal for your malloc to segfault?

one of those days

so, it turns out rustc actually does this! (if a function takes ownership of something it passes the pointer without byval) but that's a bit annoying because it's making it really hard to compare my code to rust code that uses byval lol godbolt.org/z/qxaj7v6h6

i'm genuinely considering adding a flag that sets all calling conventions to ccc so tail call elimination is gone but at least you can know where to look for your variables in memory

looks like i'm on a roll today

wow debugging generated code is horrible if you don't even have a fixed calling convention

oh fun. (i *think* this is just a segfault in the program, not in lli but it's kind of surprising that it tells me to report it as a bug anyway?)

did you know that rust has support for parameterized modules, just like ocaml: github.com/rust-lang/ru...

13/ Patterns were invented in/for OOP but the name-motivation-applicability-consequences core is actually useful in pretty much every area of software engineering that develops idioms. Smart Constructors are a "make illegal states unrepresentable" pattern, etc

Doomscrolling has made me unmotivated to do long-term work, so to force myself to be doing *something* besides doomscrolling: n² likes = n obscure software engineering concepts/principles/memes I find super useful

so, (according to godbolt) rustc doesn't set any calling convention for its functions. that means they all implicitly use "ccc", right? is there any reason rustc does this instead of using fastcc? without `extern "C"` it uses its own tricks on top of that and isn't C-compatible anyway right?

today in omfg why is llvm like this: the c api lists constants for a bunch of calling conventions (llvm.org/doxygen/llvm...), but *NOT* tailcc. to use that one, you need to look at the c++ api (llvm.org/doxygen/name...), which does list it

the combination of or-patterns and lower-your-guards in GHC >=9.12 is soo nice

you're using a language with type classes/traits and have a function that uses a class method `blah` at type `Int`. if you jump-to-definiton on `blah`, would you prefer to get taken to: 1) the definition of the method `blah` in its class 2) the definition of `blah` in the instance for `Int` ?

i think one major reason it's so depressing to listen to everyone talk about AI now is that it's all so incredibly superficial. people aren't talking about technologies, they're talking about *products*

Haskell core library committee be like

here's an interesting question: so, llvm implements passing larger structs "by value" with functions taking a pointer argument with a "byval" attribute that instructs the code generator to emit code that first copies the value into the callee's stack frame...

so, if i want to share a type definition between haskell and rust, what would be a non horribly hacky way of doing that? i'm okay with writing macros in either language that read the source file from the other but i'd rather not have to parse it myself

In which I finally make sense of value numbering bernsteinbear.com/blog/value-n...

the one thing i just absolutely don't get about ai generated code is people generating test cases. like, tests are there for you to specify how your thing should work and how it's supposed to be used. that's not an implementation, it's the *meaning* of what you're doing.

(i made this and it's still building vector)

my initial plan was to make my llvm bindings mostly memory safe as far as possible, but... i don't think that's going to happen lol