studying compilers every day until i land a compiler role (day 191)

Added: 2026-05-05

[00:00:01]And we're live. Okay.

[00:00:03]Um hello all, hello world. This is day 191 of studying compilers every day until I land a compiler role.

[00:00:09]Um sorry about yesterday. I I might have forgotten to do homework. So, I got that done and yeah, life is good. But yeah, that's why I didn't stream yesterday.

[00:00:20]Um the day before that we started adding function prototypes and it turned out that was a little more difficult than we thought it would be. Um it actually takes a decent amount of plumbing. So, we ended up only doing like about half of the work maybe or maybe like a third of it.

[00:00:34]Um this time hopefully we can get a larger portion done.

[00:00:38]I'm not sure how much because I'm a little bit tired. So, I might have to take a later nap. So, we'll we'll see what happens, but yeah.

[00:00:47]It's going to be a good time.

[00:00:50]So, yeah. Let's let's get it right into right into tapping away.

[00:01:01]Also, I have food. I have a bagel in front of me. So, I will be munching on that in the meantime as well cuz I'm also a little bit hungry.

[00:01:09]Yeah, I'm I'm a little big and greedy.

[00:01:11]So, yeah.

[00:01:14]Uh get log. What were we working on?

[00:01:18]Mhm.

[00:01:21]We did ST to HR. We need to do HR to MR in some capacity now.

[00:01:30]Um okay.

[00:01:34]Mhm.

[00:01:40]We did a lot of it already, I think.

[00:01:43]Um the big problem is once again we don't have an MIR construct for uh for a prototype.

[00:01:52]So, that's going to cause some problems, but we'll we'll re work Yeah.

[00:01:56]We'll worry about that in a second.

[00:01:59]Um mhm.

[00:02:04]Just because I'm curious, I'm going to look at the back end real quick cuz I'm going to try and figure out what we need for MR to LR first.

[00:02:12]Um if we need a lot for this then I will scope um I'll scope today's stream to be a little bit shorter, but um if it turns out to be pretty simple, um then I'll probably I'll probably try to get everything done in one sitting.

[00:02:30]Uh what even goes in here?

[00:02:34]We do those passes.

[00:02:37]I guess mhm.

[00:02:42]What is generate trees again?

[00:02:47]Uh Okay, so we're we're going for function.

[00:02:55]Mhm.

[00:03:00]I guess we don't really need to do anything.

[00:03:02]We might have to like change what a function is in MIR and then deal with the downstream effects, but I don't think we like really care a lot beyond that point.

[00:03:16]Yeah, like as long as there's something for like a call to point to, um I think that should be fine.

[00:03:24]So, I'm I think that like that actually cuts out a decent amount of the work that we need to do.

[00:03:31]Um at least in the back end.

[00:03:37]Mhm.

[00:03:39]I don't even think we need to make these functions here because we're like re we're like de-control flow graphing the IR, right?

[00:03:51]So, if we look in here in our tree gen, if we look at the calls that we have, it's like instruction call wherever that lives.

[00:04:04]Please, hello.

[00:04:08]There we are.

[00:04:10]Yeah, so this just like this literally um I I I.

[00:04:17]Uh this just takes like a this takes a name, which is a string.

[00:04:24]Oh, bruh.

[00:04:26]Oh my god.

[00:04:29]The name is a new one.

[00:04:33]Um yeah. So, since it just takes a name, I think we can kind of we can kind of just like dissolve the whole function prototype thing in the back end and we should be fine.

[00:04:42]Uh we still need it in like MIR and we need to figure out HR to MR, but I think that's about it.

[00:04:48]Um that's a pretty good state to be in, I think.

[00:04:55]So, let's let's do MR first and then MR to um Yeah, let's do MR and then HR to MR should slide into place pretty easily.

[00:05:06]Um and then from there, I think MR to LR should be pretty quick and then we're good to go.

[00:05:16]Also, this bagel is this bagel is possibly good.

[00:05:21]I'm kind of big and greedy right now.

[00:05:29]Okay.

[00:05:33]So, have the header on the right, the body on the left.

[00:05:37]This whole thing is kind of messy. We're going to need to extend function again.

[00:05:49]Uh what's going to cause us?

[00:05:52]Yeah, I'm I'm eating. Hopefully you're doing all right.

[00:06:03]All right. So, we go back to Godbolt for reference.

[00:06:07]Uh let's see what LLVM calls its function prototype again.

[00:06:19]I declare. That's what we want to do.

[00:06:22]I opened my first live. Nice. Um how'd it go?

[00:06:30]Okay, enough of me eating.

[00:06:32]Um I'm going to lock in now. That That was that was a pretty funny experience.

[00:06:39]Okay.

[00:06:44]Um so, we have function definition.

[00:06:48]It should extend public function.

[00:06:53]Class function.

[00:06:58]We want to do something with that.

[00:07:06]Let's rename that.

[00:07:10]Um and then we also want function declaration, I think, is what we call it. Declare.

[00:07:17]Let's actually just yank that.

[00:07:22]We just do that.

[00:07:28]Okay.

[00:07:29]So, we can kind of keep most of this.

[00:07:34]Uh we definitely want a name regardless.

[00:07:40]I think Yeah, the name is probably the only Actually, what happens if I get rid of the parameter?

[00:07:48]I guess that also works.

[00:07:53]I don't think we need much else than that here. So, we could probably I'm in live right now on this account.

[00:08:01]Dumb. Well, um it it that's that is a choice.

[00:08:08]Um yeah, I mean if you're if you're live, I would implore you to maybe not re-stream my stuff. I don't I don't know if that's what you're saying, but yeah.

[00:08:22]Um okay. Let's let's lock in.

[00:08:31]Um what what what is wrong with this? We need to make a virtual.

[00:08:43]I guess this also means we have to like mess with a lot of our uh we have to mess with a lot of our other passes as well cuz they'll use function and we have something that's different from function now, which is going to be messy.

[00:09:01]Um this is fine. This is fine.

[00:09:06]I think they probably all have a type at least.

[00:09:14]Mhm.

[00:09:19]I guess not necessarily, huh? Or just to keep things consistent, I think we should do it like this.

[00:09:26]And then we should do like that.

[00:09:34]We can do that.

[00:09:37]And this needs to override.

[00:09:44]And we should yank that. We can probably just steal most of this.

[00:09:51]Yeah, so type, name, parameters. Let's get rid of basic block stuff cuz we don't have basic blocks in this.

[00:09:57]This is kind of just a name placeholder.

[00:10:01]Um so we can keep all of that. I think we can just do ink that as well.

[00:10:14]Okay.

[00:10:16]So that's all good. Now let's throw this slop in here as well.

[00:10:22]Uh we also need virtual.

[00:10:25]Just uh we need a destructor.

[00:10:29]Uh what language is this? This is C++.

[00:10:37]I don't know. Do that.

