Roasting Julius' code in T3 Code

追加: 2026-05-09

[00:00:01]Let's see, I'll start from the top.

[00:00:04]So it's a minimal web GUI for coding agents currently, codex and Claude more coming soon.

[00:00:12]if you really want to contribute, still read this first.

[00:00:17]Let's see what, let's see what Julius said.

[00:00:19]If you want to contribute, we're not actively accepting contributions.

[00:00:23]You can still open issues or PRs, but know that there's a high chance that we just close it, deferred forever or never ever look at it.

[00:00:34]I like this contributing.md.

[00:00:37]I like this one.

[00:00:39]If that's annoying, that's because it is this project.

[00:00:43]It's got better.

[00:00:44]It got better.

[00:00:46]Like it's getting better.

[00:00:47]This is good.

[00:00:50]this project is still early and we're trying to keep scope, quality and direction under control PRs are automatically, what we're most likely to accept focused bug fixes, reliability fixes, perf improvements, sure.

[00:01:08]Okay.

[00:01:09]So let's see here.

[00:01:12]What is in the agents file?

[00:01:20]Sure.

[00:01:21]Sure, sure, sure, sure.

[00:01:22]Sure. Okay.

[00:01:25]So there's package roles.

[00:01:27]I feel like some of this is not necessary.

[00:01:31]Sorry, Julius.

[00:01:32]I think almost all of this is unnecessary context.

[00:01:36]These are not, these are fine.

[00:01:41]I would argue if Julius is listening, I doubt he is, but if he is, I would argue this is the only thing that you need in your agents file.

[00:01:49]Maybe this.

[00:01:53]Maybe if, if, I don't know if it has like a folder with reference repositories or something probably that goes in the, and you claude.md them as well.

[00:02:07]Let's see.

[00:02:09]apps now these are the, let's look git ignore Mike it does not look like Julius has adopted your pattern or at least it's not evident to me.

[00:02:29]My pattern being? clone the repo locally.

[00:02:33]As they say, not my problem.

[00:02:43]Well, anyway, let's look at some code.

[00:02:45]Let's look in a shared source.

[00:02:52]I don't know.

[00:02:54]What's drainable worker do drainable worker is a queue based worker that exposes a drain effect wraps the common queue unbounded plus effect forever pattern and adds a signal that resolves on the quque is empty and the current item has finished processing.

[00:03:18]Okay.

[00:03:21]It feels like, okay, wait, let's look at this.

[00:03:27]Makes a queue makes a deferred, Wait.

[00:03:40]Immediately complete deferred.

[00:03:46]Okay.

[00:03:47]Now I'm going to defer judgment for one minute.

[00:03:52]As a state ref.

[00:03:58]And finalizer to shut down the queue, which is fine.

[00:04:05]State through finish one modifies the state by checking how many outstanding there are, I guess, outstanding tasks.

[00:04:20]and if remaining is zero returns the idle deferred, otherwise returns null.

[00:04:33]Oh, probably he wanted a latch instead of at the idle, deferred.

[00:04:40]I dunno, just say.

[00:05:04]It seems like a counter, outstanding that counts the amount of current pending items.

[00:05:11]And then idle is just the third that completes when there are no entry outstanding.

[00:05:18]So probably that would have been like a latch.

[00:05:21]Right.

[00:05:23]And the other way it's kind of rolling.

[00:05:25]Yeah.

[00:05:29]And that the third completes only when there are no entries because we saw before that completed at the end of the finish one.

[00:05:38]It completed that if it was idle node, right?

[00:05:42]Yeah.

[00:05:43]This is a good case to use STM actually, because all of this is going to be unsynchronized.

[00:05:51]And I have race conditions all over the place.

[00:05:58]But if the whole purpose of this is just to drain a queue or to be able to wait for draining a queue.

[00:06:05]And this is before having a signal, a signal where the, when the queue gets to zero.

[00:06:11]That's the point.

