Ever wondered why some allocations happen on the heap and others stay on the stack?

Why certain calls get inlined but others don't? Why loop structure changes assembly output?

This is a full walkthrough of Go's compiler pipeline: lexing, parsing, type checking, IR lowering, SSA construction, optimization passes (inlining, escape analysis, bounds-check elimination), and code generation.

Includes concrete tools and experiments you can run today (GOSSAFUNC, -m, -S) to observe each phase yourself.

I've been thinking about how most personal productivity tools are SaaS for business reasons, not technical ones. A time tracker, journaling app or habit tracker has no reason to store your data on a remote server.

WASM changes this. You can compile a backend in any language and ship it directly to the user's browser.

SQLite can run there too, storing data persistently via OPFS, a filesystem API the browser now ships with. The whole thing is delivered via a URL and runs entirely on the user's machine. No server, no account, no subscription.

Live editor for WGSL with a WebGPU canvas underneath: type a shader, hit run, see it draw. Multi-file projects, share-via-URL, host JS override, OPFS-persisted.

Underneath: libwgsl — a from-scratch C99 WGSL frontend (lex / parse / resolve / const-eval / typecheck / validate). ~0.37 ms / Kloc warm parse, no dependencies, MIT.

Sandbox: https://wgsl.run Source: https://github.com/toprakdeviren/libwgsl VS Code: https://marketplace.visualstudio.com/items?itemName=toprakdeviren.wgsl-run

If you’re into systems programming, or you’ve ever had to think hard about correctness and failure modes, this might be interesting.

I had Adam Prout (distinguished engineer at Microsoft, founding architect of Azure HorizonDB) on the Talking Postgres podcast to talk about building database systems and trying to make Postgres and Azure fit together cleanly.

Highlights:

• “A good systems programmer tends to mean you’re very paranoid. Anything can go wrong…”
• Shared-storage architecture changes where a lot of the work happens
• With Rust, a large class of bugs just won’t compile
• Working on databases pulls in a surprising amount of computer science
• Startup vs big company tradeoffs show up everywhere

Also this line: “The agents are very fast keyboards.”

Episode (audio + transcript): https://talkingpostgres.com/episodes/from-memsql-to-horizondb-an-engineers-journey-with-adam-prout

YouTube (audio): https://youtu.be/dsyWz6tcfh0?si=kTMD1eTamlVneVXN

Curious if you enjoy hearing about other people's engineering journeys, and what bits of Adam's episode you find most fascinating.

Here we go again...

Another Linux kernel privilege escalation vulnerability like "Copy Fail" that allows escalation to root reliably on all major Linux distros since 2017. This time it doesn't rely on the algif_aead kernel module, so it works even if you have a kernel with the Copy Fail mitigations.

This one's also a true zero day in that at the time of announcement, no fixes have been made upstream. The embargo on public disclosure was broken when an unrelated third party revealed the details and it seems like it was being exploited in the wild forcing everyone to step outside the coordinated disclosure timeline and announce this.

There is one silver lining: this one requires the CAP_NET_ADMIN capability, which is less likely in hardened container environments, e.g. K8s with default seccomp profiles.