Agents are the oxygen that oxidize rust.

correct take!

I’m curious, in a world where the agents decide everything for you, what decisions are you making?

You gotta go learn the archaic rules behind python first

Go write your saas app in ASM and report back.

That’s right. Once we’re done with baml we can all stop everything. Last thing we’ll ever need! 🫡

modern compilers are really really good. in terms of exploring data layouts, I prefer writing in a language with a good compiler and then using AI to inspect the compiled ASM with me to see what we’ve gotten! It’s much faster to understand larger volumes of changes.

I mean models are good enough to write in any language. LLVM IR still expresses ideas much more verbosely than Python / TS / BAML per se. And in many scenarios that verbosity may not be buying you anything.

5 years from now there will be more ASM than today, but there will be even more higher level language code than that. I’ll take the bet!

You can do this already!

The hard thing about software is that something may not have changed for 1 year and then suddenly need to change. Also modern compilers are very very good. Writing in asm doesn’t automatically mean it’s faster

wait till they learn about xtensa!

AI will never ever write code in assembly. Lets me tell you why. I spent most of my career writing assembly, and the hardest part of job was never to write things in ASM, it was deciding what to write in ASM. Writing things in ASM has a real tax. You lock in architectures, memory layouts, and making your code fast, means making it more rigid. Think about our supply chains during covid. Shipping stops and suddenly everything breaks. Speed is never free. AI might write some code in ASM, but only if the value you're getting is worth the benefit. New folks can benefit from SSE/AVX instructions, but the majority of code in the world needs to remain flexible and updatable. At 1M Tokens / second, would you rather generate a for loop in ASM? or an entire app in Python? Time will always be money and compilers and higher level languages are going to win. Hopefully BAML :)

Yep! Every existing language was designed for a world assuming some human read that line of code. New languages need to exist designed for the opposite world: humans have read the least lines of code and code can be fixed quickly and reactively.

brew install baml

It’s basically semantics of rust, but no lifetimes to deal with. Plus we brought in unions from typescript! We do live onboardings every Thursday if you’re interested boundaryml.com/eap

re the dynamic of python, this post explains it better nitter.net/vaibcode/status/210372… but concurrency and correctness are a notoriously hard duo. Given that the target for what people should build in BAML is application code not systems code, we bias a bit more towards practical concurrency over lifetime management. this mean: 1. we make it possible to cancel hot loops 2. we have really nice thread pool ergonomics 3. we can support durable execution / multi-machine concurrency (not yet shipped, still in slop stage and needs to be cleaned up) 4. all container types are threadsafe w/o gil you can still run into data races/logic bugs, but we think with really good tracing / observability you'll be able to diagnose issues much better. to help with this, we made BTEL - our improvement over OTEL - thats just 10ns overhead on function calls, and 1000s of times smaller in memory/disk footprint.

go has a lot of things that i love, but misses so much as well: union types, the open interfaces things always bothers me, generics were introduced too late into the language, rusts Result type > go's error tuple.

Build composable layers so you can incrementally rewrite it! Have found this to be very true in our codebase as well.

A line of code a day keeps the slop at bay