[00:10:43]Wait, what?

[00:10:52]What do you mean override? We're not overriding anything. Right?

[00:10:58]Public. Whoops. There we go. Much better.

[00:11:04]Um all right. Let's Let's keep Let's keep throwing stuff at the wall here.

[00:11:10]Um Let's make this declaration.

[00:11:24]And here we need to fix those up again.

[00:11:33]Do that.

[00:11:36]Uh what Uh do you need to get Uh do you need to be really good at competitive programming to get into compilers? I have never done competitive programming.

[00:11:43]Um if that's any consonance.

[00:11:50]Uh what happened here?

[00:11:57]Why is that Wait, why is this broken?

[00:12:05]Wait, what?

[00:12:09]Oh.

[00:12:10]I see.

[00:12:12]Okay, that That does make a mess. Okay.

[00:12:16]Um hmm.

[00:12:20]This is a function declaration, so that should be fine. Right?

[00:12:26]Oh, wait.

[00:12:31]Let's change that.

[00:12:36]Um okay. Here we need to We need to make a mess, but we'll do it. Math blocks in C++ will suffice. Like Yes, insofar as like that will do for everything, right?

[00:12:45]Like I don't know. I don't really think the question is particularly great cuz like I don't know. I don't I don't think it's something you can like really reduce to like a sec like a list of like qualities, right? Like There There is more to it than just like do you know XYZ things?

[00:13:06]Uh but what do I know? I'm >> [snorts] >> I'm not the one with a job here, so like Yeah.

[00:13:14]Uh let's let's yank all of that.

[00:13:20]Uh we can probably just steal some of these slowly.

[00:13:31]Um get name.

[00:13:34]We can just yank that as well. We can yank that even.

[00:13:49]There we go.

[00:13:51]Okay, the two string we can kind of yank from above as well, to be honest. We just have to We can just like be a little bit looser with it, I'm fairly sure.

[00:14:04]Uh we don't need that, I'm fairly sure.

[00:14:09]Or actually no, we do kind of need that.

[00:14:13]Wait, no we don't.

[00:14:19]Yeah, we don't We definitely don't need the numbers.

[00:14:24]Right? Cuz we can just do I32 I32. Okay, yeah.

[00:14:28]We can do it like that then.

[00:14:30]We can get rid of that.

[00:14:35]Um oh, I guess we might want that anyway, huh? Or hmm.

[00:14:42]The visitor doesn't make sense here, so we That's kind of fine, actually.

[00:14:47]Uh we can change this up real quick. So this should be declare.

[00:14:51]And get type and then we want to assemble that.

[00:14:59]Uh we can do iter All right, how do we do this?

[00:15:06]Iter get and then we want like get type.

[00:15:13]Right, what's wrong with this? Oh, yeah, yeah.

[00:15:20]And then we can do We can do this ugly thing again.

[00:15:29]I don't know why.

[00:15:31]I feel like there's a real I feel like there's a reason that I need to do it this ugly way.

[00:15:36]What type is this again? Value of unique pointer.

[00:15:40]So we want iter, we want arrow forget.

[00:15:42]Okay, yeah. I guess that makes sense.

[00:15:45]We could also just like do deref iter arrow get type, but I don't know. It's kind of It's kind of just doomed at least in that regard.

[00:15:56]Um here I believe we can just call it at that.

[00:16:01]We don't need the body at all.

[00:16:07]Uh We can do that.

[00:16:12]Okay.

[00:16:15]Uh let's change surrounding quotes to single quotes for character.

[00:16:21]Um now what else do we need to change?

[00:16:23]We need to do this. Oh, man.

[00:16:26]Um Hmm.

[00:16:34]Yeah, maybe we should put type as a Hmm.

[00:16:41]That might be smart, huh?

[00:16:43]I guess we could also like move name around as well. Uh ger.

[00:16:50]This is really dumb.

[00:16:52]I'm not sure why I separated out like this. I might I might flatten it down in the future, but that will We'll worry about that in the future, I I guess.

[00:17:02]I think that's It's a very regrettable choice, but we will We will figure it out why it's regrettable later.

[00:17:10]Um Hmm.

[00:17:21]Yeah, let's just let's just move this up.

[00:17:27]Let's just paste that there. Let's paste that there.

[00:17:32]We can do that.

[00:17:36]This is not a regrettable choice at all.

[00:17:40]Okay.

[00:17:41]So that kind of should fix all of the MIR stuff, I think.

[00:17:47]Uh we can find out when something breaks that it breaks.

[00:17:53]I don't think instruction is really affected. Maybe like call will change.

[00:18:00]I guess not really. It still takes a Uh wait.

[00:18:06]No, it just takes a function pointer, so that should be fine.

[00:18:09]Um two string had to change. I think the rest of this is also fine.

[00:18:13]We might have to change some things here and there. Yeah.

[00:18:19]Um oh, man.

[00:18:25]So let's do Oh, no.

[00:18:28]Okay, we're going to fix the We're going to fix the passes later cuz this is I fear this is going to be very annoying to deal with.

[00:18:39]Actually, this one should probably be easy.

[00:18:45]Uh so we want function or fun def or function declaration or I don't know.

[00:18:53]definition So we can just do All right.

[00:19:02]We can dynamic cast to MIR function.

[00:19:07]Oh, yeah, yeah.

[00:19:13]We'll do that.

[00:19:28]And then uh And then we can just replace this with definition.

[00:19:40]I guess.

[00:19:44]What's wrong with that?

[00:19:53]Whoops. Okay, can do that.

[00:20:02]Okay, nice.

[00:20:05]Oh man, we >> [sighs] >> we might have opened Pandora's Box with this.

[00:20:11]This is kind of hell.

[00:20:14]Um Okay.

[00:20:20]Let's do that kind of thing here as well, I think.

[00:20:25]You can just yank this as well.

[00:20:35]Then we want after I get here instead.

[00:20:39]We can just continue if it's not a definition.

[00:20:44]Um Oh man.

[00:20:50]I guess we could probably split this up by like function as well, right?

[00:20:57]Yeah, actually that might be smart. Sort of like what we had here.

[00:21:05]Yeah, let's let's refactor it to do that while we're at it. I think that would be smart.

[00:21:14]Uh what's good is this?

[00:21:23]Uh Okay, that's that's a I think I want to handle that refactor at a future time along with a lot of other things. So, we'll just leave that as is. Let's just continue with this.

[00:21:36]Um and then instead of that, we can just do uh definition I guess.

[00:21:46]Yeah, we can do it like that.

[00:21:51]Um okay.

[00:21:59]All right, that's all good. I'm sure there will be no problems in here whatsoever.

[00:22:06]Oh man.

[00:22:13]Um parallel copies Let's just Let's just go back here and yank what we had once again.

[00:22:37]Um okay.

[00:22:44]And that's all fine, I guess.

[00:22:50]Any problems here? Yes, many problems.

