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

Added: 2026-05-14

[00:00:00][sighs] Okay. Uh we are we are back again. Um hello all hello world. It's been a couple days. Um this is day 204 of studying compilers every day until I land a compiler role. Um yes, this past weekend I've just been like dealing with I guess making sure all my school work was done and good to go. And then yesterday I had Ghazer which was a systems themed I guess conference/workshop.

[00:00:30]Um it was a good time. Um yeah overall I think I think that was very well spent.

[00:00:37]Uh time very well spent. But yeah it is it is time to get back to compiler work.

[00:00:43]Uh it's good skill. It's good to see you. Um last stream. What did we do last stream? We supposedly finished up the expressions and the um uh the instructions in the rewrite this time.

[00:00:56]Hopefully we can get all of the remaining glue work done and everything is uh yeah hopefully everything will be good to go by that by the end of all that. Uh I just took a linear algebra final and I've gotten a total of 7 hours of sleep.

[00:01:12]Damn that is that is rough.

[00:01:14]Um, I thought I was feeling sleep deprived, but that is like that might be categorically that might be a little bit worse, if not even like categorically worse.

[00:01:23]Um, I hope I hope you get to catch up on sleep at some point. It's pretty important.

[00:01:29]Um, okay. Where was I?

[00:01:32]Status get log. Okay. Yeah. Okay. So, we did some more stuff in here. Uh, what am I looking for? to mir.

[00:01:44]Yeah. Okay.

[00:01:48]Yeah. Today's today's early. Uh what's up, Ezra? Um yeah, I have somewhere to be at 7 and then working backwards from that. I got that means I probably got to go to the gym around like 5 or so, which means I need to fit in the stream somewhere, which means it's got to be here, unfortunately. So yeah, that is that is kind of a resultant effect of all of this. Last time tomorrow and then I'm home free. Nice.

[00:02:18]Yeah. I mean that's that's kind of finals, right?

[00:02:22]Like that's that's the life.

[00:02:25]It's I don't know. I think school is a lot of just like waiting for stress, right? Like the average case really isn't that bad, but like there are like really bad waves of stress at least.

[00:02:37]Yeah, as long as you're like making time for yourself, that's a good thing.

[00:02:44]Um, okay. I remember why I didn't do this last time. Um, uh, yeah, we've got a lot of to-dos to look at and a lot of this is just annoying work and I don't really want to do that. So yeah, um let's see how do we make parameters again.

[00:03:12]So let's just uh this is Yeah. How did I do this before? Oh no, I don't want live captions. No windows, please.

[00:03:28]Just leaving to walk my dog before it rains. Yeah, I feel you. It's like I don't know. The clouds here are like they look like they look like we're on the verge of getting some rain.

[00:03:47]Um, what the Sorry, one one of my classes just had one of the funniest one of the funniest comments I've seen in a second.

[00:04:00]I I don't think I'm I don't think I should share like class materials, but it's like if you're in if you're team I please review please review team I + 3 mod 16 and I + 5 mod 16 like what are we doing just in the thick of it? Yeah. I mean, the the nice thing is like once once you're through all of it, like you will feel like um you you will feel kind of unstoppable, right? Like anytime you get another course load and like you think it's bad, you like think back to this and you're like, "Damn, I got through that. I can get through this as well."

[00:04:40]And it's it's like light work.

[00:04:47]Okay, this is this is what we did.

[00:04:51]So we want to what type is this? This is a front end type.

[00:05:00]So we want to make a new type. This is param type to mir.

[00:05:08]And then let's let's actually just yank that line actually.

[00:05:16]Yeah. So, we make a variable.

[00:05:21]Yeah, we don't need to make a scope for this. I think we probably want to add it to the scope mapping in some way though.

[00:05:28]Um, let's see.

[00:05:32]This is probably what like the global scope or this would be like scope zero maybe.

[00:05:40]So I think yeah I think we should when do we call make params actually yeah so this is before visiting the body so that means this should be in like scope zero.

[00:05:58]Uh what part of your school year are you in right now? Um we're past roughly midterms week. Like this is the time when like registration starts picking up.

[00:06:09]So, um, yeah, I don't have any exams, so I I have it a little bit late, but we've got like other work to do, so that's kind of that's kind of how it be.

[00:06:21]Um, okay, let's let's do all of this stuff. So, we have Pam.

[00:06:29]Um, yeah. So, we want to make the alloc and the store Yeah, we want to do that uh for SSA related reasons.

[00:06:48]Yeah, so this works.

[00:06:52]Uh do I need value mappings and type mappings?

[00:06:56]I I forget what I forget what I had.

[00:06:58]It's been it's been a second.

[00:07:03]Um, okay. So, we have scope binding types.

[00:07:10]Duh.

[00:07:12]Um, oh man, this is Yeah, this is so messy.

[00:07:19]Yeah, we we've got all of the we've got all the visitors. What's up, Aiden?

[00:07:25]Wait, so what what do I even What am I doing here? It's I leave the codebase for 3 days and I immediately forget everything I've written.

[00:07:34]What am I mapping to? What? Okay, so these are all function stuff. So we don't we don't care about those.

[00:07:43]So it's these or this one. It's not an expert, so we don't care. So it's just these two then.

[00:07:52]Yeah, we want scope bindings and scope binding types.

[00:07:57]So scope bindings.

[00:08:04]Oh wait, this needs to be tomire visitor. That thing.

[00:08:14]So what what goes into this again? What type is this?

[00:08:22]This is Okay. So, we want back for both of these.

[00:08:29]So, thankful I did a research masters.

[00:08:31]Yeah. Honestly, like at some point I was like, I don't want to write a thesis anymore and I just want to be done. But then I like thought about it more and I was like I don't want to take the classes either. So, like the thesis is definitely the more interesting of the two. Um, also just like research is pretty fun.

[00:08:50]I think the biggest thing I learned just from like this past weekend is that like the research community really is just like a bunch of really cool people. And I think like that's kind of the big thing I've been missing from it cuz I don't know. I've kind of like compartmentalized that sort of part of my academics into its own little box.

[00:09:09]But I've never really like engaged in it too much beyond just like talking to my adviser and being like I did X thing and then that my adviser is like cool.

[00:09:20]So yeah, I think I think that's at least been very rewarding for me at least.

[00:09:28]Um, okay. So this is we want pram name to we want an ID here actually. Can we just pram name get value?

[00:09:44]Let's paste like that.

[00:09:47]So this gets um allocate get and then this gets type right.

[00:09:58]What type is this?

[00:10:00]Oh man, this is pram type.

[00:10:07]And then we have to like clone this thing.

[00:10:12]Wait, what?

[00:10:14]Oh, get nice. Okay, that that's very clean.

[00:10:21]So, we do this and we do this.

[00:10:28]Yeah, it it is it definitely has its drawbacks, but I mean I think at least I've been engaging with it a lot less than I should have this whole time.