[00:06:13]Right.

[00:06:14]It's not easy to do with a normal queue.

[00:06:17]Right.

[00:06:19]Very easy to do with a transactional queue.

[00:06:26]You heard it here first, folks.

[00:06:28]A good use case for STM right here.

[00:06:34]Julius, if you're listening STM.

[00:06:38]Yeah, I'd say STM, a simple as the TX queue.

[00:06:43]And then your, your idle check simply becomes a size check with a retry with an STM retry.

[00:06:53]And it will automatically give you a signal when, when the size gets to zero.

[00:06:59]Create a PR for it.

[00:07:02]We could.

[00:07:03]Fair enough.

[00:07:04]We could retry T3 code to do the PR.

[00:07:08]That would be fun.

[00:07:09]That would be fun.

[00:07:12]Except we use neither, neither Codex nor a Claude code.

[00:07:16]So yeah, I'm an, we're all, as far as I'm aware, we're all Open Code enjoyers, except for Tim, who's currently a Clanka enjoyer.

[00:07:27]But still uses open code and no, I think actually he integrated Clanka into Lalph now too.

[00:07:35]I've taken state idle and then this just waits.

[00:07:41]And this idle check would just become your STM retry loop.

[00:07:44]Right. Yeah.

[00:07:49]Plus the state could also be a Tx ref.

[00:07:53]So the whole set of changes is transactional.

[00:07:57]Maybe we will make a PR.

[00:07:58]Maybe I'll do that today.

[00:07:59]And Mike can check my work.

[00:08:03]You folks can watch in real time.

[00:08:04]Like, what is the rule for when, when you need to take an STM and when, when, when is it correct to what's the word I'm looking for?

[00:08:21]Hang on.

[00:08:22]I'll show you.

[00:08:24]I know this is really tiny.

[00:08:25]Give me one second.

[00:08:27]Let's go back in here.

[00:08:35]When is it correct to wrap?

[00:08:37]At what boundary do you do that with your STM?

[00:08:43]What's that?

[00:08:44]When do you wrap the STM with the with the transaction signal or atomically or whatever it's called?

[00:08:52]When you create a Tx ref This is the effect that creates a Tx ref and requires a transaction.

[00:09:07]If you do this.

[00:09:13]Right.

[00:09:13]You get your Tx ref.

[00:09:15]How?

[00:09:16]Like, how do you know, like similar to like I'm thinking of trans like providing the transaction similar to like scoped, right?

[00:09:23]Like so how do where do how do I know.

[00:09:25]a good question for the audience and also for me is like, how do you know what the transaction boundary is?

[00:09:32]Like what's the rule of thumb there?

[00:09:35]There's no real rule of thumb there.

[00:09:37]It's totally dependent on business logic.

[00:09:40]So in this case, the, the scope of a transaction is the scope of the retry.

[00:09:51]Got it.

[00:09:52]That makes more sense.

[00:09:54]So you basically let it bubble up.

[00:09:57]It's like database transactions.

[00:10:01]When do you make a database transaction?

[00:10:02]Depends.

[00:10:04]Right.

[00:10:04]So like the case of, in the case of like the, the T3 code example, if we take that more concretely, it would be correct to create the queue in the ref upfront as small transactions, and then later on down the road, when you're doing your idol check, you would do like, you know, your whatever, and you'd say, just for the sake of argument, you'd have this and you'd say like, And the current count is just the getting the size of the queue.

[00:11:20]Let me get rid of this business here.

[00:11:31]This would be the scope of the transaction here, this whole thing.

[00:11:34]So you would wrap this whole thing.

[00:11:41]That is to get the signal, yes.

[00:11:45]That said, if you wanted to compose these into other things, then you would have to extract the inner check.

[00:12:05]The idea here is that the scope of the thing that you want to retry as part of your transaction is your boundary for where you market as a transaction, like where you provide the transaction.