[00:23:00]Yeah, this we can yank from here again.

[00:23:02]Yeah, this is just a lot of actually just a lot of boilerplate.

[00:23:17]Okay.

[00:23:20]What's wrong with this now?

[00:23:26]Wait, what?

[00:23:46]that we need to fix Oh no.

[00:23:56]I'm so scared.

[00:24:02]Um we might just have to narrow We might have to do a little bit of narrowing.

[00:24:08]Um Oh man.

[00:24:13]>> [sighs] >> Okay.

[00:24:14]I'm I'm really starting to regret my choices about now.

[00:24:20]Uh what is wrong with this though? This should be fine.

[00:24:29]Uh this should be continue instead.

[00:24:37]Okay, so we did need ranges.

[00:24:40]What?

[00:24:47]We did it We did need What was it?

[00:24:54]Yeah, okay. I was just being pranked.

[00:24:56]That's evil.

[00:25:01]What did I need here as well?

[00:25:03]I guess insert parallel has instruction, right?

[00:25:08]No, wait, what?

[00:25:12]This Wait, what?

[00:25:18]Surely this needs it.

[00:25:24]Yeah, we're just not going to mess with headers when there's errors, I guess.

[00:25:28]Oh mem to reg. Oh, that's not going to be fun.

[00:25:34]Uh let's do Let's do function definition.

[00:25:43]Uh what's good?

[00:25:49]Uh let's throw in the usual boilerplate again.

[00:26:02]Yeah, I wish there was a better way to Maybe a macro to define that would be helpful, but oh well.

[00:26:14]Um then here And do that. Everything's good.

[00:26:25]We are happy until we aren't happy. Then we'll worry about it later.

[00:26:32]Is this fine? This is not fine.

[00:26:35]We're going to do the same thing again.

[00:26:37]We're going to take the Yeah, I'm I'm like already going insane.

[00:26:46]It was kind of dumb for me to not just like support this sooner, I think.

[00:27:11]We can do that.

[00:27:14]Okay.

[00:27:17]Uh what's good, Grizzly?

[00:27:25]Uh we need to do the same thing again.

[00:27:26]Okay.

[00:27:29]Um Man, okay.

[00:27:39]Or maybe we could What even is get functions return?

[00:27:44]It's a ref to that. We could just like make a list.

[00:27:48]But I feel like that might that might suck a little bit. Or like a custom iterator.

[00:27:56]Hm.

[00:27:58]Yeah, maybe that Maybe that could be interesting.

[00:28:02]But I don't know. We'll We'll worry about that once we get there.

[00:28:08]For now, let's just make all this work.

[00:28:21]Okay, that's all changed.

[00:28:23]I think all of this should be fine.

[00:28:27]There's something wrong here.

[00:28:30]Oh yeah, okay. Um Yeah, these we might need to change from function to like the other type function that we have.

[00:28:54]Do that as well.

[00:28:57]Surely this does not cause issues whatsoever.

[00:29:07]Right?

[00:29:08]Uh what's good, Panda?

[00:29:15]Uh how long have you been doing this?

[00:29:16]What do you mean by doing?

[00:29:19]I guess like I don't know.

[00:29:21]>> [laughter] >> It's a little hard to define clearly, at least.

[00:29:27]Um okay, so we want definition again.

[00:29:38]Okay, nice.

[00:29:42]What else do we need? I think I think that cleans up most of this. The passes are fine.

[00:29:55]Um Hmm.

[00:30:04]We should make like a pass register thing.

[00:30:09]191 days obviously that's that's so real actually.

[00:30:13]I I imagine that's not the answer that we wanted, but I guess that is an answer.

[00:30:22]Um Yeah, there's stuff that's broken here.

[00:30:34]This is the only place where that happens.

[00:30:38]We'll worry about that in a second. For now let's let's take a step back.

[00:30:46]Except that.

[00:30:50]Uh update MIR to include prototype.

[00:30:56]Let's call it declare.

[00:30:59]Right?

[00:31:00]Yeah, we're we're working off of what what LLVM called it.

[00:31:12]Uh can you tell us why you don't code in Java cuz I don't want to use Java.

[00:31:16]I would very much rather use a lot of other things that are not Java.

[00:31:21]So yeah.

[00:31:24]Let's Yeah, I will not be doing that.

[00:31:54]Okay.

[00:32:01]Um okay, let's let's see. So HR to MIR is now where we're at.

[00:32:08]Um a lot of things have changed here now.

[00:32:13]Oh man.

[00:32:14]>> [sighs and gasps] >> This is this was such a bad idea. I don't know why I did this.

[00:32:24]Um Okay, let's I think we did a dynamic casting somewhere here as well. We can youink.

[00:32:38]We can do that maybe or we can even just do that.

[00:32:42]No, okay. I guess I guess we need the HR name space there.

[00:32:49]Um So then if prototype we can do something.

[00:32:59]Just in case we'll wrap another dynamic cast.

[00:33:10]Um let's youink all of that.

[00:33:21]Um add both. That is a good idea. I'll do that in a second. Uh let me get let me get a little bit more of this done first.

[00:33:31]What's wrong here? Oh, this needs to be arrow now.

[00:33:38]Um let's continue let's continue doing this.

[00:34:01]Oh my god, I cannot I cannot type right now.

[00:34:12]Um let's see.

[00:34:14]>> [sighs] >> What is wrong with this? Oh, function def definition.

[00:34:31]Okay, and then we can we can kind of just youink all of this and then we can go from there.

[00:34:42]So let's paste that up there like that.

[00:34:46]Uh we want that still.

[00:34:50]We do not care about that I'm fairly sure.

[00:34:55]Right?

[00:34:56]Oh, actually we do kind of care.

[00:35:01]Yeah, we still care about this.

[00:35:08]Uh this we do not care about though.

[00:35:16]Yeah.

[00:35:22]Um this should be prototype.

[00:35:32]Uh can I connect on LinkedIn? Go for it.

[00:35:35]Um I haven't checked LinkedIn in a second though. So I mean Oh, wait. I need to make the constructor. Okay, I'll do that in a second. Um Yeah, so that will have type name, params and then it will not have these two.

[00:35:56]Like that I think.

[00:36:00]Uh I don't think we need to do this.

[00:36:02]Yeah, cuz we don't have basic blocks that we need to resolve.

[00:36:08]Uh we need to update the HIR stuff real quick though.

[00:36:12]Um I don't think a lot else needs to change though. This is this has been surprisingly peaceful.

[00:36:30]Uh let's go back to middle end MIR.

[00:36:34]What am I missing?

[00:36:39]Constructor. Too peaceful? No, not really. I'm I'm quite content with how peaceful it is actually.

[00:36:46]I'm very happy that it's not more aggressive right now.

[00:36:53]Uh did I forget to Yeah, okay. I just completely forgot to add a constructor.

[00:36:56]That's really funny.