[00:10:40]Uh, wait, let me get food.

[00:10:43]One second.

[00:10:46]I need to We need to do a little bit of nepotism. Let's figure out what I want to eat.

[00:11:00]What is good here? Does anyone know what is good here?

[00:11:12]Presumably, presumably I want to lean towards like something chickeny here.

[00:11:23]When is the deadline for me to we are getting money through some uh very legal means right now.

[00:11:39]Okay, I'll I'll put this on the second monitor so as not to like [ __ ] up the stream. But yeah, I'll just I'll wait for other people.

[00:11:49]Uh, what's up? Uh, what's up, Slappy? I am continuing the big rewrite pile.

[00:11:58]Studs less as a student unless you're publishing. Yeah, I imagine like it's at least like it's definitely something that like matters a lot less if you're just like if you're just there for the degree and like if you kind of isolate yourself.

[00:12:15]Um, but yeah, I think like at the PhD level it starts I would imagine it starts getting a little bit annoying.

[00:12:30]There we go. Okay, so this is all cleaned up.

[00:12:35]Um, what else do we want to do?

[00:12:42]This is fine.

[00:12:46]What type is What type is this again?

[00:12:48]This is a really ugly pair. Okay. Yeah, there's there's a reason we're doing this like this then actually.

[00:12:54]Um what is res supposed to be again? Oh, we want the value.

[00:13:08]Um okay. So then here res push back stood move I move pram like that. Okay.

[00:13:28]So that looks about right. You'll you deal with other people and things. Yeah.

[00:13:32]I mean, it dealing with people kind of sucks, but at the same time, I feel like [snorts] maybe I'm just like really freaking isolated and I like sit in my room all day and like only interact with people like for 3 hours a day, but like it's kind of nice. It's kind of nice talking to people. Like everyone's everyone's so smart honestly. Like Yeah.

[00:13:58]Yeah. It I think like the whole check mark-based economy is probably not a good thing, but I don't really see a particular way around it. So that's like Yeah. Although like um one of the professors that I like really looked up to um they were at the they were at the conference yesterday um and like one of the topics that came up was like the PhD experience and like they mentioned that like it was a very check mark based economy. Like in theory, you could just be done with your PhD if your reviewers just immediately signed off on it. Like you could theoretically be done with it, but that's not going to happen ever, right?

[00:14:43]So like um one of the things that they mentioned was like the bar to the bar to signing off on everything like goes down substantially if you have something like lined up already for next year, right?

[00:14:55]So like um Yeah. So, it's like if like if you present yourself as like, oh yeah, like this is the cool research stuff. This is like the paper I've been working on. Oh, by the way, I also have a job lined up for 3 months later. The the framing goes from like I don't think you're ready yet to like, oh, we got to get you out of here. Let's figure out how to do that.

[00:15:21]Uh the chill guy I had during my time doing research was a furry. [laughter] I mean, like, we we joke about this, but like you look at the entire like Rust community and like there's like there's like this whole stereotype and it's like um are you live on Twitch? Um I'm not.

[00:15:40]I'm trying to keep everything compartmentalized to YouTube at least cuz I don't really like Twitch as a platform and also like I used to stream like esportsy stuff there. So, it feels a little bit odd to I guess pivot there.

[00:15:53]It also just like makes production really annoying because then I have to like figure out how to like dual stream.

[00:15:59]Um, and like YouTube lets me I think generate a better platform overall or at least keep a more coherent platform all in one place.

[00:16:12]Are you live on Discord? I can be.

[00:16:16]Um, I don't I don't make money on Discord though, so I will not be live on Discord.

[00:16:29]Maybe I maybe I should make Tik Toks.

[00:16:31]Maybe I should do that.

[00:16:34]Anyway, that's a that's a future concern for me.

[00:16:39]It's very much not like that here really.

[00:16:44]Like the attit like I assume you're talking about like the whole attitude towards graduation thing.

[00:16:53]Okay, how many to-dos do I have left? We cut out four of them there, so that's good.

[00:16:58]Please bleach this. This will not get bleached.

[00:17:02]Okay, so we need to figure out how to map basic blocks or at least how to add like edges properly.

[00:17:10]Um, yeah, this this seems like something this was something that I struggled with before.

[00:17:17]Um, yeah, like cyclical basic block dependencies were very annoying.

[00:17:26]Um, or like creating an edge to a basic block that doesn't exist yet was a really big problem.

[00:17:34]Yeah. So, the way I managed it before was I made like a mapping from basic blocks to like their successors.

[00:17:40]Um, we might still have problems with this though. So I need to figure out how I want to map that.

[00:17:49]So we have like function level mappings.

[00:17:51]We have like variable level mappings I guess.

[00:17:59]Yeah. So these are expert these are like scope related.

[00:18:06]Um, okay. Okay, let's do a let's add one more level here which is like basic block level.

[00:18:15]I know that like I should not be we should not be unordered mapping everything known to humankind but oh well we will we will deal with this.

[00:18:26]What do we even call this? Like basic block to ah what do we even call this?

[00:18:38][sighs] We could do like basic block to ID or something. I don't know. This is like this is getting really awful.

[00:18:50]How do you feel about this whole module thing in C++ being bolted on like scavenger run in a movie?

[00:18:56]Um, I don't know what you're referring to actually.

[00:19:08]Oh, like the new mo the alternative module system.

[00:19:15]I like I think I looked at it once, almost threw up, and never looked at it since.

[00:19:22]Yeah. Like like what are we doing?

[00:19:32]Yeah, I mean like I imagine it's like I imagine a lot of the job stuff is like injust but like um yeah I think it's like the at least the amount of like the threshold that they care about it I think goes down a little bit at least just like perceptually.

[00:19:55]Yeah. What are we doing here with modules?

[00:20:00]I I think this I think this title is pretty funny.

[00:20:06]Yeah. I don't I don't understand the point of this at least.

[00:20:13]Anyways, let's move the food to the side.

[00:20:24]Um, yeah.

[00:20:29]Okay. Anyways, before I before I get sidetracked by food again, I'm going to get back to work here.

[00:20:38]Um, let's see.

[00:21:06]Okay. Had to What type of food? Um, this type of food.

[00:21:15]Actually, I'm hitting order now. There is nothing There is nothing you can do about it.

[00:21:22]Um, Let's look at the mules. I'm getting hungry.

[00:21:30]Yeah, like it it is the committee, but like if you I don't know if you're like homies of the committee, I think that helps a little bit.

[00:21:43]Okay. Anyways, before I before I get far far too far too sidetracked by food again, I'm I'm actually like big and greedy right now. I'm like, "Oh my god, I want to bulk." Um, anyways, so we're trying to map basic blocks here.

[00:21:59]Uh, what's up, Jac?

[00:22:02]>> Okay. Um, we have this basic block edges resolution thing. We need a way to track basic blocks.

[00:22:09]Um, I remember doing this in like my MIR thing. I was not very happy with my MI thing because it was really, really ugly.

