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

Ajouté : 2026-05-10

[00:00:01]And we're live. Cool. Um, hello all.

[00:00:04]Hello world. It's been it's been a really tiring day. It's been a really long day, but I am here. Um, this is day 203 of studying compilers every day until I land a compiler role. Um, last last stream we were going to finish all the experts and then we ran out of time to finish um, binary expert or binop expert, binary op, whatever whatever combination of words you want to throw at it. Um, but we did finish uh, what's it called? We finished Oh man, I'm I'm really cooked today. Uh, we finished Uniop. So that was good. Um, yeah, this time we will we will get binary op done and life will hopefully be good. So, yeah, let's let's just keep chugging along. I guess that's kind of that's kind of how business is for now.

[00:01:00]Um, okay. I think we could yank some of this first.

[00:01:07]Uh, instead of get value, get left.

[00:01:13]Uh, and then we do left.

[00:01:16]And then instead of left here, we do right.

[00:01:21]And this will be interesting because we actually have to um we got to implement some new behavior. So that will be that will be fun. Uh, what's up, James?

[00:01:34]Um, I think we kind of got to do these like buffers again, which is really funny.

[00:01:40]Um, yeah, that's that's really funny, actually.

[00:01:49]Uh, what's up, Isra?

[00:01:53]I see I see I'm not the only one that's fried today.

[00:02:05]Um, okay. So, we have binary op Uh yeah, we can do this, I guess.

[00:02:20]Uh let's see. What else do we want to do in here?

[00:02:25]Yeah, I mean it it happens all good.

[00:02:30]Uh let's see where where is the pile? Or I guess we actually don't handle a lot of stuff interesting here. Uh, what's up, Panda? Good to see you.

[00:02:44]Um, okay. So, we want binary op and we have a lot of different things here now. So, we got to we got to handle things a little bit more interestingly here.

[00:02:59]So, yeah, I mean, you're you're here. That's that's all that matters.

[00:03:08]Um, oh wait, we can't actually do it like this anymore. Um, so right necessarily is a use, but left we got to we got to be careful with.

[00:03:19]Um, yeah.

[00:03:26]So, let's we could do a another switch block on this, but I don't know. It gets it gets really ugly really quickly. Uh, what type is this? This is value star. So we also want we also want a buffer for this. So left and then that or left is also putter.

[00:03:46]Um yeah, janky code. It happens. I'm I'm about to write some really scuffed code as well, so it will be fine. Um how'd you get your domain name for the GitHub page? Yeah. Um I bought it off pork button.

[00:04:02]So, oh man, this is bright compared to my room. It actually just lights up my screen. That's so funny.

[00:04:10]Um, yeah, you can you can search up domains.

[00:04:16]Uh, yeah, we love Pokemon.

[00:04:23]Yeah, I am just like full blind.

[00:04:27]Yeah. Um, some of these are a lot cheaper than others. Um, AI is always really expensive for some reason. Mom exists. There's some really interesting ones that exist, but yeah, I bought it off here and then I um I think I registered it with Cloudflare. I don't remember exactly what I did, but this is where I bought it at least.

[00:04:50]Um, okay.

[00:05:00]Let's see. We want to We want to yank this in some capacity.

[00:05:09]Let's yank that.

[00:05:18]Uh, okay. So, let's just norm We can do that.

[00:05:31]Okay, so now we can work off of this.

[00:05:33]Yeah, I actually just got Yuru flashed.

[00:05:36]Um well, I didn't get Yuru flashed cuz nobody plays Yuru anymore, but man, I'm now I'm sad.

[00:05:45]That that really sucks.

[00:05:48]Um okay, anyways, all jokes aside, let's see.

[00:05:53]Um, these are all simple and then assignment makes a mess. I believe that's kind of that's kind of how we're that's kind of how we're handling this.

[00:06:02]I think um yeah, so these are all straightforward enough.

[00:06:12]So then these we can kind of just uh we can kind of copy the code from above pretty much.

[00:06:23]Um, actually we don't need this like literal buffer anymore, which is really funny.

[00:06:30]So, we want to make unique of um uh Oh, we need to make a we need to make a No, we don't need to make anything yet.

[00:06:45]Uh, we got to store something eventually, but we'll worry about that in a bit.

[00:06:50]Um, oh, we got to get right as or we got to get left.

[00:07:00]Yes. So, we got to do this.

[00:07:05]I guess we have to do this anyways, right? So, it's just a question of if we use prep expert, I think, right?

[00:07:16]Yeah, we got to do this, I think.

[00:07:21]Wait actually. Yeah. How do we want to do that?

[00:07:29]So we the thing is we need to handle the case where it's an address operator I believe.

[00:07:44]Yeah. Yeah, I don't remember what my plan was for this, but we'll figure that out in a second. I'm fairly sure use prep expert. Okay, so we can do that.

[00:07:59]Okay, so we can instruction binary op.

[00:08:03]So give it what does this take again?

[00:08:11]Okay, well that doesn't help me at all.

[00:08:13]Um, actually, did it help me?

[00:08:18]Uh, wow, that actually did not help me.

[00:08:24]That's pretty funny.