[00:12:18]Whatever happens inside the transaction is atomic, whatever happens outside it's not.

[00:12:27]So if I wanted to, for example, idle check and do some other operations within the same transaction, this would not be okay.

[00:12:40]Because you would have to separate transactions.

[00:12:45]Unless you decide that that transaction self-compose.

[00:12:50]So if you have an above transaction, it automatically retries children's transactions, which I'm not sure it's a good kind of an implicit pattern.

[00:13:09]Yeah, I kind of like that it feels the same as scope in some regards here.

[00:13:19]Where like the boundary of your, you have to decide what the boundary of the transaction is similar to what, like you have to decide what the boundary of like a scoped operation is.

[00:13:33]So there's like some degree of familiarity here.

[00:13:36]Maybe I will make a PR and see if I can make this into something that uses STM.

[00:13:41]Cleans this up a little bit for Julius.

[00:13:45]What else is in here?

[00:13:50]Yeah, so I'm in the net module now and I was just looking at this tri-reserve port method.

[00:13:56]So yeah, for those, for this, I thought this was kind of a neat use of callback, but the idea here being that effect.callback allows you to wrap async operations into an effect.

[00:14:16]So you get like a function that has access to a resume method.

[00:14:23]So in here, it looks like a server's created, they have a settled callback, and if the server actually settles, then they resume.

[00:14:34]And once you resume, the callback exits.

[00:14:38]So if you run an effect.callback and you never call resume, then this effect would never finish unless it's interrupted.

[00:14:48]Unwrap the server, then if there's an error, the settle method is called with a failure effect.

[00:14:59]If listening is successful, it looks like settle is called.

[00:15:08]It looks like settle is called with the resolved address, I guess.

[00:15:16]And then effect.callback is also nice because if you have a callback that is currently running and gets interrupted, you kind of might want a way to like clean up stuff that's happening inside the callback.

[00:15:33]And whatever you return from an effect.callback, it's kind of like, I really hate this comparison, but for folks coming from React, it's similar to like a useEffect where you can like do stuff and then have a thing that you return at the end that does clean up.

[00:15:50]It's similar in spirit here, but this effect that you return at the end would be called if the callback is interrupted.

[00:16:00]So like if nothing has called resume, and this callback is still running, and it gets interrupted, then this would get called.

[00:16:08]And in this case, they're closing the server.

[00:16:12]So I guess this service is primarily for network operations.

[00:16:18]Effect equals use effect, gotcha.

[00:16:20]We need the Johannes meme on like a one-click binding, the Drake use effect meme that Johannes had created a while back.

[00:16:35]Net service is a service for startup networking helpers.

[00:16:44]Is this not the same?

[00:16:48]I guess not.

[00:16:50]Can listen on host.

[00:16:56]I guess this is like low-level networking node net wrappers.

[00:17:08]This is a cool little example of zipwith.

[00:17:12]Is port available on loopback?

[00:17:16]Can listen on local host or on the IPv4 loopback and on the IPv6 loopback?

[00:17:23]And if both are true, then zipwith gives you the result of both of these and you can do something with them.

[00:17:32]Cool.

[00:17:33]It's a nice little service.

[00:17:35]Would callback only be useful in server side?

[00:17:38]Would callback, sorry, would effect.callback be useful in server side events if I'm only expecting a specific event for processing versus just using stream?

[00:17:52]They are unrelated, right?

[00:17:55]I think callback is most useful for integrating with native JavaScript that is callback-based.

[00:18:12]So if your server side events, however you're listening to them, if it's like, you know, an event emitter or something like that, that is only called once, then sure.

[00:18:21]But server side events are like typically multi-shot type things.

[00:18:29]So if effect.callback is a single shot thing, if you're doing something that's multi-shot, stream is probably better.

[00:18:38]So in streams, because streams are multi-shot, they can integrate nicely with multi-shot event emitters.

[00:18:49]But I think that there's a callback push.