[00:22:19]Um, yeah, it was it was not good. It was like this this really ugly Yeah, I we had like indices or something. It was so stupid. Um, do not do this when your data structures look like a vector of pair of something to another vector. You know something has gone really wrong.

[00:22:47]Um, let's see.

[00:22:58]Yeah, I I don't I don't have a great idea for this. Um, cuz basic blocks are like a completely new construct that we've created pretty much.

[00:23:07]So, Yeah, I I don't know how to map this properly.

[00:23:22]Um, the idea So, we make all the basic blocks and then we like connect them up later cuz some basic blocks don't exist yet when we make the terminators for the previous basic block.

[00:23:33]So, we just set them to null and then we update them as we go. Um, maybe we could do like a connect to previous block thing. I don't think there's an instance where we jump ahead.

[00:23:50]H, no, we do. We definitely do.

[00:23:53]Um, let's see.

[00:24:00]Yeah. How do we do this?

[00:24:05]H yeah, this is this is a lot harder when I don't have like labels for instance.

[00:24:19]I guess the case the case I'm not concerned about is like straight line stuff. The case I'm concerned about is if we have like nested if statements.

[00:24:28]So like if And then we have like if bar and then like need to call A here, B here, and then like C here.

[00:24:50]And then these all like join up at the same block.

[00:24:55]It's like how do we figure out this block at least?

[00:25:03]Ghost, you're actually going to make me hungry. Like, this is this is dangerous.

[00:25:06]This is super dangerous.

[00:25:16]Yeah. How How do I want to connect this?

[00:25:18]This doesn't This doesn't seem very fun.

[00:25:24]Um, yeah, I'm I'm really struggling here.

[00:25:39]If we just had labels, we could like make basic blocks from those labels, but we don't really have labels anymore, which causes a big problem.

[00:25:54]Yeah, [laughter] man. Okay. Um, let's see.

[00:26:03]Maybe we could like make a stack or something just to store it state temporarily instead of like doing this weird mapping thing.

[00:26:13]Um hm.

[00:26:20]We could make like we could make a counter and then every time we make a block we connect everything that depended on that block.

[00:26:28]But then we don't know the count beforehand. So that causes a problem.

[00:26:37]Oh man.

[00:26:41]Okay. Let's let's just like figure this out case by case, I think.

[00:26:47]Um yeah, we need to we already mapped the function type.

[00:26:54]And then is that all of the stuff we need to do mapping here? I think so. Right.

[00:27:06]That should all be good.

[00:27:10]Yeah, we have function IDs. We have function types. That should be good.

[00:27:17]Okay, so those we have to deal with eventually.

[00:27:29]Yeah, this is this is really throwing me for a loop actually.

[00:27:36]Okay. Um.

[00:27:38]Hm.

[00:27:50]I guess with the we could start with a return block. I think that's like the most we don't have the we don't make a damn return block yet. Maybe we should make the return block first and then we can like make the blocks in like reverse order almost.

[00:28:13]And then we can construct the program back to front almost.

[00:28:18]That might actually that might actually work better.

[00:28:39]I have to I have to figure out more logistics. One second.

[00:29:02]Okay. Anyways, um yeah, I'm sorry. I'm I'm really struggling to figure out what I want to do here. So, this is probably fine.

[00:29:14]Um maybe we're maybe reverse order would have been nicer, but I think forward is probably good. Um can you go back and pass the labels on? I don't make labels in the uh at the though is the problem.

[00:29:29]uh which is this is kind of one of the things that like having h did I guess resolve a little bit but it just doesn't it doesn't really work here because I don't support labels in the front end proper or in like the um are you working on your own language or are you implementing a compiler for an existing language I am I make it in compiler for C Okay, sorry. I am like I'm getting like super sidetracked. I should I should not be doing that.

[00:31:05]Um, yeah, I don't think this this backwards thing really works to be honest.

[00:31:16]I guess like h most of these things we can kind of understand like sequentially like we could keep track of like previous block in like a stack or something.

[00:31:30]I don't know this is this is really annoying. So um let me just like try to draw out the problem.

[00:31:39]So like we have this block here.

[00:31:42]So a basic block is like a straight line sequence of instructions if you're not familiar with that. Um the idea is we can like model control flow with these.

[00:31:50]And then let's say here we have like a branch, right?

[00:31:54]So like this is like an if statement like if something is true then like we go here otherwise we just fall through and then this like directs back there so on and so forth. Um, the problem is we're making these, I guess, in this direction pretty much when reading through the program. So, we we haven't made the next basic block yet, which means we can't like make the pointer to it yet, I guess. Um, so like it it might seem simple to just like keep track of like basic block every time you make one, like link it to the previous, but then you get to like these sorts of control flow structures which cause problems.

[00:32:30]Um, yeah.

[00:32:38]Yeah, that's that's kind of the big problem I'm running into right now at least.

[00:33:06]Yeah, previously I've just been like making these without the edges and then figuring out like the edges at some point in the future, but I don't know how to keep track of that properly.

[00:33:19]I really don't want to like index by strings or something. That would be really annoying.

[00:33:35]How does LVM manage this again? I know it has like a basic block builder or it has like a IR builder which I think would handle this for it.

[00:33:46]Um our our lowering thing is kind of a builder in and of itself. So, I imagine there's some way to abstract it out, but this this is annoying at least.

[00:34:03]Um, yeah, this is actually like super super annoying.

[00:34:24]Let's maybe we could worry about branching control flow in a second. We could like start by figuring out straight line then maybe or like return at least.

[00:34:34]Let's let's just start with a mapping uh from like some sort of number to like basic some sort of basic block.

[00:34:57]Yeah, we'll do basic block putter.

[00:35:00]Um, we'll just do that. I don't know.

[00:35:09]So then crap.

[00:35:17]Where where do we make the where do we make the return block? I guess we kind of implicitly make it.

[00:35:25]So we can kind of just like make that a zero.

[00:35:34]And then we can keep a counter here which is like basic blocks or I guess like cur basic block id.

[00:35:43]And then we need to initialize that somewhere. But we'll we'll see if this even like works in theory before making changes in places that I will forget about.

[00:35:54]So let's start with start with return.

[00:35:58]Slener.

[00:36:14]Yeah, let's do it like down here.

[00:36:22]So at Yeah, we want the Okay, that maps to the basic block and then we want something to map I guess like actually this should be basic block ids and then we want to map from uh the actual ual instructions that need these.

[00:36:56]So, Terminator star to I guess a list of unit 64t and this should be basic block edges potentially.

[00:37:33]Um [ __ ] Okay.

[00:37:48]So let's do basic block edges at I guess branch get equals zero which will just be the index of the default one.

[00:38:11]We'll just do that.

[00:38:15][sighs] Um, yeah. And then we can figure out what to do with make basic block.

[00:38:27]Yeah, that'll be that'll be very annoying.