[00:08:29]Okay, so let's look here.

[00:08:32]Yeah.

[00:08:37]Or is it was it actually just the topmost? It was actually the topmost.

[00:08:40]God damn it. Okay, so we have type up left and right.

[00:08:46]Um, so we have type uh actually we could yank type from like uh how do we get type up here again?

[00:09:08]Or I guess we just like assigned it differently.

[00:09:14]We'll worry. We should probably worry about this right now. Let's Let's try something different.

[00:09:20]Let's Let's just do this first.

[00:09:22]So, we have E get OP.

[00:09:27]So we want uh to MIR and we give it the OP and then left and then right like that.

[00:09:47]And then we need to handle some other stuff in a second.

[00:09:52]Uh a little late. Yeah. I mean I I keep pushing the stream back. I'm just it's just been a really tiring day. So, it is it is what it is.

[00:10:02]Uh do you ever use Jupyter Notebook? Um not really actually. I've never really like Jupiter. It's just been like I don't know. It It feels clunky to use.

[00:10:11]It feels really silly to just permanently store state in a notebook.

[00:10:18]So, I don't really like that. Um yeah, I don't know. It's just and also like I don't really write a lot of Python nowadays anyway. So it's like I don't the one advantage it has I don't really take advantage of I guess.

[00:10:33]Um if I were to like take notes digitally in some organized format I'd probably just use markdown. Um either markdown like on its own or like Markdown is like a part of Obsidian.

[00:10:45]Yeah, it's all it's all stylistic at the end of the day. You can do C++. I see.

[00:10:50]Wait, can you actually Yeah, it's like kind of awkward, but like even still, it's like when am I like writing code in my notes, right? I guess more fundamentally, the big problem is like I don't really like take notes of a lot of stuff. So like when I do take notes, it's just plain English.

[00:11:17]And if I'm just using markdown exclusively markdown, then it's like what's the point of using Jupiter, right?

[00:11:25]Yeah. I don't know. That's it's all it's all preference at the end of the day.

[00:11:29]But my preference is not aligned with Jupiter for better or for worse.

[00:11:42]Um, let's see. What do we change here?

[00:11:54]Wait, why did I cast this like that?

[00:11:56]Unop is a Oh, I see. Okay.

[00:12:01]Um, did you look at the QBE compiler? I did not, unfortunately.

[00:12:10]Yeah, I got I got code the right unfortunately right now.

[00:12:30]Okay, we can do that.

[00:12:33]Um, yeah. Okay, so that's good.

[00:12:40]We want to do this and then we want to yink the type.

[00:12:47]Actually, this is this is very awkward.

[00:12:53]Can we just do left get type?

[00:13:01]Uh oh, we can't do that.

[00:13:09]Um okay let's do expert types at e get leftft I believe h yeah how are we doing type let's just let's just yank the type from left seems wrong.

[00:13:45]Uh, so we want expert types at that.

[00:13:56]Yeah, we can do this, I guess. This is so ugly. I really don't like how this looks, but this is fine. We'll we'll worry about this in a second.

[00:14:06]What's wrong with this clone, I think. Or do you just want to get I think I think we should just do that.

[00:14:18]Oh, what's up, Panchchu?

[00:14:25]Um, how the hell did I do type here? We just did it by hand. Okay, great. Um but here we needed to do something interesting.

[00:14:36]Um why why are we see right? So we wanted to get we wanted to get the base. We can we don't really need to worry about that. We don't need to worry about that at all here.

[00:15:01]um to MIR.

[00:15:05]That's what we wanted.

[00:15:10]Uh I'm getting pinged somewhere.

[00:15:23]Okay.

[00:15:25]Uh, let's not be on that one so I don't leak esports stuff. Uh, college is about to start in a few weeks and my course is CSSE before starting CSSE. Um, you're you're new to school, right? I'm I'm assuming that's why you're asking.

[00:15:43]Uh, but if you're not, like if you're not, please correct me cuz I imagine the feedback will look very different.

[00:15:58]Uh, is this correct?

[00:16:01]Yes. Okay, that's what we want. Then we have type.

[00:16:10]Oh man, this is this is getting really unwieldy actually. Holy hell.

[00:16:16]Yeah. So, I guess we need the children first.

[00:16:22]I'm new. Okay, cool. Um, advice-wise, I think the big thing is just like the big thing is just to like pay attention. Um, it's really easy to like get sidetracked. And like whenever I go to classes, I am also like kind of guilty of this, but like a solid like 30% of the class is just doing whatever.

[00:16:39]whether it's like like scrolling your phone or like playing like Plants vs. Zombies on their laptop for some reason or just like texting people instead of paying attention. Um I do think it actually is helpful to like like you know like all your like study skills so I won't like prescribe anything on that.