[00:37:01]Um We do that. Type name, parameters and then we don't need that.

[00:37:09]And we don't need that.

[00:37:18]Um Yeah, okay. So now we can youink that.

[00:37:28]Where Where the the hell am I here?

[00:37:31]Um Where is declaration?

[00:37:38]Down here. There we go.

[00:37:46]Give me his name and then parameters.

[00:37:50]Stud move parameters.

[00:37:55]Right?

[00:37:58]Oh.

[00:38:01]Like that. There we go.

[00:38:03]Okay.

[00:38:06]Wait, what?

[00:38:09]Oh, I forgot to format. Um simplify CFG.

[00:38:19]Let's re-commit that.

[00:38:26]How would I forget the constructor? Lol.

[00:38:32]Okay.

[00:38:35]Um all right. So now prototypes.

[00:38:48]Okay. So now we get to keep Let's make builds. Let's see what's broken right now.

[00:38:56]Uh what?

[00:39:00]My what?

[00:39:05]Um okay, so HIR somewhere here.

[00:39:09]Oh.

[00:39:12]Uh this should have that unless I encoded it incorrectly.

[00:39:19]It appears it should be correct cuz it has that.

[00:39:26]Unless I forgot to implement it in prototype.

[00:39:36]What?

[00:39:45]>> Wait, what?

[00:39:58]They might have just forgotten to implement it, I think.

[00:40:05]Oh, I cannot search like that. Okay. Um Function prototype to string, hello?

[00:40:12]Like it's it's right there.

[00:40:17]What?

[00:40:19]Are we blind or like what?

[00:40:25]Oh, that doesn't make sense.

[00:40:30]It's right here, like I don't understand why this is worked.

[00:40:50]Oh, wait. Uh I need to deref it. So, I need to do like get and then arrow or arrow get.

[00:40:59]Yeah, there we go. Um do you think being a tutor helps with being a CS student? I think it does.

[00:41:05]Um I think it helps you better understand what's happening and I also think it helps you better explain what's happening.

[00:41:11]Um both of which are very important in any industry setting cuz generally speaking you'll be working with people.

[00:41:19]And part of the benefit of that is you will be like sharing ideas with each other, right? So, yeah, that's that's my initial thought at least.

[00:41:29]Um that's not to say strictly necessary, but I think it at least gives you a very good opportunity um to do a little bit more of that internalization.

[00:41:38]Um okay, so now we get to get to look at the back end.

[00:41:43]So, let's actually something we should do.

[00:41:50]More indirection.

[00:41:53]Except I can't type, so there's a typo.

[00:41:56]Which is fine.

[00:42:08]Um Okay.

[00:42:12]I'll play tomorrow. Yep, that sounds like a good plan.

[00:42:17]Um okay, so this is in tree gen, which makes sense. This was the thing that we left as a to-do.

[00:42:24]Um how old are you? I am I am younger than 30 years and I'm older than 20 years.

[00:42:30]I will I will let you make your assumptions off of that.

[00:42:36]Um okay, let's just make this function deck definition.

[00:42:46]Oh, what's good, hacker? Good to see you.

[00:42:49]Or pack or momo momo, I I think you I think you go by momo, right?

[00:42:54]Oh, yeah. Good to see you.

[00:43:00]Um okay, let's Where am I? Start function.

[00:43:07]This should be deck definition, I think.

[00:43:13]Yeah, okay.

[00:43:15]Uh that fixes that problem.

[00:43:18]And then where do we call that on?

[00:43:23]We just not call that?

[00:43:26]Uh okay, that makes sense.

[00:43:28]Now, it's it's been a second.

[00:43:31]Uh 25? No.

[00:43:40]Yeah, you could you could probably put all the numbers in chat, but that's a little bit boring, so.

[00:43:48]Um okay, what we want to do here, I think we want to we should split this up between definitions and declarations.

[00:43:56]Um declarations, we just we don't really need to do anything for actually, I think.

[00:44:05]Um older or younger than 25? Yes.

[00:44:15]Something Not not really. It's just like why?

[00:44:19]Like all all of the things you could possibly ask me about and like the the one that we land on is like age.

[00:44:24]It's like I don't know. May maybe I'm like a little bit entitled to that opinion, but it's like I I don't know. That's like one of the things that like I think is generally better to not let float around, so like eh, I don't know.

[00:44:40]Um Okay, so then if I'll just do definition.

[00:44:53]Let's just dynamic cast to function Oh, we need we need more name spaces.

[00:45:08]Do that. Let's give it.

[00:45:14]This is or this should be dot. Whoops.

[00:45:19]No worries, momo.

[00:45:20]Uh what's good, friend of a gamer?

[00:45:28]Uh also uh welcome, spy.

[00:45:34]Uh what's wrong with this? Am I Oh, this needs to be a pointer.

[00:45:41]Uh and then if not definition, then then you can continue.

[00:45:52]No, it seems they found the Tampermonkey scripts. I mean, you got to like advertise it, right? Like it's not something that I think people generally um I don't think that's something that like people generally have spend time like searching for, right?

[00:46:08]Like Like just because it's on a public site doesn't mean that like people will be looking it up.

[00:46:17]Right? Like I could I could make a website that's public about like rolling an orange competitively or something and it would probably get zero traffic.

[00:46:26]Or it would get plenty of traffic from bots, but like the main Tampermonkey site. Well, even still, right? Like who's like looking for the code specifically on that, right?

[00:46:39]I feel like if you really want something to be visible or if that's something you care about, you probably need to put effort into like advertising it more explicitly.

[00:46:51]Uh so, I want to know how much time you had to be in uh this advance in C++. I see. Um Well, to answer that question, uh it's less than 4 years. I technically took a like C++ intro class in my I think it's like 3 years ago now.

[00:47:08]Um a little bit over 3 years ago, but I didn't like start properly writing like substantive C++ until like a little bit under a year ago, actually.

[00:47:19]So, um I think a lot of this is is just like built up over time, at least. And just through I guess this project mostly, actually.

[00:47:31]Um if we count lines of code in source, um yeah, like we're close to like we're approaching 10K lines of code, which is terrifying to think about.

[00:47:47]Uh okay, let's change this up real quick.

[00:47:50]And give it definition.

[00:47:54]Let's give it that again.

[00:47:59]Uh what's good, Nuresh?

[00:48:01]It's been a second. Hopefully you've been doing all right.

[00:48:09]Um Oh, yeah. Uh what is Rust good or should I avoid it? I think Rust is great. Uh if you have like a reason to use it, like I think it's I think it's great. If you don't have a reason to use it, I still think it's great and you should use it. Um I think it's just really powerful to be able to bracket out like memory related errors in general.

[00:48:30]And the borrow checker is just very good.

[00:48:36]Um How do you debug all that 10K lines? I don't.

[00:48:43]When a when a bug comes up, there's a lot of digging around that occurs.