[00:38:33]So then yeah, con branch. So this I guess anything with conditional branching is going to be annoying.

[00:38:41]So the problem is like we might have recursion which will like be annoying.

[00:38:51]So let's let's start with this.

[00:39:01]So that should be curve basic block id + one, right? Cuz one of the blocks goes one way and then we need to make the block.

[00:39:21]So the the making the block will use up the current ID. So the next one is plus one here.

[00:39:32]Um, you need to do this.

[00:39:39]Oh man.

[00:39:44]Yeah. How do we how do we even do this properly?

[00:39:56]We'll just do this. We need that maybe.

[00:40:02]Um, yeah. So, we can do that, I guess, to keep that because we're going to be moving this in there.

[00:40:20]So then we make this con bird putter after we make the true branch.

[00:40:30]I guess the false branch. Oh, that's really annoying.

[00:40:50]Yeah, that's really annoying.

[00:40:53]That's very annoying.

[00:40:57]Respect the grind, bro. Thank you. I am I'm struggling, but I I appreciate it a lot.

[00:41:10]Actually, this is this is probably fine.

[00:41:16]Um, yes, cuz then the next block is necessarily Yeah, cuz this we visited the body.

[00:41:24]So then we can definitely do this.

[00:41:30]So that should be current plus one.

[00:41:35]Let's just let's also do Uh, let's do this real quick.

[00:41:51]So, we do that and then basic block edges or not edges IDs at curve basic block id++.

[00:42:08]Yeah. So we want that.

[00:42:15]So that maps that maps it to basic block ids and then it increments current basic block id. So with that now we can continue doing this slush.

[00:42:31]So um actually We could do it like this.

[00:42:45]Um, so we've already made it here. So we can do this.

[00:42:51]And then here we've made it. So then we can do this is going to be really ugly. So we can do I we can do a turner operator inside of this because we love we love ugly code here. So, if it has a false branch, then it's the current block.

[00:43:12]It's It's going to be the current block anyway, actually, now that I think about it.

[00:43:22]Yeah, I But this is like really ugly code at least. So, I don't really like this.

[00:43:32]Um, yes, we're writing a to-do to write a comment. This this is the state of affairs in this world. Um, yeah.

[00:43:59]Um, so we have con branch. Let's actually just make this like T branch.

[00:44:18]We'll just simplify these names a little bit.

[00:44:31]Yeah. So, we're going to need that after we make the basic block.

[00:44:39]And then this should be null putter for now.

[00:44:46]Uh, this should be f branched putter.

[00:44:49]Oh, we can't do auto here. God damn it.

[00:44:51]Ah, okay. Um, can I just do fashter equals f forget?

[00:45:03]Does that work? No, cuz I need cuz auto is not enough here.

[00:45:10]Yeah. Okay. So, we have to do that then.

[00:45:14]Uh oh, you weren't here for the answer. Um, I am making a compiler for C. So, I'm I'm going from C to X8664 right now.

[00:45:27]Okay, let me actually figure out food.

[00:45:45]Um, okay. I I actually got to figure this out real quick before I get yelled at.

[00:45:52]Let's see.

[00:45:54]Let's get a mule.

[00:46:00]Oh, let's get that.

[00:46:20]Uh Okay, let's I'll just take a screenshot of that.

[00:46:38]That will be easier.

[00:46:48]Okay. Uh, have you used Bison or Lux during this? Um, I have not, but I'm using a different parser generator. Um, I'm using Pectal because I'm I'm somewhat familiar with it and I don't want to write a parser by hand.

[00:47:04]Um, it's it's a template header only uh parser generator.

[00:47:23]Um, okay. Anyways, let's let's figure this out for a second.

[00:47:33]Yeah. Okay. So, yeah. What is the best way to associate this?

[00:47:49]Um, okay. So, we keep the pointer so we can associate this later.

[00:47:56]So, this would go at the end here.

[00:47:59]I'm fairly sure.

[00:48:02]I guess we could put this here as well.

[00:48:04]So, false branch put her. Actually, we could just auto here, right? Because we don't care about it outside.

[00:48:17]Yeah. So, we can do that.

[00:48:27]What am I doing here?

[00:48:34]I guess we don't need to. No.

[00:48:37]Ah, actually, this is probably fine then. We don't even need this then.

[00:48:44]Yeah. So, that should be good. So, that maps the false branch properly to the next block.

[00:48:50]Um, but we need let's do the true block real quick.

[00:49:12]Let's go that. Or we could even Ah, this sucks. Okay. I I want to do it this way just so I can standardize it a little bit and help readability in a sense.

[00:49:36]So we do that that associates.

[00:49:42]I'm putting off making an assembler. I yeah, assemblers are hard. Assemblers are really difficult. Um, Pectal is like fine. Um, it's it's been really funny learning that there are features that trivialize very large slots of my code, but yeah, I I would honest I don't even know if I'd suggest it. Honestly, like with parsing, just do whatever you want at this point.

[00:50:09]I think that's kind of that's kind of the only way to go about it.

[00:50:14]Um, okay. Yeah.

[00:50:20]So, this Yeah. So, let's do it this way.

[00:50:33]So then uh So then yeah, what do we how do we want to organize this better? I guess this this kind of thing is kind of working.

[00:50:52]Uh let's move this up here instead.

[00:51:03]Uh so this is con to true this is con to false or cont.

[00:51:17]So I guess we don't need to explain it then.

[00:51:21]So this we want to push back curve basic block ID.

[00:51:36]Sorry. Um okay son this all this all should be fine from here I think.

[00:51:45]School project. Oh okay. that that sounds simultaneously better and worse.

[00:51:50]If it was like if you were trying to like meet actual spec, I think it'd be miserable. But at the same time, I think it being school like puts a lot of time pressure, right? Like that seems that doesn't seem fun in its own way as well.

[00:52:13]Okay. So we have so con to true we have K to whatever else and then this should be or maybe we could is it bad style to like do one big inline comment as well.

[00:52:38]Yeah, we can do that.

[00:52:47]So that's false to [ __ ] This should be true to [ __ ] Oh, we need to we need to make that as well. It just occurred to me.

[00:53:00]Um Oh, we do it here. I see. That's Yeah. Okay, that makes sense actually.

[00:53:12]Um, yeah. Okay. This This makes complete sense. So, let's do it like that.

[00:53:23]Um, this could also just be this.

[00:53:36]Yeah. So, we're going to do that. So, that's consistent.

[00:53:40]This is fine. This is fine.

[00:53:46]Full tool chain assemb assembler linker and emulator. Oh, wow. Wait, that's that's crazy for a class. That's really cool.