[00:16:58]But I will say that like it is very easy to get distracted because with like how large class sizes are, professors genuinely just do not have time to like care. Um, and the upshot of that is um you'll it's very easy to like erode your own learning just by like being careless. So I think it's pretty important to at least like um make an active effort to stay focused whether that's like taking handwritten notes for a bit or like um making sure like you have Discord closed on your laptop for instance just like anything you can do to just like more actively pay attention. Um there's a lot of like intro classes I really wished that like um yeah I really wish I guess I really wish I paid more attention like if I in our like 111 class or like our first intro sequence class we learned about like lambda functions and I was like I don't I don't care about this so I just didn't pay attention and then it turns out I ended up getting into something that's kind of programming languages related and all of a sudden I really need to know about lambdas. Um you might like it everything might seem insignificant at first but like it's just nice to know stuff so pay attention. Um yeah all of this is just to say pay attention pretty much but be very deliberate with it.

[00:18:20]Um yes also it is true that you you'll very frequently be left to your own devices in terms of like studying. Um, yeah, that's that's kind of just inevitable and you'll you'll get through it, though. I believe you will.

[00:18:41]Okay. Um, let's see. Let's let's continue.

[00:18:46]So, this is all good.

[00:18:49]Um, what does our two MIR look like for for this case?

[00:19:01]What's our two MR for assignment?

[00:19:03]Actually, I I think we unreachable that, right? Is that what we did?

[00:19:12]Yeah. Okay. We just we just I think we just unreachable assignment. Yeah. Okay.

[00:19:18]So, this might this might cause some problems. Um Okay. So, how do we want to do this?

[00:19:34]Uh, if you're confused about anything, don't wait to ask for help. Yes. Um, remember that your professors are getting well, they're getting paid to be here at least. Um, whether um whether they enjoy talking to students or not is a completely different question, but like they are obligated to like help you if you ask for help. Um, hopefully your professor like enjoys teaching, but if if your professor doesn't, then like it's it's still all good. Like you can still probably ask for help as long as you like show an active effort to learn.

[00:20:05]It's really hard to like it's really hard to like turn down a student that struggling at least.

[00:20:13]Um, yeah, like the even just like anecdotally like Um, the way I got to where I am now, a lot of it stems from the fact that I just like cold reached out to my compiler's professor after taking the class and I was like, "Yo, I want to do research."

[00:20:32]And he was like, "Bet, let's let's schedule a meeting." Um, it is like really scary to cold reach out because like I mean like duh, but um, it will it will be fine.

[00:20:48]Want to start a startup, but it'll interrupt my academics. Uh, not necessarily. It's about It's all about just like how much time you want to put into it, right? So, um, okay, let's see. What do we want to do here?

[00:21:15]Yeah, time management. I imagine you probably already know why that's important and what you need to do for that.

[00:21:24]Um, wait. How did I do plus equals actually?

[00:21:36]Oh, we need to generate a different store. I see. Okay, that's that's what I needed to do.

[00:21:42]Uh, where you from? I'm from the US. I guess that doesn't really say a lot, but yeah.

[00:21:50]Um, oh man. Let's see. How do we want to do this? This is This is rough.

[00:22:03]Yeah. So, we want to reuse an allocate.

[00:22:06]So, we want to use this, I believe.

[00:22:16]Right. Um, or we have a help. We had the helper there, but we want to yank the body without making a load pretty much.

[00:22:32]Where did this go? Where'd I put it? Did I blind?

[00:22:42]Uh.

[00:22:44]Ah, here we are.

[00:22:52]Um, let's see how how the hell do we even do this from India? Nice.

[00:23:02]How How do I do this? Actually, this is very awkward.

[00:23:09]I guess we can just take the expert, right? That's just that is the value or the putter.

[00:23:21]Yeah. Okay. This necessarily is something assignable. Either like a pointer or like a stack variable.

[00:23:32]I guess we do need to load it anyway, huh?

[00:23:35]Best of luck. Nice to talk to you. Thank you. And uh best of luck to you as well.

[00:23:40]Um, college has definitely been like the highlight of my life. So, um, hopefully you will have as good experience as mine, if not better.

[00:23:52]Um, okay. So, we want to generate the load without the allocate, I guess.

[00:24:02]Um, actually, let's let's actually just make a helper that lets us like clean this up a little bit.

[00:24:11]Um yeah. So under our operator pile, let's do this is all fine and all. Let's do or not even there. Just like here bool is assignment.

[00:24:35]Yeah. So, this will let us avoid a little bit of this mess.

[00:24:40]Um, yeah.

[00:24:46]So, let's let's yank that.

[00:24:52]I think this kind of just goes at the top, actually.

[00:24:58]Okay. Um, yeah, this is going to look really funny. So, we're gonna We're going to yank all of that.

[00:25:13]Oh, I deleted the yink. Okay. Okay.

[00:25:15]Let's inflict that instead.

[00:25:20]Um, we're just going to do a little bit of this. These are not assignment.

[00:25:25]Return true or false actually.

[00:25:31]Or actually, let's invert it.

[00:25:46]Um, default. All right. Yeah, let's default.

[00:25:59]Jesus.

[00:26:02]Okay. Um, the reason I'm putting unreachable here is because the llinter gets mad. So, yeah, that's Yeah, that's that's a little bit rough.

[00:26:14]Okay. Um, all right, we have that now.

[00:26:25]Add is assignment.

[00:26:29]Cool.

[00:26:31]So, let's go back down here.

[00:26:38]Yeah. So, this lets us actually skip this giant switch block.