[00:48:49]Uh what is clock? It's count lines of code.

[00:48:57]20K lines. I guess I guess it's kind of like the Java experience.

[00:49:03]Um let's see how to std vector in.

[00:49:07]I'm not sure what you're asking. If you're talking about like using the stand the std namespace, I think it's fine to like have std prepended. I generally it's like something you want to do so you don't pollute the std namespace.

[00:49:19]Um but I think like um readability-wise, I don't particularly care. I think the verbosity is not bad to have at least.

[00:49:31]Um okay, that's not ideal.

[00:49:36]What the hell?

[00:49:39]What did we break?

[00:49:42]Specify what you're using.

[00:49:47]No, uh using stood necessarily says that like the current name space is the stood name space. So, polluting that is bad.

[00:49:56]Uh why is your code just fold? If you're talking about these like line breaks, um it's the I my formatter enforces uh horizontal spacing. So, everything is less than 80 characters of width.

[00:50:07]Which I believe is counted down here in the it's hidden by my camera.

[00:50:12]It's counted down here in this corner.

[00:50:15]Um it's generally good practice to not have your code like drift off too far. Um and it's also very useful if I have it like split screen, for instance.

[00:50:24]Um cuz then if it gets like past this, then you have a horizontal scroll bar, and nobody likes that.

[00:50:37]Okay. Um let's go debugging.

[00:50:41]Lines of code is a terrible measure, yeah. Uh it is definitely not a great um I don't think it's a great metric, but um it's at least a metric.

[00:50:52]100 characters? I think 80 is a good number at least. It if it's well on my screen.

[00:50:56]It it works on my computer.

[00:51:04]Wouldn't adding the using stood two pull, etc. be easier? Um possibly, but like I don't know. I don't think it's enough of a difference to really matter. I think it's good to specify that some that things come from the standard library.

[00:51:20]Um there are some things where I like make an exception, cuz like back end is like truly miserable.

[00:51:27]I'm going to do my homework that's due three weeks ago. Holy [ __ ] go do that.

[00:51:31]Yeah, you should you should be like booted from the stream. You should You should just like do your homework. I I have booted myself from stream to do homework. I did that yesterday, so. Go do your homework.

[00:51:44]Uh is carbon fox? Nah. I'm not in a very I'm not a very color scheme mood today.

[00:51:52]Um okay, let's let's go debugging. Let's figure out where this is breaking.

[00:51:57]I think I have an idea where.

[00:52:02]This is in the parser proper.

[00:52:07]I think.

[00:52:11]Um So, all the preprocessor stuff is fine.

[00:52:16]Um is your repo public now? It's been public for a bit. It's been public forever, actually. Um it should just be on my GitHub profile, which is in the description.

[00:52:28]Um where is this breaking? Let's just Let's just Let's give it Let's give it call chain C.

[00:52:48]And so, vertically, but like I don't know. It's I feel like it's generally more accepted to like keep the stood stuff on, at least.

[00:52:58]Um also like I think using also like using just like generally makes a mess, and you should use it as conservatively as possible.

[00:53:08]Um I'm not sure if it like I'm not sure if using stood two pull necessarily like makes the entire name space stood or not, but I would be concerned about that, at least.

[00:53:32]I don't know. I feel like people care a lot about like what type of formatting looks the best, or like people care a lot about that in terms of like verbosity.

[00:53:40]I don't really get it, personally.

[00:53:42]I think just like as long as you have some semblance of like a format that like doesn't completely irritate you, it's fine. Like it's always going to irritate someone. You're eventually going to get irritated by it. As long as it's consistent, it's fine.

[00:53:55]Um like there were some things that annoyed me, so I like I have like some changes in my like clang format. Like I can't live without like four space indent {slash} no tab indent.

[00:54:09]Um and then like some small things here and there, but like aside from that, like LLVM formatter is like fine for me.

[00:54:20]Um okay, we're going to do this.

[00:54:23]Okay, let's first Valgrind.

[00:54:27]Get irritated with clang warnings.

[00:54:30]Um well, the warnings are a good thing. So, they they exist for a reason. Oh, no.

[00:54:38]Oh man, okay.

[00:54:39]Um pop scope.

[00:54:42]So, this is in the parser, which I guess we could have figured out, but like still.

[00:54:52]Uh this is in function, actually.

[00:55:03]Uh what's wrong with this?

[00:55:06]Uh what's Valgrind? It's actually the thing literally the thing tells you. Um by default, it's I think generally Valgrind is just like a memory error detector.

[00:55:17]Um I'm just using it to print the stack trace.

[00:55:20]Um but there's a bunch of other tools included in Valgrind.

[00:55:26]Ah, full blind. Sorry.

[00:55:30]Um tool suites.

[00:55:34]Okay. So, this website is very poorly written, obviously.

[00:55:38]Um but it has like cachegrind, which profiles your cache.

[00:55:42]Um it has like callgrind, which also includes call graphs, so on and so forth. It's just like a bunch of like useful tools. Memcheck is the big one that people care about.

[00:55:55]Congrats on 5K. Thank you. Yeah, you've you've been here for a while, so it's it's pretty cool to it's pretty cool to see that you've been here, at least.

[00:56:07]Uh a lot of other people have like entered my life and exited my life since.

[00:56:12]Um but you've you've been here for this entire duration, at least, which is pretty neat, if I do say so.

[00:56:20]Uh what is wrong here?

[00:56:26]Why is pop scope causing problems?

[00:56:29]Is it an instruction, maybe?

[00:56:33]That shouldn't be causing problems.

[00:56:37]Maybe it's parsing it incorrectly, actually.

[00:56:41]As I think about it.

[00:56:45]Um hm Maybe our rule for it is incorrect.

[00:56:54]Time to add Valgrind. That would be crazy.

[00:57:04]Uh what's going to do? We're going to look in function again.

[00:57:11]Uh this looks about correct.

[00:57:22]Yeah, I don't really know what to do with this, at least.

[00:57:26]Header should be fine. That shouldn't cause problems.

[00:57:30]These should be fine.

[00:57:35]You have an action for function. We have an action for prototype.

[00:57:39]We have an action for param.

[00:57:41]That should That should solve everything there.

[00:57:49]I'm a merge clock. Uh yeah, I that's fair. I don't I don't think it's like particularly important. I only have it because like people have asked me how many lines of code I've written.

[00:57:58]So, like it it's like truly just like a utility that I have because I got annoyed of like figure out other ways to solve the problem.

[00:58:08]Um there's a way to check in Git, I think, but I don't think that's really that interesting.

[00:58:16]Uh maybe it's at the top of the rule here.

[00:58:23]Hm Um There might be something funky happening with the headers, now that I think about it. I don't think so, but there is a chance.

[00:58:42]Oh, so we do the pectal try. So, that should be fine.

[00:58:47]Maybe we could hm Maybe if we flip these around, it might be better.