[00:53:57]Um, yeah, like damn, I don't think our our compilers class was ever that comprehensive. It's all just like it's all very much backend heavy and a little bit of middle end and like a little bit of front end. Um, how do you find interesting compiler design? Um, I took a class in college and I thought it was cool. Um, it covered like the front end and the back end of a compiler as opposed to like the optimizer, but I still thought it was like really interesting. Um, I thought that it it was cool how it combined like PL stuff along with like system stuff as well as some like software engineering and like um, uh, what's it called? some like theory, algorithms. I think those are all kind of like what makes uh computer science cool for me. So, it was just really cool seeing like a field that I guess included all of that in some in one place.

[00:54:49]Okay, so we can get rid of these to-dos now.

[00:54:59]Um, yeah, we don't need this anymore.

[00:55:12]Yeah. Okay. So, now we need to figure out while we need to figure out how the hell we're going to do this. Uh oh. Yeah, we also need to like wrap up the previous block as well in some way.

[00:55:29]I I think we do that. I don't remember if we do though.

[00:55:34]I guess we don't need to for if but it matters for these loops at least.

[00:55:41]Um yeah so we can do this so you can call that prove.

[00:55:54]So this should be con and then this should be I don't know body.

[00:56:06]Sure. We we'll call it that.

[00:56:10]Um, yeah, we can do that. We can do that.

[00:56:18]That can be arranged.

[00:56:21]Yeah. And then we start with a clean basic block and then life is good.

[00:56:30]Okay. So, let's I think we could start with this at least.

[00:56:41]Um or maybe we could do conet cuz I think there's only like or there's two places this could be actually. So we do want conutter.

[00:56:58]So cond get do that.

[00:57:06]So that's fine.

[00:57:14]So con to uh I think this is body.

[00:57:24]Yeah. We also want pre to let's actually just write all the comments out real quick.

[00:57:34]Actually, we could just do this even.

[00:57:46]So, edges at pre get equals this plus one.

[00:57:58]Unless we standardized it in some way. I don't think we do like a plus one anywhere else.

[00:58:04]Yeah, we should we should probably standardize it then.

[00:58:24]Yeah. So, we'll do that.

[00:58:33]Yeah. Okay. Nice. And then, yeah, we can do it that way. That cleans up our code a little bit or at least tries to make it a little bit readable.

[00:58:44]A little bit more readable.

[00:58:47]Um, yeah. So we can do this.

[00:58:52]We can make that condition branch.

[00:58:58]So we do this.

[00:59:04]Um so con to body and then we need to figure out con to K, I guess.

[00:59:23]It's probably like here or um Okay. So, this is body to cond.

[00:59:43]Yeah. Okay. So, this is like the fall through So this goes to the condition, this goes to the body, this goes back to the condition, and this is the fall through slashcontin.

[01:00:06]Okay, so we get rid of these to-dos now.

[01:00:16]Um, okay. Let's yank that.

[01:00:31]So, she body putter.

[01:00:39]So that goes to not that but this is converter.

[01:00:46]This should push.

[01:00:53]Yeah, we should push this back.

[01:01:03]And then this should be [sighs and gasps] uh I guess we could keep a a temporary here.

[01:01:26]We can do that.

[01:01:29]And this should be con basic block ID.

[01:01:38]Yeah. Okay.

[01:01:41]This is very messy, but I mean it's it's more manageable than before.

[01:01:49]Yeah. Okay. So, now all we need to do is actually like tie the edges together.

[01:01:53]And I think I think we should be in a pretty solid state.

[01:02:15]Uh, I'm clicking things. Okay.

[01:02:20][sighs] Yeah, I'm tired. Um, let's try to let's try to be brisk with the rest of this.

[01:02:30]So, we want to figure out how to resolve all of this.

[01:02:33]Now, uh we also need to we need to initialize that in the constructor real quick.

[01:02:42]I hit N. So, I lost where I was. That's really annoying.

[01:02:47]So, have that cur basic block ID is one because zero is reserved for the return block.

[01:03:02]Um, we should probably map that as well real quick.

[01:03:08]Which lives in Where does this live? Where does this live again?

[01:03:25]It lives here. Okay.

[01:03:30]Do we ever close the basic block at all?

[01:03:34]Do we even make the We don't even make the return block or make return block.

[01:03:52]Um, actually, yeah, this is fine. We can just we can do it in this order.

[01:04:08]So, we visit the body. That cleans all of that up.

[01:04:12]Um, does it?

[01:04:21]No, it doesn't quite actually h actually that doesn't quite that is really annoying cuz we also we do need to like close the block I think.

[01:04:49]Yeah.

[01:04:51]So, we should we should handle this distinctly from just the visitor.

[01:04:58]But we can we can yank all this stuff real quick.

[01:05:18]Uh So, let's do that.

[01:05:28]And then want to do that maybe. I don't know.

[01:05:38]Uh, so we have that and then yeah, I don't even remember how I wanted to close the final thing. I think I think it should just jump to the return block.

[01:06:02]Yeah. So, we need to handle this separately.

[01:06:08]Uh yeah. And then we should just generate a branch. I believe that's kind of how we want to handle this. I think I think we did this before here though somewhere.

[01:06:31]Close dangling block. Yeah. So we just we just go to the we just go here to the return block. Okay. So then, yeah. What do we do here?

[01:06:53]Yeah. So, I'm going to do that.

[01:07:03]Okay.

[01:07:10]So, this is like fine.

[01:07:17]And then we clean that up.

[01:07:21]And then was there anything else that I'm missing?

[01:07:29]I don't think so. I think that's the big thing that we were missing at least.

[01:07:34]Um that that cleans up the final block.

[01:07:40]So then yeah, what do we what else do we want to do from here? I think this is sufficient.

[01:07:57]Yeah, cuz this all all we wanted to do was just close the final block.

[01:08:05]Yeah. So then yeah.

[01:08:16]Okay. So then we can do this like resolve basic block edges thing.

[01:08:24]We can kind of we can even get rid of this. Um what's up parsa? Um are you using WSL? Yes. Um, I'm using WSL instead of like dual booting or like using a proper VM because I'm lazy. Um, I also have a bit of a Valerant addiction. So, we need we need to preserve Valerant, which means I need Windows.

[01:08:50]Okay, let's clean this up now. So, then this actually should be a little bit less awful cuz we kind of we kind of associate all the blocks now, which is very nice.

[01:09:01]So then for uh let's see how do we want to map this at least.

[01:09:24]Yeah. What are what are we doing here?

[01:09:27]Yeah. Like this was this was really messy.

[01:09:31]because like we had to like translate labels as well. We had to keep track of like a third state. This somehow manages to be less less messy.

[01:09:41]So we want um Terminator and edges in basic block edges.

[01:09:59]Can I Okay, that's not a thing.

[01:10:03]So, we do this. And then for auto edge, I guess ID in edges.

[01:10:18]We do something.

[01:10:21]So then Terminator or we we could do like a dynamic cast thing like we did in the original.

[01:10:32]Yeah. So we did this.

[01:10:39]But this is very ugly. So we're going to we're going to take inspiration from this only.

[01:10:48]So we'll shorten that.