[00:26:51]So, we do that.

[00:27:01]Yeah. So then we can we don't even need these buffers anymore actually because this is just an if statement which is really nice.

[00:27:08]Um or we still need some of these buffers because we reuse value or we re reuse computation.

[00:27:24]Oh my god. Wait, I forgot we can just like make pointers for things. Actually, we can make autoputters.

[00:27:31]Oh, I got to wait. Now I got to I got to look over my code again. Well, god damn it. Let's Let's see.

[00:27:43]Um, I guess C++ auto putter or auto star explicitly forces it. Okay.

[00:28:00]I should probably do this more.

[00:28:06]I don't know. That's fine. We'll worry about that at some other time. And by some other time, I mean I'm adding it to this stack.

[00:28:16]What the hell? I should I should do it now.

[00:28:22]Star putter.

[00:28:26]Yeah. Okay. Let's Let's do a quick pass over everything actually. Oh, what's up, Jac?

[00:28:34]What type is this?

[00:28:37]That's an iterator.

[00:28:39]This doesn't work right. Okay. Yeah.

[00:28:47]Um, what does replace file name do anyway?

[00:28:54]It makes it Wait. Oh, I see.

[00:28:58]What am I doing here?

[00:29:10]What is current file?

[00:29:13]Oh, I see. We don't we don't care.

[00:29:14]That's fine.

[00:29:18]Okay, we don't need to worry about that one.

[00:29:22]I don't think we need to worry about it in these for the most part.

[00:29:29]Okay, this necessarily is a copy.

[00:29:33]So, that's good. That's also good.

[00:29:41]Yeah. Okay. This is I mean this is fine I guess.

[00:29:52]Yeah. I mean I can't fault any of this.

[00:29:55]This all looks fine.

[00:30:01]Okay. This is all very boring actually.

[00:30:09]Okay, that's a unique pointer. Okay, I guess none of this should change.

[00:30:16]Wait. Okay, that's a move. So that's fine. That's also move.

[00:30:21]That's fine.

[00:30:23]Let's actually work the other way instead.

[00:30:26]Yeah. Okay, this is all good. I'm fairly sure. Pop expert is a unique pointer.

[00:30:29]These are all unique pointers cuz we're making things Um, okay, cool. So, the parser is fine.

[00:30:42]Why am I doing this? This is like such a waste of time.

[00:30:48]Yeah. So, like we mark refs properly at least.

[00:30:54]Ah, here we are. This actually matters.

[00:31:02]Okay. Okay. And then we went back to the beginning. Okay.

[00:31:07]Yeah, that's something I want to get in the habit of doing. So, I guess it's probably better to do it than not, I guess.

[00:31:16]Okay. And this is the file we're working on right now.

[00:31:22]Um, yeah. So, like here for instance, this should be a putter.

[00:31:32]A putter.

[00:31:35]What is that? That is just a type which is an enum.

[00:31:44]Yeah. Okay. We can do that.

[00:31:56]All right. We can't do that.

[00:32:01]What is this? Actually, this is an iterator. So that's fine.

[00:32:14]Okay, that's also a vector.

[00:32:20]Yeah, I want to I want to get in the habit of doing this at least.

[00:32:29]pram. Okay, that's fine. That's fine.

[00:32:32]This should be a star.

[00:32:43]Um, that's good. That's good.

[00:32:50]Yeah. Okay.

[00:32:54]That's also good. That's also good.

[00:32:57]That's good. That's good.

[00:33:11]Okay. Do that.

[00:33:16]Oh, wait. I'm I'm tripping.

[00:33:22]Okay. And we run back. Okay. So, this is all good now.

[00:33:32]Um, okay. So, add puddters.

[00:33:36]Nice.

[00:33:40]Okay. Now that we've wasted like we've wasted like 5 minutes, uh, let's get back to actually implementing this thing.

[00:33:48]Um, okay. So, this time we're just skipping the giant switch block, which is very nice.

[00:33:56]Um, and then the rest of this I think we just got to we got to figure this out.

[00:34:05]Um, yeah. Okay. So, we want left putter in some capacity.

[00:34:25]Uh, we can delete the rest of this.

[00:34:29]We don't need this.

[00:34:32]Um, new to your channel. Could you please tell me how you started learning from scratch? Um, if you're talking about compilers specifically, I took a class from uh the school I go to and then I've been doing like academic research. Um, and then I've been like supplementing that with a couple books here and there. It's nothing like particularly like laid out or anything.

[00:34:52]I've just kind of been like slowly building up a mass of knowledge at least. Um, that's probably not the answer you wanted to hear, but I think that's the least inaccurate way to go about it.

[00:35:08]Did I delete too much here? Oh, wow.

[00:35:11]Okay. Yeah, we deleted way too much.

[00:35:14]Okay. Um, let's see.

[00:35:21]So, that's a value. That's good.

[00:35:25]Um, yeah. Yeah. So, we want to load from this at least, I think. Yeah, we don't have a load. So, this is fine.

[00:35:52]Uh, let's yank the load from up here, I believe, that we made before.

[00:35:59]Yes, we can do that.