[00:59:04]And do this. That Ay ay ay.

[00:59:07]What the hell did I do?

[00:59:17]Do that, maybe.

[00:59:20]Oh god, that looks so much uglier.

[00:59:30]All right, let's see what happens when we do that.

[00:59:36]Okay, that still quits.

[00:59:41]When you're stuck in one line Uh that's that's really wide.

[00:59:47]I don't really like that.

[00:59:51]All right, so this order I think was fine to be honest.

[01:00:01]Um okay, well, let's let's try to figure out what else could be breaking this.

[01:00:09]All right, let's look at the test itself. What happens if we try this on a different test that isn't just call chain? Let's give it like uh parsing the parsing test.

[01:00:20]Oh, that still fails. Okay.

[01:00:23]Hmm.

[01:00:30]Try to name things inside generic by using a type def. I see.

[01:00:36]Um if you're asking about like this slush, um it's because the parser generator is a template only like uh is a template header only library.

[01:00:45]So, this is kind of just how it's going to look for better or for worse.

[01:00:57]Um Hmm.

[01:01:07]What was I going to look at again?

[01:01:12]Yeah, I guess where did I even go here?

[01:01:15]Yeah, metaprogramming in C++ is insane.

[01:01:17]I I'm kind of scared of it.

[01:01:20]Um I've always been like trying to stray away from templates for that reason, but I should probably learn about them sooner than later cuz I'm going to run into some metaprogramming hell eventually.

[01:01:33]Clang is a powerful, really? That's crazy.

[01:01:37]Uh what's going on? Good to see you.

[01:01:38]I've been doing all right.

[01:01:40]Um hopefully you're doing well as well.

[01:01:45]Man, I keep looking at every directory other than front end.

[01:01:48]Um Hmm.

[01:01:52]What is breaking?

[01:01:59]I guess we can look at the preprocessed output as well. That could be interesting.

[01:02:07]Although, that shouldn't cause any problems cuz it was working fine before.

[01:02:16]Yeah, like that was that was perfectly fine.

[01:02:21]Should make a note on your right side.

[01:02:23]Um Yeah, maybe, but I'll select yeah.

[01:02:28]I have I have like this neat little thing on this side, which is like very very more like broad, but yeah. I think it's like I don't know. It's It's like fine. I don't care enough.

[01:02:43]Like some sometime wasting is fine. Like the fact I use Neovim automatically cancels out any possible time savings I could have gained.

[01:02:52]So, um yeah, that's that's kind of an unfortunate fate.

[01:03:00]Um So, we're trying to parse the function, but we're just not matching a scope somewhere, which means we're missing the Wait, what? No.

[01:03:13]Hmm.

[01:03:16]We're matching something wrong.

[01:03:26]Function param active params, okay, that should be fine.

[01:03:38]This all should be working at least.

[01:03:41]Okay, let's Hmm.

[01:03:45]Let's let's look at call chain. Let's uh question input call chain What if we just comment that out?

[01:04:02]Then we try this again.

[01:04:08]Still fails. Okay. So, that is like the smallest program that we can make and that fails.

[01:04:16]Um Yeah, why why doesn't this work?

[01:04:27]Hmm.

[01:04:40]Do I have a double namespace guard?

[01:04:44]Um I don't have a workspace.

[01:04:47]I guess I have like some I have like some someone's to the guard like um all of my IRs have a second have an intermediate namespace, but like I don't really have like >> [snorts] >> I don't have like a full project workspace at least.

[01:05:06]I don't know. I'm not making this at least with the intent of reuse for the most part. If if it comes to the point where I do need that then like we will we will handle that accordingly, but for the time being I haven't really planned on doing that.

[01:05:26]Uh what is wrong with this?

[01:05:38]This should be fine. I don't understand what could be going wrong here.

[01:05:47]And the parser we wrapped it with this.

[01:06:00]So, that should be fine.

[01:06:04]We try to match the function before we do it and we try to match the prototype before we do it.

[01:06:17]Can we just auto log it? What do you mean?

[01:06:43]All right, so scope is empty.

[01:06:46]So, this side Wait.

[01:06:55]Wait, what?

[01:06:57]Wait, so this this includes instruction, yes.

[01:07:09]What?

[01:07:18]Hmm.

[01:07:22]I might have to pull out the forbidden LLM actually.

[01:07:25]It might It might have to be done.

[01:07:35]Oh, man.

[01:07:37]I Hmm.

[01:07:42]That might be a little Uh that might be a little easy, but I mean I'm I'm running out of ideas.

[01:07:51]Okay, let's Claude.

[01:07:59]Uh yoink.

[01:08:04]Ideas ideas on how to debug this.

[01:08:21]Why do you use code extension card within your workspace? Cuz I don't use it enough to justify it. I I prefer generally writing stuff by hand, but sometimes I'm a little bit in super hell, so this is kind of I don't I don't really have context.

[01:08:53]Use AI to reflect.

[01:09:02]Reflect your code into specs as markdown. What do you mean?

[01:09:07]I'm I'm very LLM terse. Terse? Is that the word?

[01:09:17]Whatever the whatever dense is close to.

[01:09:27]Oh wait, so we are we are applying function.

[01:09:36]So, you can check I don't I still don't really know what you're saying, to be honest.

[01:09:43]I don't know. Like I just have not been a very big LLM guy in general.

[01:09:49]But, sometimes I will I will be willing to like pull it out for uh certain debugging tasks, at least.

[01:10:03]Like, maybe I'm just like completely misunderstanding what you're saying, but like you're going to have to like you might have to explain it to me like I'm a toddler.

[01:10:37]Oh.

[01:10:39]Wait, that should be fine then.

[01:10:51]What the f- Okay, we we are just like we are just slop we're just generating slop now.

[01:11:17]Ring markdown you check for objective. I see.

[01:11:21]Like, I don't know. I'm not like very granular with it. I generally don't really plan things out a lot beyond just like this big picture stuff.

[01:11:30]So, like I don't think that'd be really helpful for my workflow.

[01:11:34]It also just seems like annoying and like one more dependency. So, like eh.

[01:12:01]All right. Like, that just that sounds like a lot of work. Like, I like, why?

[01:12:09]I I just like truly do not understand the the need for it, at least.

[01:12:23]Like, am I insane for that take? Like I don't know.

[01:12:37]Uh we'll just do that, and then like we'll go here.

[01:13:05]Why isn't using namespace outside of namespace? Because I don't want to I don't want to stick pectol in front of everything.

[01:13:11]Or I don't want to stick towel pectol in front of everything.

[01:13:15]So uh where was this again? This is in utils.

[01:13:22]So, we we redefine that, and then we just use the namespace here.

[01:13:40]Oh my god, this this LLM [ __ ] is awful.

[01:13:47]So, won't pollute? Yeah, but like eh.