[01:10:50]shorten that.

[01:10:57]That should be terminator.

[01:11:03]We'll figure out what to do in there in a second. Or actually, we could just do this.

[01:11:08]I don't know why we needed these IDs again. I think although I think there is something that I'm forgetting about.

[01:11:20]What the hell am I doing here?

[01:11:23]Oh, we need to add edges. Oh, okay.

[01:11:29]What am I doing here? Why do why did I want to separate this out again? This was very pointless.

[01:11:38]What's up, Nash?

[01:11:43]This actually makes zero sense why I did it like this. I don't know why I had to check twice.

[01:11:59]Yeah, like this should be fine anyways.

[01:12:01]Um, so that should be okay. So we want to set successor to basic block ids at uh edges zero I think.

[01:12:30]Okay. So, let's do the same same idea here.

[01:12:40]We don't need this honestly.

[01:12:46]We can do T successor.

[01:12:53]Do that.

[01:12:56]We can do it like this. Everything should be good.

[01:13:01]I still don't know why I separated this out, though. This feels a little bit redundant.

[01:13:11]Yeah. Oh, actually, I know why. Cuz we don't have the block itself. Obviously, that that does cause a problem. Yeah.

[01:13:20]Um h maybe we could iterate through the blocks instead of doing it like this and that might help actually instead.

[01:13:34]Let's let's try it like that. So that way we just loop over it once.

[01:13:44]Yeah. So we can loop through that.

[01:13:49]Yeah, we we literally have this do that.

[01:14:00]Let's make a T.

[01:14:06]What's wrong here?

[01:14:10]Oh, I see.

[01:14:17]Um, so we do that. We can do that, I guess.

[01:14:37]Yeah. Okay.

[01:14:40]So that kind of cleans that up in a sense. And then we can also uh set successor actually. Yeah, we should we should just do it like this.

[01:15:00]So this should be successor, right?

[01:15:13]What's wrong here?

[01:15:15]Oh, successor ID and then This should also be a putter.

[01:15:34]We also need to just change this type, but we'll worry about that in a second.

[01:15:39]Um, that's that's like a future problem at least.

[01:15:45]Okay. Um, yeah. So we can do basic block ids at uh successor id this can be successor and then basic block and then we can add edge to successor did I okay that's good and then successor get predecessors and we add edge to basic block.

[01:16:27][snorts] Look at that. Okay, so that's actually not that bad surprisingly.

[01:16:38]Um, yeah. So, we can do this.

[01:16:47]So, we have this. This is Terminator Zero.

[01:16:54]Maybe we should make this like a helper H.

[01:17:09]Yeah, this is kind of messy.

[01:17:20]Um, okay. So, we want I guess like Hol or I guess like add edge.

[01:17:35]Let's see.

[01:17:41]So, we want T And then we want I think we kind of just want Yeah.

[01:17:59]Yeah. So we want Okay. This actually doesn't This doesn't modularize well, which is fine.

[01:18:10]Let's just Let's just do it like this.

[01:18:12]So this is fine.

[01:18:16]So we have this.

[01:18:20]So instead of this, this should be true successor ID.

[01:18:30]Or maybe we could maybe we can just put this in here and it's fine.

[01:18:35]Honestly, it's not the end of the world.

[01:18:41]Yeah, I can do that.

[01:18:48]Okay. So, we can set true successor to T successor.

[01:18:57]Oh, wait. Con branch.

[01:19:09]Not that. Okay. So, now we can yink this uh Linux not quite. I'm using WSL which is like it's like a VM but not it's I guess Linux emulation.

[01:19:26]This should be one if I can type.

[01:19:33]Yes, you are correct.

[01:19:44]Okay, this should all be correct now in theory.

[01:19:48]And all the to-dos we have left is like stuff that we actually should save as to-do for now.

[01:19:59]Okay, so this should be done.

[01:20:02]Um, let's see.

[01:20:24]What the [ __ ] Okay. Anyways, um, what time did I have to go by? It got pushed back.

[01:20:33]It got pushed back. So, I have an hour, which is very nice. Let's Let's keep going. Let's actually try to get this looped into our our stuff now. Um, I'm going to keep this HR directory around for a little bit. H, actually, should I?

[01:20:50]Let's get rid of this as well as all these for now. We'll see if that deviously breaks anything.

[01:20:59]This will definitely break things. Let's see how much it breaks.

[01:21:08]Okay, so let's start with compiler.

[01:21:12]So this is in driver compiler.

[01:21:17]Um what the Okay, so we got to we got to fix our formatting here because I was that's part of the big rewrite.

[01:21:30]So these headers go to the top now.

[01:21:34]These stay down here.

[01:21:38]This doesn't exist anymore. This should be as to mir.

[01:21:48]Yeah. Okay. So that's fine.

[01:21:55]And then all the back end stuff is there. Then we have the middle end.

[01:21:59]That's all good. Okay. So we don't have this anymore.

[01:22:05]Not that anymore.

[01:22:11]Okay, we'll just slowly trim stuff out of here.

[01:22:27]So, this should just be two mir. This should take as the a instead.

[01:22:37]Wait, what?

[01:22:48]Oh, lower. That's what we called it.

[01:22:52]God damn it. Okay.

[01:22:56]Yeah, sure. That that actually makes a lot of sense. Okay. And then the rest of this looks like it's fine.

[01:23:11]runner. Oh, we need to Oh, no.

[01:23:17]What? Where is this linking in?

[01:23:22]Okay, we'll worry about that in a second. I might have just forgotten to implement something somewhere, but that's that's an issue for a couple seconds later.

[01:23:39]Yeah. So, we can do that.

[01:23:46]Uh, we don't have this anymore.

[01:23:59]Okay. We We got to We got to do this by hand.

[01:24:07]Okay. And then this doesn't exist anymore.

[01:24:17]Um Okay.

[01:24:23]Okay. We're still in trouble.

[01:24:27]We're still super in trouble.

[01:24:36]undefined reference to lower.

[01:24:42]Oh no. Oh no.

[01:24:46]Are we in Are we in template hell? Is that something that I like messed up somewhere?

[01:25:00]Uh, what the unless I like forgot to maybe I messed up the build order.

[01:25:22]No, definitely not.

[01:25:25]So that's the runner. That's the compiler. Okay.

[01:25:35]Not even two mir. That's crazy.

[01:25:46]What?

[01:25:56]Yeah. Why doesn't this link anymore?

[01:25:59]Oh man. Is this something to do with the damn install file? Is that what's going wrong? Let's just add all this real quick. Real quick. Let's also Yeah.

[01:26:15]Okay. Um, oh man, I don't want to I don't want to deal with I don't want to deal with Cmake. I really don't want to deal with Cake right now.

[01:26:32]Yeah, this is this is not going to be fun.

[01:26:45]Yeah. Like what do I even do with this?

[01:26:51]I know this all exists. So I think I think something is going wrong in my cmake.