[00:36:07]Yeah. So, we're going to do prev expert here.

[00:36:15]Um, why did I need this again? Oh, cuz that's the value. Duh. Okay.

[00:36:25]So, this is I guess left now.

[00:36:31]Okay.

[00:36:33]So then or I guess actually if e get op if that's binary op specifically just assign then we want to do something different or if it's not assign actually maybe right actually yeah how do we want to do this so if it's just assignment then we just store the value in there otherwise we need to like do an op I guess that's how we want to frame this I think um let's just figure out what we would need to do for a sign anyways So we have private exper which is I guess we should probably make that a putter.

[00:37:38]Yeah we h yeah actually no this makes sense. Um, test equals.

[00:37:57]Yeah, we're going to need to we're going to need to fudge with the terminology a little bit. So, we want prev expert.

[00:38:09]Yeah. So, we can do this again, I think.

[00:38:12]Or may as well just do dust just for correctness.

[00:38:18]Okay. So then we load from that and then we do left and right and then um oh we need to we need to track types still. Uh but that's fine. We'll worry about that in a second.

[00:38:42]I guess we can kind of just keep that college, bro. Yeah, that's that's a very succinct way to very succinct way to go about it.

[00:38:58]Um, I need to read something.

[00:39:14]Need to throw a tomato at someone.

[00:39:35]anyways.

[00:39:39]Oh, let's test. It's Yeah, it has been a second. Hopefully, we've been doing all right.

[00:39:50]Let's see.

[00:39:54]Yeah, this is this is very ugly.

[00:39:58]I guess this type will always be that. I guess maybe we'll figure that out later.

[00:40:08]Yeah, that Let's just dduplicate a little bit. Um, yeah, this this type thing is like really annoying.

[00:40:19]We might we might want a helper or we might just want we might just want to like make macros for this. I can't believe I'm saying it, but it would make things cleaner.

[00:40:32]Um, okay. So, we make a load. So, this performs the computation.

[00:40:39]Yeah, we don't need these buffers anymore for the most part, right?

[00:40:51]H wait no wait no we need to handle these differently now um so what if we do that let's just generate the code and then if we can dduplicate it then like that would be great but if not then like that's fine as well and we'll we'll worry about that in a second um Okay.

[00:41:22]Do we even care about this? Okay. So, we need to do that and then we need to generate a store.

[00:41:28]I guess here we It's like really awkward because we don't necessarily generate a store.

[00:41:34]I know. What am I saying? We always generate just let's let's just keep that. That's headache.

[00:41:42]We'll see what we use. We'll see what we don't use.

[00:41:46]Um okay. So we have that and then the difference is if we make a new pointer I believe.

[00:42:01]Yeah. Okay. So we can handle that separately though which is fine.

[00:42:09]We could even else if this even I think um yeah because assignment we literally just we take unobs and we just store the we just generate a store. It's very boring.

[00:42:30]Um yeah so we could just else if this Oh man, I can't type.

[00:42:45]Yeah. So, we can do that.

[00:42:49]Yeah. So, we can do that.

[00:42:52]I guess we don't even need dust, right?

[00:42:55]Yeah, we can we can figure this out in a second.

[00:43:01]Um, yeah. So we want to load from that and here we need to generate a computation I guess.

[00:43:18]Yeah. Okay. We don't actually Yeah, we don't need binop anymore.

[00:43:27]Yeah. As in we can auto that now at least.

[00:43:34]Um but we still need res at least. So that's the resulting computation.

[00:43:44]Uh then we can handle assign differently later on because that will just be very boring.

[00:43:53]Unless we could we could just else here even Okay. Then we have op assign standard assign or standard binary op.

[00:44:33]Okay. Uh what you working on today? I'm finishing the stuff that I didn't get to finish last time cuz I ran out of time last time.

[00:44:42]So that's kind of that's kind of how it is. Uh what's up bling? Good to see you.

[00:44:46]Um yeah, dark stream cuz well it's night time.

[00:44:54]Um okay so this will be very boring.

[00:44:57]Binopz is just uh it's just right.

[00:45:04]Yeah. Okay.

[00:45:06]So that's fine. Um okay. So now we need to generate the store which shouldn't be that bad.

[00:45:19]Um yeah, let's let's just yank all that.

[00:45:24]Um so if this is e get op equals binary op assign if it's an assign then we just do prev expert which we haven't overwritten yet. Otherwise we just make an allocate and that's the result of this and then we do that which is fine.

[00:45:53]Okay. And then store instead of this it's binary opres and we push that back.

[00:46:06]And then the type of this expression is I guess the type of the left that we've done. Yeah, I guess that's how we're inferring the type.

[00:46:19]Yeah. Okay.

[00:46:21]So that should be all the expressions at least.

[00:46:28]Um Okay. So this is binop rewrite I guess. Okay.

[00:46:37]Oh man. All right. Now we just got the rest of the stuff to do.

[00:46:43]Yeah, we have time. Let's Let's throw some more stuff at it. I want today I wanted today to be like a little bit short cuz I'm just really tired. But slash it's been a long day. But you know, we we keep going.

[00:46:59]Um yeah, how do we do this?