[01:13:51]This I don't know. I I feel like I had a reason for this. I don't remember what it was anymore.

[01:13:58]What if I get rid of it?

[01:14:01]I should I should just get rid of it, actually. Yeah.

[01:14:07]I think it's because when I originally wrote my parser, I tried to deep I tried to like skip as much like random pectol slop as possible.

[01:14:18]Um let's see if this builds.

[01:14:24]If you need the the context where blah blah Like, I truly I don't know.

[01:14:31]Like, it's it's slop regardless.

[01:14:36]Yeah.

[01:14:37]I don't know. I'm lazy. We're going to leave this here for now. We're going to kick the can down the road.

[01:14:46]Um okay.

[01:14:59]This should be fine.

[01:15:01]Unless unless I just like mess something up here.

[01:15:07]Welcome back, Momo.

[01:15:10]Um I am I'm debugging template hell, which means I am I've given up, and I've just thrown it into an LLM.

[01:15:23]This is this is the this is the point we've hit.

[01:15:28]Now I can see the full picture. No, you can't.

[01:15:44]Wait, what? What are we What?

[01:15:49]That's all that's there.

[01:15:52]Actually, what happens if we just nuke the rest of this?

[01:16:03]Why not run cloud code? I'm too lazy to install it.

[01:16:09]And I do not use it enough to really justify.

[01:16:18]Does this work?

[01:16:21]No, it's not. It's still cooked.

[01:16:30]>> [sighs] >> Like, god for god forbid I try to be a Luddite. Like it can't like surely it's acceptable in some capacity.

[01:17:06]Um hm.

[01:17:17]Like, this should theoretically be fine.

[01:17:20]What happens if I just get rid of this?

[01:17:32]Don't tell me you have no static assert and assert spam? Nope.

[01:17:39]Okay, so this is still broken.

[01:17:42]Okay, wait. This is this is interesting now.

[01:17:51]I think it is the list that's causing things to break.

[01:18:03]Yeah, that's still breaking.

[01:18:10]I think it is the list.

[01:18:19]Hm.

[01:18:23]We had like we had something that worked before. I forgot what it was.

[01:18:29]We're just going to look at the history in GitHub.

[01:18:39]Getting too rusty with it. That's so real. We love rust here.

[01:18:47]Uh where does this live? Parser.

[01:18:51]Oh, yeah. This is what the parser looked like before. It was one giant file of hell.

[01:18:56]And now I split it up into like seven different files of hell.

[01:19:01]Let's actually look in here.

[01:19:10]Um it's in parser.

[01:19:14]Uh uh Oh, this is too far.

[01:19:22]Um Maybe we look here.

[01:19:31]We just like rest files.

[01:19:40]>> [sighs] >> I'm tired, guys.

[01:19:55]Yeah, we just did packed all star function before.

[01:20:06]Type service of viruses, that is unfortunate.

[01:20:09]All right, my condolences.

[01:20:13]And the way we defined function before was like really dumb as well, right?

[01:20:21]Cuz we had to we had to appended ignorable.

[01:20:29]Uh ignorable's already optional.

[01:20:32]So, we could just do I would have actually packed all list. I think there's some really stupid uh some really stupid rule about lists that I'm missing somewhere.

[01:20:56]Uh I guess not. I should be fine.

[01:21:11]It's an actual sequence of R and then star of that. So, I should be fine.

[01:21:28]All right, wait.

[01:21:32]What?

[01:21:36]Like this should be fine in theory.

[01:21:47]How do we handle instruction again?

[01:21:56]There's another big S or.

[01:22:01]Uh what the hell?

[01:22:13]That should be fine. I don't I don't know why this is barked.

[01:22:27]Mm, this should be fine then.

[01:22:34]Let's make this not optional.

[01:22:43]This will break like the empty file, but I don't think we care about that right now.

[01:22:52]Okay.

[01:22:54]Okay, then it's probably not this then.

[01:23:00]Mm, maybe Okay, so let's go So, we're just having an empty scope.

[01:23:08]Which doesn't make sense.

[01:23:15]Yeah, cuz we handle left brace and right brace rules here.

[01:23:18]So, that should be fine.

[01:23:27]Okay, we're just going to print debug this.

[01:23:31]And I I can hear Spy already rolling over in his grave, but like Let's do that.

[01:24:01]Do do do.

[01:24:07]Let's do that.

[01:24:21]Let's do that.

[01:24:25]Uh this is this is fun.

[01:24:28]Are you all enjoying this?

[01:24:31]I'm enjoying this a lot less than I was half an hour ago.

[01:24:39]Okay.

[01:24:40]Um We're just not firing this rule at all.

[01:24:48]What the hell?

[01:24:51]Wait, what?

[01:25:00]That should be working.

[01:25:04]Maybe they need to be defined in the same place. That might be it actually.

[01:25:08]Um Mm.

[01:25:15]We might have to yank it from here.

[01:25:27]But no, that should be fine.

[01:25:31]We have my Discord alternative. Ooh.

[01:25:34]That seems fun.

[01:25:37]What happens if I just include core here?

[01:25:42]All right, let's yank that.

[01:25:57]Some type script. I mean like I guess it's a kind of fair though. There are like worse fates.

[01:26:07]Uh what was I going to do? Valgrind.

[01:26:10]Will this give us more interesting print output? I guess it will not.

[01:26:18]Mm.

[01:26:19]So, we're just not even calling it somehow.

[01:26:24]We're matching a function without having triggered the rules.

[01:26:29]Uh what's that error?

[01:26:33]Uh what the hell?

[01:26:41]That makes very little sense actually.

[01:26:45]Oh, I lied. This makes This makes complete sense. I know why now. It's It's something so stupid.

[01:26:53]Oh my god, I'm actually I'm so irritated.

[01:26:58]Um Yeah, okay.

[01:27:04]Um so, if we go back over to instruction, if we look at these rules, I think our rules are just wrong.

[01:27:14]Um in function, we changed we changed this to um vector of unique pointer of function.

[01:27:20]We have not changed it anywhere else.

[01:27:22]So, we need to change that real quick.

[01:27:29]Yeah, I I figured out what was wrong.

[01:27:49]Yeah, we're going to need to need to do more clean up.

[01:27:59]Uh what I missed? I I found the bug. I just forgot to change more things.

[01:28:06]Uh let's do that.

[01:28:16]Um none of this needs to change.

[01:28:19]Yeah, I just had the rule wrong, which is very unfortunate.

[01:28:24]Here I already changed it, I think.

[01:28:25]Yeah.

[01:28:28]Yeah, that's where I just changed it.

[01:28:31]Here we need to do that. I think we also already changed it. Yeah, this we changed before.

[01:28:38]Oh my god, that's so stupid.

[01:28:42]I just forgot to change this when I updated my data structures, which is like fine.

[01:28:50]Okay, so now if we save that and we try that, let's rebuild.

[01:28:58]Supposedly this will work now.

