Gary Trakhman

What's the next phase of AI adoption after using up all my dopamine over 2 weeks catching up on agent TUI and subagent frameworks?

Why bother contributing upstream if claude can just make my fork better? Why accept a contribution instead of rewrite it if you like it?

I've been rewriting open source projects I see in rust for just to learn the tools over the last few weeks and I don't know why anyone would ship new open source for other people to use a year from now.

Everyone's going to be forking and maintaining everything themselves. I'm not sure what open source will be in a year.

The LLM game is instead of doing the thing you want to do, you build the CPU in Minecraft to run the bespoke compiler for an esoteric language specialized to your task, then eventually using that to do the task, just in case you get a similar task again.

Folks going to get rate limited by mental health providers

Swearing at Dr Sbaitso was my jam

I am at the stage of vibe coding where I create new projects to solve my own inability to juggle multiple projects.

Code craftsmanship might be dead, but I don't ever need to really learn CSS.

What if Yegge nonsense is not farfetched in a year?

Ah neat, didn't catch that core.async worked with this. Is it related to future plans to rip out IOC in newer jvms with virtual threads?

Bambu a1 mini is pretty cost effective and good, just small. You might want a bigger one later depending on what you're into.

It depends on if you want your hobby to be tinkering with the 3d printer or printing things. I liked learning on the Ender 3 V3 SE. It printed fine out of the box, but I enjoyed understanding the process and making it work better.

Spec-kit feels like a major productivity boost on day 1 despite apparently being just a bunch of prompt templates. I'm sold on the idea that a lot of code is just going to be throwaway now when you can just regenerate a viable implementation from a clear spec.

The difference is taking on a new library or tool is usually amortized over a long period of time of constant human process, and this is a massive change all at once.

I guess slop tooling is fine? I'm less excited about slop production code.

To be fair, the CPU I have today is 2x faster. I think Rust compilation speeds are good enough on a 16-core ryzen 5 to match my own ability to optimize or break things into smaller projects, but on my 2015 macbook pro it's barely tolerable.

I don't remember ocaml being necessarily faster at compilation. Also this is neat binary patching dioxuslabs.com/learn/0.7/es...

It's not impossible to do these things in ocaml, but it's a lot of friction and it's nice not to have that friction. Then that lack of friction promotes stuff I like at scale.

I haven't really seen that in the wild. But the rust convention in contrast is to put quite a lot behind traits. The compiler will monomorphise for you when it can, so there's not necessarily a runtime dispatch cost.

I like to see the code as it will be reviewed by someone else. I usually notice more things to change once I actually make a draft PR. I think having the types always visible means I will depend on them more. I should add the ones that improve clarity and I might not otherwise.

We just used flyway for migrations, lol

The arrows are functions from the input type (left) to the output type (right). It makes sense if you already know it. I was underwhelmed when I got it.

Basically, the functions all called 'map' look the same but do different things. (ocaml) List's will loop, Deferred blocks on scheduled task, etc

No idea how I would build something like this in ocaml without first-class modules. docs.rs/tracing-subs...

Why don't we see more things use FCMs?

I thought often in OCaml that it might be better if literally everything used FCMs, and that's effectively what traits does for me. Library code is parameterized over my own types allowing inversion of control.

Record of functions sounds weak, but even harder to coordinate over multiple libs.

The startup died. Maybe related, we had multiple rewrite attempts out of ocaml and that probably wasted a lot of time. I liked how well it ran after it was written. I didn't like having to build my own worse versions of things other languages had to get there.

An authz sidecar. Not an app, but an API. Just the routing, serving, serialization, error handling, otel tracing. Still easier than I expected.

I rewrote our rust service from rouille (kind of dead) into axum in about 15 minutes docs.rs/axum/latest/...

It is comparable to dream but much more mature and widely deployed, and there are other good options.

I spent a hackday on a middlewares POC over univ-map, iirc. Definitely needed that. We also had our own Sentry library and top-level error handler. These days I would push for OTel.

We didn't have it at the time 2017-2022, but it looks like the right kind of thing. I'm not sure it's enough.