[00:47:17]Yeah. Okay. Um, expert is fine.

[00:47:24]Declaration is fine.

[00:47:26]Or not quite fine actually.

[00:47:29]We got to we got to do some mapping.

[00:47:35]So we want first of all we want scope bindings.

[00:47:41]So we want to what does this map again?

[00:47:44]This is very important.

[00:47:49]So we want the back. So we want the current scope.

[00:48:01]Um, so we want at i get variable and then get value.

[00:48:18]So we want that and then I think we assigned it to the alloc I think.

[00:48:26]Yes. So, we want the value because it's it could be a putter the way that we've written it.

[00:48:37]Wait.

[00:48:41]Oh, yeah. It could actually. Yeah. Okay.

[00:48:43]Um, god damn it.

[00:48:48]Could it be a putter? I don't think it can actually. These are necessarily variable bindings, so it has to be an allocator the way that I've implemented it.

[00:48:58]Okay, we can do that, I guess.

[00:49:01]Is there anything I missed here?

[00:49:06]No. Okay. Uh, did your instructor have to use a certain book? No, we just worked off the slides pretty much. Um, the slides were very, very rich. Um, they were more than enough for the homework.

[00:49:20]Okay, so we make the binding and we also need to make the type, I guess, right?

[00:49:33]Yeah. What what other things do we need to track here?

[00:49:37]We have scope bindings. We need to track the type.

[00:49:46]So types.

[00:49:51]Oh, we need to we need to make the thing.

[00:49:58]What type is this vector of unordered map?

[00:50:03]What's wrong with this?

[00:50:07]Oh, wait. There's no S there. Okay, this is very silly.

[00:50:16]Yeah. So, we just we just make a stack.

[00:50:29]We'll optimize this in a bit. And by a bit, I mean in a year, probably.

[00:50:34]Um, we we won't worry about that too much, you know.

[00:50:42]Um.

[00:50:44]Huh?

[00:50:48]Why did we need this again?

[00:50:54]Ah, right. Because we might need to get the type, but it's like the other the awful type.

[00:51:03]Get type get orget.

[00:51:12]Wait, what?

[00:51:14]Oh, that is already puddter. Nice.

[00:51:17]Okay, so that works.

[00:51:19]My room smells like like blueberry bagels for some reason. I did buy some today, but I don't know.

[00:51:27]That's a little odd.

[00:51:31]Um, okay. So, we do all that. What else do we need to keep track of?

[00:51:37]Scope, we don't need to worry about.

[00:51:38]We've done those two. Prev expert, we don't care about expert types, we don't care about function types, we don't care about, I think. Yeah, not in here. And function calls, we don't care about here. Okay, so I think that's all the state we need to map.

[00:51:57]Um, yeah. Okay, this all looks good.

[00:52:08]Uh the return we don't care about, I think.

[00:52:13]Yeah, we don't we don't care about this.

[00:52:18]Um and then we where do we get variable again?

[00:52:35]Oh yeah, we have get use. Okay. Yeah, that's the thing.

[00:52:39]Um, okay. So, we have to I think we have to map this somewhere. I don't think we have the infrastructure to map this yet.

[00:52:46]So, let's let's set that up real quick.

[00:52:49]Um, I don't know how I want to do this.

[00:52:57]Uh, set branch up for connecting basic blocks.

[00:53:02]Oh man, I don't even remember what I did for this the first time around. Um, the store looks fine though, so we can keep that.

[00:53:24]Yeah, this is really annoying.

[00:53:30]We'll worry about that at some point.

[00:53:32]Um, yeah. And then I think, what did I mean by map branch again? I genuinely do not remember this.

[00:53:43]Um, this is the fun of doing these rewrites.

[00:53:50]What am I mapping?

[00:53:58]We'll worry about that later. I think I think this is one and the same though.

[00:54:07]Yeah.

[00:54:14]Yeah. Let's do it that way actually.

[00:54:22]Um Maybe we also need to close the basic block.

[00:54:34]Yeah, we're going to need to figure that out. Actually, we we literally do this here. What am I saying? Um yeah, this this is fine.

[00:54:45]Yeah. Okay, we'll we'll worry about that later.

[00:54:52]Yeah, this should probably go there, I guess, then. Okay. Um, and now all we have left is just control flow, which I really don't want to do right now, but I mean, we didn't we don't quit things because we don't want to do them. So, we will we will chug along. Let's let's get this done.

[00:55:10]Um, okay.

[00:55:16]Listen, if so, maybe we should make like a start basic block and end basic block helper. I think that might make things easier.

[00:55:36]Um, yeah, that that might be smart.

[00:55:46]Um maybe every time we close a basic block we can do like resolution.

[00:55:58]Yeah, that's that's like n squ.

[00:56:00]That that would not be very smart. Okay.

[00:56:03]Um I know we definitely figure out like what the shape looks like up here. So we can kind of yank that in a way. I'm fairly sure.

[00:56:17]Yeah. Um, we definitely want that, I think.

[00:56:23]So, that's probably a good start.

[00:56:26]So, we want a true block, a false block, and a or continuation slash continue block.

[00:56:34]Um, okay. So ah that's annoying.