[01:27:06]That's really annoying.

[01:27:20]I know we did some like really messy stuff here as well.

[01:27:45]This Yeah, this this makes little sense at least to me.

[01:28:16]What is what is happening here?

[01:28:42]Let's look at this. Let's look at this more closely. [sighs] What version are we do we care about? I don't think it matters.

[01:29:07]I don't want to I don't want to do CMake. I really don't want to do CMake right now.

[01:29:22]Ah, no.

[01:29:27]No.

[01:29:42]Okay, let's I'm actually just going to throw this into an LM. I really don't want to think about this right now.

[01:29:50]So, let's pull up quad.

[01:29:54]Uh, I need to I need to change cloud accounts real quick.

[01:30:08]Okay, that is me.

[01:30:25]Let's see. I think it's AC make issue.

[01:30:29]Oh, wait.

[01:30:37]Uh, where did what file was this again?

[01:30:40]Is this Are we kidding me? Okay.

[01:31:11]Are we stupid? Okay, this is not helpful.

[01:31:36]Okay. [ __ ] [ __ ] Claude. This is not helpful.

[01:31:40]Um, yeah. We're just going to stare at this for a while as well.

[01:31:58]Let's see.

[01:32:01]What is this? Install targets. When was this added? Deprecated. Okay, great.

[01:32:31]Okay, so we want Do I need to install the libraries actually?

[01:32:44]Oh, I might need to install the libraries. That's the big thing that I might even be missing, right? No, I Wait, do I do this though?

[01:32:51]Yes, I do.

[01:32:59]Man, yeah, I don't think Cloud would be able to give context if I'm just pasting it in. So, it's also just like uninteresting to do that.

[01:33:14]Yeah. So we are installing everything.

[01:33:22]Maybe if we don't do or actually Oh, wait. Okay. Wait.

[01:33:44]Yeah, that doesn't make a lot of sense.

[01:34:02]I should figure out the distinction at least.

[01:34:12]We'll just start the We'll start the overview.

[01:34:18]Um, yeah, sure. That makes sense.

[01:34:33]Yeah. How does how does that work anyway?

[01:34:37]Sure.

[01:34:55]That Okay, that makes sense.

[01:35:05]Okay, that also makes sense.

[01:35:12]Um, yeah, that makes sense.

[01:36:02]See, this this makes little sense to me, you know.

[01:36:39]I guess maybe I should move this thing over as well.

[01:36:45]Was it this that wish? What had the big explainer?

[01:37:06]Um, Let's see this mentioned passing it.

[01:37:27]Yeah. So, dash prefix. So, we can just do it here in Dary.

[01:37:37]So, maybe this will clean it up as well.

[01:37:51]Make clean.

[01:37:57]Oh, wait. That still doesn't work. Okay.

[01:38:00]Wait. So, this isn't even like an install thing anymore.

[01:38:10]Yeah. Make build.

[01:38:17]Sorry, I'm apologies if I'm not like commentating a lot. I'm just genuinely trying to figure out what's happening here.

[01:38:25]Um, yeah. What is going wrong here?

[01:38:55]Okay, let's let's look at like pop atom for instance.

[01:39:01]Oh, do I need to name space these?

[01:39:13]There's no way that's what it is, right?

[01:39:19]Oh my god, it is. Why the [ __ ] do these need name space specifiers? So then what's the point of this?

[01:39:26]What what is what is the point of this?

[01:39:31]Like what? What was the point then if we have to specify anyway?

[01:39:42]That's really dumb.

[01:39:47]Okay, well that's that's fine. Um or what if we just What if we did this then instead?

[01:40:13]Maybe. Yeah, maybe this is the correct way to do it actually.

[01:40:23]Yeah, okay. This that makes sense.

[01:40:32]Okay, let's try that again.

[01:40:38]Okay, so that did not solve anything somehow.

[01:40:52]Lower is missing for some reason.

[01:40:56]Oh man, what the [ __ ] So, this rewrite thing did not do what I wanted it to.

[01:41:03]So, do we still have to What?

[01:41:36]Like this should be fine.

[01:41:40]We literally do this properly.

[01:41:48]What the [ __ ] >> [sighs] >> What the [ __ ] Okay, that's that's so irritating.

[01:42:25]So, do I just need to do this then?

[01:42:38]That's really annoying.

[01:42:50]So, is this literally what I have to do?

[01:42:58]It really is.

[01:43:00]Are we serious?

[01:43:06]That's so stupid. That actually irritates me so much.

[01:43:15]I just wanted to d nest this. I don't doesn't um I don't think it's supposed to. Using should just like make it this should just be like name space from here down at least, you know.

[01:43:40]Maybe that's fine though.

[01:43:50]Yeah, but it should be local to the file. So everything there should resolve properly.

[01:44:01]Yeah. So like this this file works perfectly fine.

[01:44:17]But then I guess maybe mixing these causes problems or mixing globals.

[01:44:30]That seems like what's causing it to break at least.

[01:45:06]I was like, why is lower missing?

[01:45:16]Do I really have to specify that there?

[01:45:24]No. Okay.

[01:45:26]So, let's let's fix all of these then, I guess, which is really stupid, but I mean, it seems like it seems like it wants me to do that. So, I mean, what can I say?

[01:45:39]So, the C++ files specifically need to have this thing work.

[01:45:45][sighs and gasps] That's really annoying.

[01:46:11]So this should fix like some more things.

[01:46:18]A this is this is really irritating now.

[01:46:25][sighs] Wait, so why can't I just do that?

[01:46:49]Yeah, let's let's put let's I think this is a better question to ask Claude. Why doesn't this why does this result in linker?

[01:47:08]Sorry. Ah, let's Oh, wait. That's a thing.

[01:47:40]>> [sighs] >> Wait, but we define it in a header.

[01:47:50]Sure.

[01:48:11]What? What the [ __ ] Wait, what?

[01:48:25]This isn't even about inlining.

[01:48:40]So why does so given the current header why does the namespace block work but using namespace doesn't mean uh what did I >> [sighs] >> Wow, that's so stupid.

[01:49:18]Thanks.

[01:49:21]Okay, so I do need the namespace block.

[01:49:23]That's so dumb. That's That's actually so irritating to me.

[01:49:33]Like we can we cannot be for real here.

[01:49:41]I don't know if this is true or not though.

[01:49:52]Ah, what?

[01:50:11]That's so stupid.

[01:50:23]This doesn't even make sense to me.

[01:50:34]Okay, here's here's what we're going to do. I wanted to The whole reason I cared about this is to d nest. Um, it's So, we're going to add these back, which is fine. We'll just have to do that real quick.

[01:50:50]Let's Let's start with utils.

[01:51:01]We're going to change the formatting a little bit, though.

[01:51:05]We're going to go back to claim format.

[01:51:10]We'll deindent that. There we go.

[01:51:16]Uh, we should keep the make file changes, I think, though.