[01:29:04]And what a what an unfortunate way for that to have gone.

[01:29:19]>> Yeah. So, now if we do this Okay, it works perfectly now.

[01:29:29]Ah, that's so dumb. Okay, so let me make test now.

[01:29:36]Let's see if this all works.

[01:29:43]What do you mean supposedly?

[01:29:45]Um If I If If that was the bug, then everything will work perfectly fine.

[01:29:54]I'm like pretty confident that that was That was the issue.

[01:29:58]Just some other template shenanigans that did not get caught by tooling.

[01:30:04]Cuz templates make a mess for tooling.

[01:30:08]It appears to have passed everything.

[01:30:10]Okay. So, now we can add a prototype to the mix mix, I believe.

[01:30:17]Um yeah, we don't have a prototype test.

[01:30:20]So, let's add that.

[01:30:26]Or actually, let's commit.

[01:30:34]Um update MIR to LAR plus back-end data structures to use to support prototypes, I think. Question mark.

[01:30:55]I could have just done get commit {dash} A {dash} AM, but that's fine.

[01:30:59]Um What do we say?

[01:31:03]Fix the damn action nested templates function signature.

[01:31:16]FMCL.

[01:31:18]Oh, more formatting.

[01:31:26]Uh wait. What?

[01:31:33]What file was it?

[01:31:38]It was this one. Yeah, there we go.

[01:31:46]Okay. [snorts] So, now let's write a test.

[01:31:51]When I write a test, I mean we're just going to have a tiny shitty test.

[01:31:56]Uh let's call this um What do I call it?

[01:32:12]Hm.

[01:32:16]Let's call it prototype.

[01:32:24]We'll just do that. Let's see what happens.

[01:32:37]Okay, that actually worked, it looks like.

[01:32:42]Or emit AS2, whoops.

[01:32:49]Okay, that's fine.

[01:32:55]Okay, let's Let's give it HRR.

[01:33:11]When will you use something that's more than prototype?

[01:33:14]Um I mean, the fact that I have like a compiler that looks at or it compiles like some semblance of like reasonable programs.

[01:33:24]Um Okay, the programs are like really boring that it supports. But like we have like basic Oh, it's a joke. I see. Okay.

[01:33:33]I I'll get.

[01:33:36]>> [laughter] >> I I might be a little bit dense. Um Oh, wait, this is Wait. Wait. Wait. Wait. That's not good.

[01:33:46]Um Yeah, we can't be doing that. Wait.

[01:33:53]Wait, there's there's an issue with this then.

[01:33:55]Cuz this changes the name of the parameters. Like Does that matter?

[01:34:02]I guess it doesn't really as long as it's consistent downwards.

[01:34:08]Wait.

[01:34:13]I guess nowhere in no like function signature ask definition does it require like the name the parameter names to be the same, right?

[01:34:25]Just like the number and order, I think usually.

[01:34:29]Does C require this?

[01:34:33]Wait.

[01:34:36]Surely that's fine, though.

[01:34:38]Okay, this is what I'm interested in.

[01:34:40]MIR.

[01:34:43]Okay, well, I mean this is kind of boring, but like yeah, that works.

[01:34:48]Um okay, so then it does go all the way.

[01:34:52]So, that should be fine.

[01:34:58]Okay, so then we can go to uh So, we can just test regression generate regression tests. We can update that.

[01:35:11]I think that will just add test for prototype, if I had to guess.

[01:35:22]Let's actually Let's actually kill that.

[01:35:23]Let's Let's add more stuff to this.

[01:35:30]We can just do that.

[01:35:31]Um And then here we can also like include proto type.c.

[01:35:49]Um This means we can also theoretically like make an actual interesting program now. We just need to like link the runtime library in some way.

[01:36:00]Um I think I will just have to add it to like the build directories in some way, and then we can figure out what to do with that. But it is really cool that we're like so close to actually having a runtime library that works as well.

[01:36:15]Um Uh let's Let's Let's like actually regenerate the regression tests now.

[01:36:29]Um after this, let's commit, and then we will call it a day, I think.

[01:36:36]We've We've done a lot. I think we've done a lot.

[01:36:43]Many regs is always very slow.

[01:36:47]Hm, wait.

[01:36:49]Okay, nice.

[01:36:55]Um new uh prototype test plus regenerate regression tests.

[01:37:04]Okay.

[01:37:06]I think this is a reasonable I guess hm We We have a second. We may as well try to Do you want to try to link it today, or do you want to just do that tomorrow?

[01:37:21]Um Yeah, [ __ ] it. Let's Let's try it now.

[01:37:27]Let's try to figure out what we would need to do, and then we'll actually do it next time.

[01:37:32]So, we have this like runtime.c, which is a very stupid file, but this will do.

[01:37:42]Um Yeah.

[01:37:47]So, I think we need to add it specifically down here somewhere.

[01:37:54]We need to add it to our CC stuff.

[01:38:00]Um Wait, does linking happen before assembling, or does it go the other way?

[01:38:10]Uh what's your Discord? Um It's My My username is like the same everywhere. Uh my Discord server is in the description, though.

[01:38:18]Uh the invite's in the description, you should join.

[01:38:21]Um everyone else should also join the Discord, if you haven't. Um because YouTube's notice suck, and that's like the best place to actually get pinged when I go live, compared to maybe YouTube doing it. So, I think I think that would be a good thing for y'all to do, if you haven't joined.

[01:38:40]Uh what was I going to look up?

[01:38:44]Linking or assembling first.

[01:38:52]Hey, we link it We link it last. Okay.

[01:39:00]Uh so, we We only include the runtime library in linking, I think, then.

[01:39:12]Yeah, we want to do that.

[01:39:15]Um okay, let's let's reorganize this a little bit.

[01:39:23]See you there then? Yeah.

[01:39:27]Yeah, we'll just do this next time. I think I think I'll call it a day then.

[01:39:30]Um so next time so this is done.

[01:39:35]We can like worry about the rest of this.

[01:39:37]For now let's just like We'll we'll increment this for next time and then let's do get runtime library working plus linked.

[01:39:50]Okay.

[01:39:51]Yeah, I think I'm going to call it here then. Um thank you all so much for showing up today. If you haven't already like the stream and subscribe to the channel.

[01:39:58]Um while you're down there check out the description. Uh my Discord is down there. I've already explained why you should join that. Um but also like it's surprisingly active for a small Discord.

[01:40:07]Um everyone there is pretty chill.

[01:40:10]Um while you're down there also uh my LinkedIn and GitHub are in the description. Feel free to add me on those and my GitHub sponsors is also there if you wish to give me money.

[01:40:20]Um yeah, I'm going to go make more food now because I'm big and greedy today I guess for some reason. Um take care y'all.

[01:40:28]Take it easy.

[01:40:29]And I will see you all next time and we will we will get this we will get this done. It it will finish up.