[00:56:50]I guess let's yank the con stuff first.

[00:56:58]So we can do that. Autocon star equals get or use prep expert.

[00:57:11]Okay, so that generates the condition and then we need to generate the branch.

[00:57:22]That's not going to be fun.

[00:57:28]Um con branch.

[00:57:43]So that takes what? Cond null putter. Null putter. Right.

[00:57:50]Okay.

[00:57:56]Yeah. So on that um let's see when associate the branch with uh let's see true and false basic blocks.

[00:58:21]Okay. So now we want to handle the true block.

[00:58:26]The true block will always exist. So we don't need to worry about it a lot.

[00:58:39]Um well we can just do this actually.

[00:58:48]Yeah. So then true block goes here.

[00:58:52]Um, we should close the basic block.

[00:59:05]Ah, yeah. Okay. So, Oh, man.

[00:59:17]So, we want that Instead of that, I guess condur.

[00:59:28]Yeah. So, we do that. We push that.

[00:59:35]Oh, I understand what I was saying now.

[00:59:38]Um to do uh associate or associate the basic block.

[00:59:55]Yeah.

[00:59:58]or I guess tag or I guess like or add basic block to mapping I guess more verbosely.

[01:00:15]Yes, we can do that.

[01:00:18]Uh yeah, maybe we should make like a close block, open block helper, I guess. Start block, end block.

[01:00:28]That would be helpful.

[01:00:32]Uh this lives here.

[01:00:35]Yeah.

[01:00:38]See, get type. We have all that stuff.

[01:00:41]Make params.

[01:00:44]Um, void start basic block and then end basic block.

[01:01:02]Is that how I set it up in this thing?

[01:01:07]Oh, I see.

[01:01:31]What do I need start a basic block for?

[01:01:36]Oh, wait. We actually did need it for something.

[01:01:40]Oh, to close the last block. Was this what this was?

[01:01:50]What? What was I doing? I don't know.

[01:01:52]That's That's very annoying.

[01:02:04]Yeah, I think we do actually need to like copy this structure a little bit.

[01:02:18]Yeah, we could we could just do that.

[01:02:20]This should be more clean to read.

[01:02:26]Um then this we actually need the unique pointer I think.

[01:02:50]Yeah, we can do that, I guess.

[01:02:58]Do we even need to do we even need start basic block? That feels a little bit ridiculous.

[01:03:09]Yeah, we can do that. I guess make basic block that also goes up with like we'll figure out how to organize this eventually.

[01:03:22]But that actually is an extreme problem.

[01:03:24]I think right now I just want all this to get done. So, um I guess we could figure out make pram.

[01:03:36]That shouldn't be that bad actually.

[01:03:42]Yeah, but that will that will happen later.

[01:03:51]Okay. Anyways, so we can do this.

[01:04:03]Yeah. So, we can kind of we can kind of yink that. I think that goes in here.

[01:04:27]Okay. And then, yeah, that looks reasonable to me.

[01:04:37]So, we just clear the buffer, I guess.

[01:04:43]Um, all of that just to say make basic block branch or stood move branch.

[01:04:55]Okay.

[01:04:58]Um, yeah. So then we can do this as well.

[01:05:09]Okay. So now we need to handle the true block.

[01:05:14]So uh yeah, how do we do this? We should look here.

[01:05:33]So we just get the body, I guess.

[01:05:41]Um, oh yeah, we need to handle this differently because we're making blocks.

[01:05:47]So, true branch and then false branch.

[01:06:02]Okay. So then here we just want I get T branch and then we revisit that and then let's see.

[01:06:26]Yeah. And then we want to make a basic block.

[01:06:35]once again. Or we kind of want to kind of want to do this.

[01:06:40]Uh actually yeah. So we can do that.

[01:06:50]So T to [ __ ] I guess.

[01:07:06]Um, yeah, this is going to be really annoying to map actually now that I think about it.

[01:07:30]Okay, let's let's just deal with the false branch real quick. This should be very straightforward as well.

[01:07:41]Uh instead of con, this is actually just terminator branch.

[01:07:50]Yeah, so we can do that.

[01:07:54]10 billion operator overloads for visit.

[01:07:56]Yes, we love we actually hate the visitor pattern, but we hate uh we hate object-oriented programming more. So we will we will visit until the day until the sun goes down.

[01:08:18]Yeah. Okay.

[01:08:22]Um yeah. Okay. And then the way we map this is we just do the next block. I think we want to map it to the next block.

[01:08:44]I believe I guess can't block.

[01:09:00]And we also want to do this as well.

[01:09:08]Okay. And then we can just move on here.

[01:09:10]I believe that's kind of I think that's what's happening here.

[01:09:19]Um so false or can't basic block.

[01:09:28]We could also just like generate an empty.

[01:09:32]That might be interesting, but this is probably fine.

[01:09:38]Okay. And now we get to we get to do wall loop which I don't remember what I did for that. Seems pretty straightforward though. So I mean surely it'll be fine.

[01:09:54]Um so we need to yank this as well and just do that.

[01:10:08]uh body. Let's go on the body block. And we want the I guess latch block, I guess, or cont.