[01:51:22]Or we could worry about that in a second.

[01:51:39]Okay, we're like slowly working backwards to end up with like just LOVM formatting at this point, which I think is really funny.

[01:51:54]Okay, so we'll rewrite these slowly.

[01:52:02]I guess this does have the benefit of like fixing our headers as well, so I can't really complain that much.

[01:52:14]So we can do that.

[01:52:21]That kind of works out.

[01:52:27]Huzzah. Okay.

[01:52:38]Um, so we'll just do this to be consistent with it.

[01:53:02]This is so dumb. This That's actually so dumb. I guess like I'm I'm sure there's like a real reason for it, but like God, that irritates me.

[01:53:18]Okay. What am I doing there?

[01:53:25]Uh, what's the bridge?

[01:53:36]Yeah, this is this is not going great.

[01:53:43]So, do I have to like I don't think I've like oversp specified anywhere in there at least.

[01:53:55]Definitely not in there. So maybe in here we have problems.

[01:54:08]We can do this now, I think.

[01:54:14]Sure. Okay, that works.

[01:54:18]Um, yeah. Okay, we'll just deal with that.

[01:54:26]That's fine.

[01:54:31]I'm already getting lazy to type. We're already copying things.

[01:54:45]Okay. Um format to do.

[01:55:00]See, these were fine, I think.

[01:55:06]Yeah, all of these were fine. I think the parser was where we ran into the most issues, though.

[01:55:25]Yeah, this this is my life now. This is what I have to do forever.

[01:55:32]Um, [sighs and gasps] okay.

[01:55:36]We need to we need to do more of this. I think I think this we can keep actually.

[01:55:41]I think that is fine because we're just calling that name space.

[01:56:02]Yeah. Okay. This is fine.

[01:56:19]I I think this level specification is fine here. I think it makes sense for that file specifically.

[01:56:25]Uh this Okay, now we get to now we get to have fun. Let me just make sure this is comprehensive. I forgot to format this.

[01:56:35]Um this is good.

[01:56:44]That's good.

[01:56:46]That's fine. That's fine.

[01:56:50]That's fine. Okay.

[01:56:53]We did all the utils.

[01:56:56]Yeah.

[01:57:01]Okay.

[01:57:03]So now okay the pre-processor we also did so it is just the parser now which this is hell.

[01:57:19]Uh yeah we we don't need to qualify that anymore. So this is where we have to start like fixing our our code base.

[01:57:36]Okay, that does need to be externed.

[01:57:46]Oh, that is a that is a crazy crazy way that works though. That irritates me to no end.

[01:57:56][snorts] Okay. So then name space front end we'll do this again.

[01:58:26]I'm sure this is exactly what everyone wanted to see on stream instead of like actual code, you know, because because who who would want to like watch someone actually write a program, you know, instead of dealing with name spaces.

[01:58:43]Okay. Um anyway, enough complaining. Uh this is almost done.

[01:58:52]One brings the name space to you, the other brings you. Oh, actually when you wear it like that, that makes so much more sense. Wow. Wait.

[01:59:02]Wow. Wait, that that actually is I I'm pinning this.

[01:59:09]That's actually such a good explanation.

[01:59:25]Yeah, it's it's actually like it's actually bars. Holy [ __ ] Okay, so now make build.

[01:59:38]Please, please work get value. I forgot what where the hell does this live? Okay, this is an EST instruction.

[02:00:08]What?

[02:00:17]Wait, am I tripping?

[02:00:31]What the Are we serious?

[02:00:40]What?

[02:00:43]Wait, where? Why is this going wrong?

[02:00:53]The are studying this on your own or from school? Um, this is just completely on my own. Um, independent from like research stuff.

[02:01:09]This is so mysterious.

[02:01:14]Is this Wait.

[02:01:23]Oh, wait. We didn't we didn't implement it. Okay. This This is not mysterious anymore. Okay. Um, so this goes here.

[02:01:37]What the did I do? Whoa. Oh my god.

[02:01:40]Okay.

[02:01:43]Okay. So, we can do that.

[02:01:45]Let's go back here.

[02:01:52]So, this goes up here.

[02:01:56]Okay, there we go. First try.

[02:02:07]Um, okay.

[02:02:11]So, make install.

[02:02:14]Okay, that looks like it works.

[02:02:18]Oh, I don't want it to install all that. But what? Okay, that's not good.

[02:02:37]Okay. Well, we get to figure we get to figure this out next time.

[02:02:41]Um, so this is turns out we do need name scopes. That is that is a really good way of thinking about it, though. I'm I'm keeping that. I'm keeping that for future use.

[02:03:02]Uh, while we're at it, let's see if we can skip installing some stuff as well.

[02:03:09]Specifically, the tests or the test runner at least.

[02:03:24]I guess we don't necessarily install it, which is fine then. That's good.

[02:03:30]So, what happens if we bring J32 back?

[02:03:33]Oh, we already did. Okay, nice.

[02:03:41]Fix make file separate install stuff.

[02:03:54]Okay. Um, how do we format all again?

[02:04:00]Uh, what's up, Mike? Um, I got to head out soon. So, I'm gonna I'm gonna format all and then we're going to call it a day. I think we'll just do this.

[02:04:14]Um, let's see. Cuz we have to we have more format rules to enforce across everything, right? This is all source. Okay.

[02:04:29]took a nice three-day break. Yeah, I do feel refreshed. And um I also went to a research conference and I said hi to Matt Gladwell. It was really cool. Um Matt, if you're watching this, hello. I don't I wouldn't imagine you are, but yeah.

[02:04:46]Okay. Uh what did we do here?

[02:04:49]My new format rules.

[02:04:53]Okay, I think that is good for now.

[02:04:57]Uh, what's up playing? Yeah, God is a fire last name.

[02:05:05]Uh, Matt Godbolt, the guy that made this website.

[02:05:15]Um, yeah, we'll we'll find out if this passes checks.

[02:05:24]I don't speak a lick of C++. Yeah, I mean C++ is not fun. Oh my. More formatting issues.

[02:05:34]Are we serious?

[02:05:38]This has to be a bug or something. I don't know. Anyway, we'll worry about this next time. Um, is it is Bjorn's book a good place to begin? It probably is. PR is smart. Um, yeah, I got to head out now. Uh, one of my friends is waiting for me. So, yeah.

[02:05:56]Um, like the stream, sub to the channel if you haven't. Uh, join the Discord if you haven't. That's in the description.

[02:06:02]It's the best place to get pinged when I go live and stay connected with everyone else. Uh, my GitHub is down there as well if you want to add me there. Um, my LinkedIn is down there, although I haven't been on that in a second. I have like 50 connections that I need to like accept, but I'll get around to that. Um, and my GitHub sponsors is there if you want to give me money. Um, yeah, I'm going to go to the gym now and do the rest of the stuff I needed to do at night. Um, take care y'all. Take it easy. And I will see you all tomorrow for real.