[00:18:55]Is there like a.

[00:19:02]I think they've been unified into the same.

[00:19:07]Maybe.

[00:19:10]Anyway, this is the idea.

[00:19:14]It's not like a perfect example of this, but like you could.

[00:19:24]You could use.

[00:19:26]Sorry, I was reading all of these new properties on here.

[00:19:31]So you have to use the queue methods.

[00:19:38]New event. You would do something like this.

[00:19:52]And the idea being here is now this is like a multi-shot situation.

[00:19:56]Like the stream can keep emitting these events because it has it like you would be offering them into a queue under the hood.

[00:20:04]With effect dot callback.

[00:20:05]It's a single shot resumption.

[00:20:07]Like it's a it's a it's something that's meant to like wait until some async op is finished.

[00:20:13]And then you call resume with that value of with the effect that you want to resume with.

[00:20:20]Hopefully that makes sense.

[00:20:28]There's no effect imports in here, so we're going to just not not go in there.

[00:20:34]schema JSON.

[00:20:38]This has only effect imported so we can look at this module.

[00:20:43]It doesn't look like there's anything interesting here, though.

[00:20:46]And nothing interesting.

[00:20:49]All right, let's get out of shared.

[00:20:50]Let's go to the apps.

[00:20:53]Yeah, let's go to the server.

[00:20:55]Let's look at.

[00:20:58]I don't know, Mike, pick a pick a thing.

[00:21:03]Checkpointing.

[00:21:04]Checkpointing sounds good.

[00:21:07]Well, layers and services.

[00:21:11]Julius, so organized.

[00:21:13]Let's look at services.

[00:21:15]Checkpoint store.

[00:21:17]The checkpoint store is a repository interface for file system backed workspace checkpoints owns get owns hidden get ref checkpoint capture restore and if computation for a workspace thread timeline.

[00:21:29]It does not store user facing checkpoint metadata and does not coordinate provider conversation rollback. Okay.

[00:21:37]This is a this is a sergeant Dokes moment right here.

[00:21:40]These these these four lines, Sergeant Dokes.

[00:21:43]I'm looking at I'm looking at you, Julius.

[00:21:54]Surprised motherfucker.

[00:21:56]It looks like that's just the interface.

[00:21:58]Let's look at the actual implementation.

[00:22:01]Okay, so and if you don't know who Sergeant Dokes is you had a bad life.

[00:22:09]Watch Dexter.

[00:22:10]Watch Dexter and then understand that the meme is related to AI generated code.

[00:22:18]So make checkpoint store looks like it gets some platform services get core.

[00:22:24]This is cool.

[00:22:28]Look at this real quick.

[00:22:29]I know I'm like a little ADD at the moment, but let's just look at this.

[00:22:35]I want to see if Julius is using my beautiful new child process module.

[00:22:41]He is.

[00:22:43]He is.

[00:22:46]I spent quite a bit of time on this module.

[00:22:49]So I'm happy.

[00:22:50]I'm happy that people are getting used out of it.

[00:22:53]The old command module is was not good.

[00:23:00]create trace to monitor.

[00:23:02]No, I want to look at the service constructor.

[00:23:07]Make it core.

[00:23:13]Spawner.

[00:23:14]We've got an execute method.

[00:23:19]There's a lot of stuff going on here.

[00:23:21]This is cool.

[00:23:24]Command spawner.

[00:23:24]Spawn it makes the child process.

[00:23:28]Object with all the stuff it gets from spawn.

[00:23:36]Yeah, I think one of the things that I'm most happy about is the ability to actually like properly collect output from different streams now.

[00:23:46]Which is kind of nice.

[00:23:50]Wasn't really possible in an easy manner before.

[00:23:54]Actually really wasn't possible because of race conditions.

[00:23:59]This is very cool.

[00:24:02]This is a very involved get integration.

[00:24:06]I like it.

[00:24:07]All right.

[00:24:08]Back to the checkpoint store.