[01:10:24]Okay. Um let's make the let's make the body So, you can kind of just do this as well, I think.

[01:10:49]Yeah. Let's We don't need the comment actually.

[01:10:56]Yeah. So, we can get the body.

[01:11:03]Yeah. So, we can do that.

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

[01:11:16]So, that jumps up to the cond.

[01:11:20]Oh, wait. We need a new block actually.

[01:11:22]Yeah, this this matters here.

[01:11:36]Um Uh what do we even call this?

[01:11:47]Trav to cond I guess.

[01:11:53]So we just have a branch np putter.

[01:12:06]Yeah. So then we give it.

[01:12:17]Yeah, this all makes sense now. So we can close that up. And then here we have the new block. We check the condition and then we load.

[01:12:32]Um, let's see what else do we do.

[01:12:42]So, we do this.

[01:12:45]Uh, this should be cond basic block.

[01:12:51]Okay. And then from here, the rest is just the next block pretty much.

[01:12:58]Yeah, I think this should be correct.

[01:13:02]Um, yeah. So, the only things left is like figuring out how we want to link these basic blocks up and then generating like parameters, which is like fine.

[01:13:15]Um, yeah, actually, we could do this map thing real quick.

[01:13:21]That should be pretty easy.

[01:13:27]Uh, we have a we have a map made for it already, I think. Yeah, we have function types, which should not be bad.

[01:13:37]And then resolve functions should not be that bad as well.

[01:13:43]Yeah. So, we can just loop through function types and that should be f that should let us resolve functions pretty easily.

[01:13:50]Let's actually do that real quick. So, function types at Oh man. Uh, we probably need to do this.

[01:14:01]Oh, actually no. We have the get name get value.

[01:14:12]So that we can assign to what type are we using? Looks like we're using the original type. What the wait.

[01:14:24]Oh yeah, we had a reason for that. Okay.

[01:14:28]Um, f get type.

[01:14:34]Yeah, we can do that.

[01:14:38]Yes, that's fine.

[01:14:43]Uh, we could even put this here.

[01:14:53]Yeah. And then we can do this here as well. That's fine.

[01:14:57]Um, and that allows for recursion when we handle a body, I guess.

[01:15:04]Yeah. Okay. So, now we can just do this real quick. This should be pretty easy.

[01:15:12]Um, also this needs to be a putter, I think. or no.

[01:15:17]Oh, never mind. We don't need to worry.

[01:15:20]Okay, so we have ID and uh type H. Actually, do we need this?

[01:15:36]Oh, wait. We forgot to actually map the damn functions. Whoops.

[01:15:45]Uh yeah.

[01:15:58]Uh let's see. And then where did we Oh, we just put it in resz.

[01:16:13]Oh, yeah. Okay, that makes sense.

[01:16:21]I'm not sure why we don't just make a I'm not sure why we don't just make one giant buffer for it, but that's fine.

[01:16:34]Um, yeah, I guess I guess there is a reason behind the madness. So surely this is fine.

[01:16:46]Uh instead of that that should just be function function star.

[01:16:57]It's ID function in functions.

[01:17:06]Um, yeah, maybe we should just like keep a ve a buffer of functions instead.

[01:17:19]Uh, but we need this mapping anyway, so it's like fine, actually.

[01:17:24]Yeah, it doesn't change a thing.

[01:17:30]Okay, let's map this real quick as well at actually function ids. Let's let's name it that instead.

[01:17:52]There we go.

[01:17:56]So at f get name get value.

[01:18:07]Um oh we need to worry about like overloading.

[01:18:12]That's really annoying.

[01:18:18]Yeah, I just thought I just thought about that. That's really annoying.

[01:18:25]So we can do that and then that will be fine.

[01:18:31]Okay.

[01:18:33]Function ids.

[01:18:41]So then otherwise we have uh auto star call in function calls at id call. We want to set ki to fun.

[01:19:10]Yeah, that's a very silly function. But I mean, I guess we need it, so that's probably fair.

[01:19:21]Um, yeah. Okay. So, that was that was easy enough.

[01:19:30]So, all we need to do now is figure out basic block edges.

[01:19:36]And we only have 19 to-dos in this file.

[01:19:39]including please bleach this.

[01:19:47]That's great.

[01:19:50]Okay. Well, I'll save the rest of this for next time, though. I'm I'm tired.

[01:19:54]Today's Today's been a really long day.

[01:19:57]Um, what did we add here again?

[01:20:05]Okay, so we added finish instructions map functions.

[01:20:20]Okay.

[01:20:22]Yeah, I think I think that's good enough for today. Um, thank you all so much for showing up today. Um, if you haven't already, like the stream, sub to the channel. Um, it really does help out a lot with the algorithm. Um, while you're down there, check out the Discord. Join it. It's the best place to get pinged when I go live and stay connected with everyone else in the community. Um, what else? Uh, GitHub in the description, LinkedIn in the description, GitHub sponsors in the description. Um, and yeah, I think I think that's about it. Um, yeah. Um, take care y'all. Take it easy.

[01:20:57]Um, I'm going to go get food now. Um, I will see you all tomorrow hopefully.