[00:24:11]It looks like it's primarily just using the delegating some commands to get to get checkpoints and other information.

[00:24:21]I wonder if any of these are also then decoding with schema.

[00:24:26]Capture checkpoint.

[00:24:30]Make a temp directory.

[00:24:33]Isn't there a make temp directory scoped?

[00:24:37]Unless he's doing something else here.

[00:24:45]I thought that there was a... I am switching to another screen, but you don't need to see what I'm doing.

[00:24:52]Give me one sec.

[00:24:56]Are they using the file system module from us or No, there is.

[00:25:01]I think so, yes.

[00:25:03]Make temp directory.

[00:25:07]It's not like a huge win here, but you could just use make temp directory scoped here.

[00:25:16]And avoid having to do the cleanup yourself here.

[00:25:24]Avoid the whole acquire release here.

[00:25:27]Make temp directory scoped and then flat map that directly into this and then wrap it all with effect.scoped.

[00:25:39]Is there any schema stuff going on?

[00:25:48]Let me see.

[00:25:52]Sure why you would have it here.

[00:25:56]I don't know.

[00:25:56]I'm just looking at what's going on in here.

[00:26:00]It's cool though.

[00:26:00]This is a very nicely designed service.

[00:26:04]A lot of these could probably be converted to effect.fn with span names to get better stack traces and also to integrate with tracing later if that was desired.

[00:26:20]It's a small perf improvement, but it adds up over time to not recreate these generator objects every single time these methods are called.

[00:26:30]And when you have lots of them being created all the time like this as part of calling a function.

[00:26:36]Getting telemetry out of the box is also a huge win.

[00:26:40]I think even less than that, getting the stack traces is a huge win.

[00:26:44]Being able to see where something was called.

[00:26:48]I got a lot of PRs to make to the T3 code.

[00:26:50]This is crazy.

[00:26:53]But according to the contributing.md You cannot.

[00:26:58]My PRs will not be accepted.

[00:27:02]Alright, one more thing we can look at and then we'll probably call it.

[00:27:07]Let's look at persistence.

[00:27:12]Wow, there's a lot of stuff going on in here.

[00:27:15]Let's look at projection state maybe.

[00:27:19]Is there anything interesting here?

[00:27:21]Make the repository.

[00:27:28]This upserts.

[00:27:36]Making very heavy use of effect SQL, which is cool.

[00:27:44]It's like literally going all in on effect.

[00:27:48]Yeah, this is probably one of the best examples I've seen of effect v4 being used in production in an open source app.

[00:28:00]That said, if you have better examples, send them to me.

[00:28:05]This is high quality code.

[00:28:08]You can tell that some of it's been generated with AI and still is very high quality.

[00:28:13]Aside from a few small things that could be improved with just lint rules or the effect LSP running on checks.

[00:28:26]But yeah, this is a very high quality code base from what I've seen so far.

[00:28:31]I like how Julius specifically said don't open issues or PRs and there's 337 issues and 234 open PRs.

[00:28:39]Because nobody reads code contributing.md.

[00:28:40]Yeah, nobody but me apparently.

[00:28:46]Probably you should have said in the readme as a first line, please open PRs and issues.

[00:28:52]Please, please do not contribute.

[00:28:56]Please contribute so people would do the opposite.

[00:29:04]Anyway, yeah, high quality code base.

[00:29:07]Go take a look.

[00:29:10]Don't contribute.

[00:29:14]Unless you have something worthy to contribute, I guess.

[00:29:20]Yeah, T3 code looks like very high quality code.

[00:29:23]I'm sure that in Open Code also there are reasons and rationales why they took the approach that they did.

[00:29:29]There may be better ways to do things, but it's exciting to see effect getting adopted there as well.

[00:29:34]I'm sure that over time we'll see more and more effect in that code base.

[00:29:44]But yeah, this is it's cool to see effect in some of these larger open source projects.