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

追加: 2026-05-24

[00:00:00]We're live. Okay. Um, hello all, hello world. This is day 210 of studying compilers every day until I learn a compiler roll. Last time we went back into CMake hell and it kind of worked out. I think it worked out. We I think we got all of that done surprisingly.

[00:00:17]So, um, there might be we might have to touch CMake like one or two more times in the future, but for the most part, it's actually like um it's actually a pretty good time. Um, this time we're going to go back to, I guess, finishing debugging our front end. Hopefully, if we can get this to a completed state. I think that'd be really great. If not, then like all good. Um, the overall goal here is to get it so our tests are roughly they reach roughly par with our original test output. Um, or at least referring to our regression tests. Um if we get the same output from the same inputs then we can say that everything is good to go. Um but if not then we can like I guess manually convince ourselves by hand. Um yeah so that's kind of where we're at right now. Uh what's up Isra?

[00:01:10]Uh good to see you. Um yeah so I've I think these are roughly the three things that we want to look at um that's causing all of our test differences.

[00:01:20]So get diff test regression.

[00:01:25]Uh specifically we're looking at star.mir.

[00:01:30]So we have some differences in like the ways that we generate um we generate labels because of like just some minor differences. It causes some like interesting there's some really interesting stuff happening. I need to figure out what's happening there. Um, there's some other strange stuff happening here and there.

[00:01:53]Uh, trying to find a good example of it.

[00:01:58]Um, let's keep looking. Yeah. So, here we have like some weird sequencing issues.

[00:02:07]Um, I'm not really sure why that's happening, but it happens. Um, we're going to need to figure that out, but it should be correct at least. So, I'm not completely concerned about it.

[00:02:21]Um, also something I'd like to do at some point is to rewrite the test to have like like actual printed output instead of just like instead of just I guess existing in a vacuum. It's a little bit awkward to a little bit awkward to verify correctness um at least after assembly.

[00:02:42]Um yeah, here's another example where we have some weird sequencing issue.

[00:02:49]Um yeah, and that affects some things which is a little bit concerning.

[00:02:55]Um let's keep looking more sequencing stuff here. We have like something going really wrong. Um that's a minus one which should not be valid.

[00:03:09]So we need to figure that out. And then like that's kind of like the big three categories. So yeah. Um I think the first thing to look at is probably like the or the continue block with if um or that might be the most annoying.

[00:03:26]So maybe we look at like the address operator because I think that's causing one of the things to uh one of the things to go wrong. So let's see. This lives in here I believe.

[00:03:41]Um H I guess this switch block really doesn't help actually. That kind of makes a mess out of things. We might have to just do an if tree just for arbitrary logic.

[00:04:00]Um, yeah, because I guess the big thing that's annoying me about using the switch block is that we have to like make these buffers appear um for temporaries. Uh, do you use fee nodes in your IR? Yes.

[00:04:16]Um, yeah, I have a very specific fee instruction that exists in Mir.

[00:04:22]Um, that was fee.

[00:04:27]Uh oh, I'm looking the wrong file.

[00:04:31]Yeah, here we are. But yeah, it it exists.

[00:04:38]Um, I was thinking about switching to like basic block parameters, but I was too lazy to make the change, so I didn't really think much more about it.

[00:04:48]Um, it also is like the LOVM like canonical solution. So, I think, sorry, um, at least for my goals, I think it made sense to just use fees and call it a day.

[00:05:03]Um, yeah, there was something wrong with address, I believe.

[00:05:16]and expected putter at zero. Okay.

[00:05:27]So then what is what is wrong here?

[00:05:34]I guess maybe we could we could split screen like this.

[00:05:44]We'll do that. Uh, get diff.

[00:05:48]There we go.

[00:05:50]Let's learn what they last night. Yeah, it's it's quite it's quite important for us to say because you got to we got to do the resolution at least.

[00:06:00]Um, short serving is still throwing me for a bit of a loop. I see. Um, yeah, I haven't actually looked at that yet, but I'd need to extend the front end more for that and I'm a little bit lazy. So yeah, I would that might be something that you could ask me about in a year, but probably not right now, unfortunately.

[00:06:21]Um, okay. Let's also just pull up the test here as well.

[00:06:30]Okay. Um, yeah. So, we're like looking here, I believe.

[00:06:41]So we have that load which makes sense I think. What the hell is happening actually? Why is why is there an extra load there?

[00:06:56]Or I guess we need that load necessarily, right?

[00:07:05]Wait, hold up. Wait. So, what are we taking the address of?

[00:07:15]Okay. Wait, do we even use that? No, we just don't.

[00:07:28]Wait, what the [ __ ] Oh, because use prime expert. I see.

[00:07:35]Okay, that makes that makes sense.

[00:07:37]Tornado warning. What the hell?

[00:07:42]That That sounds very Midwestern.

[00:07:45]Um, okay. We're going to we're actually going to take the time to bleach this.

[00:07:48]This is like this is genuinely irritating me now. Um, yeah. So, let's let's figure this out now.

[00:08:00]See, we definitely want this, I believe.

[00:08:03]Or I guess we necessarily Oh man. Okay, let's just let's just start from the top. We don't even know if we if type is what we want, but we definitely want to accept the value as a prerec.

[00:08:18]So So op equals e get op.

[00:08:24]And we're just going to avoid the switch block because that makes so much overhead mess here. It's just not worth that. It's not worth the headache.

[00:08:35]Yeah. So, we'll just do we'll do do things with a giant if tree.

[00:08:52]Uh we'll do um and then we can probably like else stood unreachable just as a catch all for myself cuz I am definitely going to forget to implement something.

[00:09:13]So minus we have not uh we have address and then we have DREF.

[00:09:28]I live in an area that gets tornadoes.

[00:09:30]Wow.

[00:09:31]I mean I guess like I don't know the the weather the weather is just really strange everywhere.

[00:09:38]Man, we love climate change out here.

[00:09:42]Anyways, depressing note aside, uh, let's let's figure out what to put in here.

[00:09:50]Um, let's see. What do we do after? At least we have an allocate.

[00:10:03]Or we definitely do that, I think.

[00:10:07]Yeah. So, we definitely need this stuff, I think.

[00:10:12]Uh, we'll worry about that after we clean this up though, I think.

[00:10:17]Uh, if it's unary plus, we want to use val.

[00:10:24]Um, what type is this? This is just unary op, right? Yeah. Okay, this is fine.

[00:10:32]Uh, what's up, Zach? What's the main goal here? Um, I am trying to I'm trying to I guess continue the whole test debugging thing as I'm removing MIR. So, the goal here is to make it so my tests or my test output is one to one with what it was before and then maybe we can start making some cleanup changes. Um, that's why I jump through like crazy hurdles.

[00:10:58]Where was it again? I think it's below here. Yeah, it's like this stupid thing.

[00:11:06]Um, the reason for that is to try and reach par. Um, hopefully we can get it to a point where that doesn't matter anymore and our tests are still accurate. Um, but for now, just to prove correctness, I want to make it match as close to 1 one as possible and then we can undo those changes.

[00:11:26]We gather in Argentina for 365. I could be convinced. Um, that might that might be interesting. That might be funny.

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

[00:11:44]I think this is fine.

[00:11:47]We can even move this. We could still move this out actually.

[00:11:55]Yeah, we could do this.

[00:11:59]So if op equals or not equals unary op df I think or address if it's not that then use prev expert other or I guess we should we should invert the condition so if it's address then just prev expert otherwise use prev expert Um, yeah. So, we could do it in this order.

[00:12:30]I think that might I think this will clean up our code a little bit.

[00:12:40]Um, okay. So, let's start with let's start with plus.

[00:12:49]I guess we could kind of keep a lot of this the same, right?

[00:12:58]Um, I guess we necessarily need to make this anyways, but the type changes inside of the block.

[00:13:15]Um, yeah. So, we do that.

[00:13:25]So you set type. We have Val still.

[00:13:31]Um, let's make a we should probably make a result buffer. So we kind of do need to we kind of need to yank this unfortunately, but it's it's less bad, I think. Uh, we can rename that instead because we definitely we changed up how we did binary op as well, right?

[00:13:56]Um, Jesus Christ, that's ugly.

[00:14:02]Um, let's just name it result and that will hopefully clean things up.

[00:14:14]So, result equals or res, I don't know.

[00:14:20]This is very neat code pill I think if you watch any neat code.

[00:14:26]Okay. So this is val.

[00:14:39]Yeah. So we do that. I think we need to yank that.

[00:14:47]Um okay. So next or do we care about type beyond this point?

[00:14:58]Um yes we care about all.

[00:15:04]So we want God damn it.

[00:15:13]Okay. Well this is this is really awkward all of a sudden. It might just be easier to keep this original structure then.

[00:15:26]Um, oh man. No, no, we're we're we're cleaning up. We're cleaning it up. We have to clean it up now. We have we absolutely have to clean it up. Let's just let's be maximalist about this.

[00:15:40]Um, okay. So, we've cleaned that up. Why exactly are you removing MIR? Um it was it was it was annoying to like uh it was annoying to maintain and it didn't pro it didn't preserve enough information and everything I needed it for you could just directly do on the anyway. So it was a little bit redundant at least in my opinion.

[00:16:03]Um so that's why I got rid of it at least.

[00:16:07]Um overall it's just like a cleanliness decision.

[00:16:12]Um, does AI help with compiler research?

[00:16:15]Um, sort of not really. It's definitely a subject of research at least. Um, cuz part of compilers research also extends to like tooling based around like static analysis for instance. Um, and there's like a lot of ongoing stuff about whether um whether AI is like able to use tooling output to the fullest extent. Um but aside from that like AI in the system space and by extension compilers is generally like as long as we have a way to verify the output. Um as as long as we can verify the output then it's perfectly fine. Um what's up rich? Did you hear about the produce 240 situation? I have not. Uh what what is that? I could I might look that up actually.

[00:17:14]Ah, I see.

[00:17:22]Um, wow.

[00:17:29]Uh, let's turn this into dark mode real quick. There we go. Much better.

[00:17:34]Self-report which assignments they used.

[00:17:36]That's crazy.

[00:17:41]Um, wow. Uh, what's up, Max? Um, also what's a harsh, uh, do you contribute to real compiler related projects in open source? Um, that's on the buck list for now. Most of my real world contributions beyond just like this toy compiler. Um, those are pertinent to research. So, our research lab has a couple projects and I contribute towards those.

[00:18:08]Wow, this is crazy.

[00:18:21]Yeah. I mean, like, this is I don't know what I'd even do in this situation. That's That's crazy.

[00:18:34]Oh, no. I just I care about y'all. I don't I don't want y'all to burn out your retinas.

[00:18:43]Wow.

[00:18:46]Okay. So, the the big idea I'm seeing here is just they they added a new cheat detection tool. We don't actually know how well it works, but it flagged a lot of people and that's causing a big deal. Is that kind of what's happening?

[00:19:04]watch parties. That's crazy.

[00:19:13]Okay, that's not really helpful.

[00:19:24]Um, okay. Sure. Well, that's that is a little bit insane. I can't lie.

[00:19:34]Um okay let's see so we need type as well here this is also uh casted like that what type is this middle and or I okay we can do it like this this might be easier senior engineer, you need to choose the right thing. Um, yes, that that makes a lot of sense. I think again, I'm mostly doing this right now just because it's like fun, but like yeah, open source is definitely on the list. Uh, one of the things I want to do with my research is to um, I guess my current big research project right now is making like a uh, building a independent like Rust tuning pass for LVM because it turns out there are a lot of IR differences. And part of that also involves like making an LVM blog post.

[00:20:39]So, um, that's that should be fun. Um, ideally I'd like to also get some stuff upstreamed, but we'll we'll end up we'll see how the scoping ends up going. Um, but yeah, I don't I don't want to like reveal too much at this stage. So, we will leave it at that.

[00:21:01]Um, okay. So, we have this. We're making all this stuff.

[00:21:07]Uh, res equals that.

[00:21:10]And we push this back.

[00:21:14]Okay.

[00:21:17]All right. Next up is not let's yank this.

[00:21:24]Yeah, there's I will do a big presentation at some point probably when I graduate. But um yeah, we'll see.

[00:21:32]We'll see how things end up going.

[00:21:40]Uh this makes sense. We need to set type as well. I think maybe we should just set type by default.

[00:21:55]Ah, that's the wrong Oh, whoops. Okay, there we go.

[00:22:05]We can just auto this at this point then.

[00:22:13]Uh, we could do this even.

[00:22:21]We could get really ambitious with this.

[00:22:25]Yeah. So, we can do this.

[00:22:28]We don't need that anymore. We need to update those.

[00:22:39]Um, yeah, we'll do this.

[00:22:46]And then let's see.

[00:22:49]This is res or wait. Yeah, this is just res now.

[00:22:59]We can split that up like that.

[00:23:10]Uh, how's the market like in America? Do you grind lead code in your free time?

[00:23:13]Um, it is still necessary, but I've been very lazy about it recently, just between like school and just like being a little bit burnt out to be honest.

[00:23:22]Um, so yeah, I've kind of just been like really slow about it. Um, it is definitely something I should pick up again though. I might I don't know.

[00:23:31]Should I start doing it on stream again?

[00:23:33]I feel like it was like really boring when I stared at a leak code problem for like an hour.

[00:23:43]I also just like I don't know. I feel like my process is not really like very streamable cuz I kind of just like I don't know. It's just like I like stare at the problem for a while and like I don't really explain things very well. I guess it would be good interview practice, but I think I would have to frame it explicitly as such instead of like relearning stuff.

[00:24:07]Um, oh man. Okay. There's there's a lot of stuff happening in the address thing or this is DREF. What am I doing?

[00:24:17]This goes here.

[00:24:20]Let's paste that there. Let's rename this or let's paste it there.

[00:24:32]D goes here. Um between a phone call and the cost of tornado warnings and missed your explanation about fee. Uh you're good. I haven't like I didn't properly explain it. Um, if you want me to like give a if you want me to like properly explain what phenotes are, I'd be happy to though.

[00:24:50]Um, oh man.

[00:24:54]Uh, let's see. So, here res equals val Uh maybe maybe we do just split this logic up. I don't know. That's really ugly. I don't really like it.

[00:25:21]Ask for tomorrow. Yeah, sure. Don't worry about it. Um or even just like off stream. Um if you wanted me to like type something up in Discord, I'd be happy to.

[00:25:33]Um address we store allocate putter or use the putter of wait actually how do we how do we represent address for like a temporary I guess it is just use the use the inner value address, I guess.

[00:26:07]Yeah, sounds good. Um, again, no rush on that either. Um, just at at your own convenience, I can I can try to cook something up. Um, maybe I should actually just like I don't know. Another thing I've been thinking about is making like educational content.

[00:26:25]Um, I think like uh one of the things I want to do is make more offstream videos. And I think like I'm struggling to think of good concepts for it. Um, at some point I want to build like a full compilers course, but I think a good place to start might just be like smaller concepts that are usually not really covered too too explicitly.

[00:26:47]Um, neither of my compiler classes, or at least the compiler class I took, never took uh never covered SSA. So, I think that might be something fun. Um, so SSA, FE nodes, um, I guess why they're useful.

[00:27:02]Um, I think that might be something. Um, if that's something y'all are interested in, u, let me know. If that's something you're not interested in, also please let me know. But also, if there's anything else you are interested in, please let me know.

[00:27:16]Um, yeah. I'm I'm always looking for more content ideas, but whether I actually get to do something with them is a completely different question. I watch Hell yeah.

[00:27:29]Yeah, maybe I do like I don't know. How would I even animate it? Unless I'm like scribbling on Paint.NET. I feel like that's a little bit too a little bit too sloppy for for the channel.

[00:27:42]Uh maybe I'd do some like maybe I do some animation like three blue on brown.

[00:27:47]We'll have to see.

[00:27:54]Um actually how would we do this?

[00:27:59]So if we have like if we have like fu plus two or if we get the address of like I don't know I guess it has to be a variable anyway.

[00:28:14]So this is like there's something drefocable or no something referenceable obviously.

[00:28:22]Um or like some sort of store.

[00:28:29]So I guess if it is just like a variable this should be fine.

[00:28:34]Um oh man animation library. Yeah I remember someone mentioned it before.

[00:28:39]Python animation library. I forgot what it was called. Yeah. Um manm I don't remember how it's pronounced. I think this is what's used though. Um if you remember like I'm not going to dox them. Um there's there's someone in my chat that was like messing around with menm.

[00:28:59]So yeah, I I might give that a shot. But then I have to write Python, so that's not really fun. Maybe if there's like a rust equivalent. I don't know. That might that might be a little more enticing all of a sudden.

[00:29:16]Um, yeah, I guess this is probably fine. We just need to figure we need to figure out how we do this.

[00:29:26]Um, can we just copy from alloc for dref or for address? Um, well, we haven't made the allocate yet or oh wait, I see I see what you're saying. Um wait yeah so private expert here so the val is I is um is the allocate putter if it's an address otherwise it's just the value um or the value in the uh the value in the address. So, we can just copy directly, which is what we're doing here.

[00:30:06]Um, we'll just do that, I guess.

[00:30:11]Uh, what's up, Jojo? Uh, why C++ and not Rust? Um, well, initially when I started this, um, part of the goal of this was also to get comfortable with C++ because a lot of like LVM's infrastructure is in C++. So, it's kind of like a necessary evil for me, at least for better or for worse.

[00:30:33]C++ is better. Hell no. Hell no. It is not better.

[00:30:41]Um.

[00:30:42]Oh god. What was I doing here?

[00:30:48]Jesus Christ.

[00:30:51]So this is a star. Planning to use LVM as the back end later. Um I'm not but I'm using this as practice for C++ because I will be like I'm working with LVM a lot on other projects.

[00:31:08]Um okay this makes sense.

[00:31:12]What the hell am I doing here? Why am I dynamic casting?

[00:31:18]Oh I see. I see.

[00:31:21]Um, wait, what?

[00:31:30]Wait, no, that doesn't make sense.

[00:31:41]Wait, what? What am I doing?

[00:31:45]Oh, I see. Obviously, it has to be a It has to be a putter.

[00:31:50]It has to be a putter if we're drepping it.

[00:31:57]Um, okay. Uh, how do we even split this up properly? I think this is probably fine.

[00:32:10]We'll just add a type checker later.

[00:32:14]LVM kaleidoscope tutorial. Yeah, that was that was way back in the day. Wow.

[00:32:18]So much has changed since then, actually. just in my life, which is really funny.

[00:32:25]Um, okay, this makes sense. Res equals that.

[00:32:33]So, that's a load.

[00:32:44]Let's just do putter of val or Oh, what the hell did I do? There we go.

[00:32:55]For now. Um, yeah. Well, thanks for stopping by. Um, I appreciate the support lots.

[00:33:02]Uh, and have a have a wonderful evening.

[00:33:09]Um, okay. I think we bleached all of this now, luckily. So, we can get rid of this slop.

[00:33:17]Um, this is mostly fine. This is just res now.

[00:33:22]There we go. Okay. So, hopefully that's all good now. Make build.

[00:33:28]Wait. Make install.

[00:33:34]Okay. And then let's Okay, let's let's make tests real quick just so we know nothing is crashing.

[00:33:47]Okay, we're we're good there. And then uh test regression generate regression tests.

[00:33:58]Let's see how this changes everything.

[00:34:00]Uh putter is very late in this list because many reg is slow as [ __ ] Yeah.

[00:34:29]Um, okay. There we go. So now if we edit. Okay, that fixes everything here, which is very good. And that also cuts down the list of tests a little bit more, which is also very good. So now if we diff again.

[00:34:48]Yeah, so we're just generating an extra instruction and that was causing issues.

[00:34:54]Um, is there anything? Okay, there's still there's still whatever the hell is happening here, but we've we've solved one problem. That's very good. We solved this and that only took half an hour.

[00:35:11]Um, okay. So, next let's look at whatever the freak is happening here.

[00:35:21]Oh, I see. Um, this was from the runtime library, I believe, right? because this is prototype and pre-process.

[00:35:34]Or at least that doesn't make a lot of sense to me. I'm not sure why this is happening.

[00:35:42]Um yeah, something looks a little wrong.

[00:35:52]Yeah, we'll worry about that in a second. Uh for now, let's I think it might be easier if we just start with the if continue block stuff. Um, it also looks like it exists in while, so I think we'd probably want to fix it there as well, or at least make some changes there. Um, yeah.

[00:36:18]Yeah, it looks like we just generate blocks differently. At least is why this is causing some weirdness.

[00:36:30]Uh what did we change here?

[00:36:34]Uh just that function pretty much. Okay.

[00:36:39]Uh source.

[00:36:41]Let's skip this for now. Skip this for now. Let's add all of that for now.

[00:36:50]Yeah. So that is just that little hunk.

[00:36:52]Then if we go up here, that should still be not added. Okay, perfect.

[00:36:58]Uh, let's see. So, we did rewrite unery oper We should just use the language bleach here because we use that in the comment. So, it'd be really funny.

[00:37:23]Um, okay. This all looks about right though, which is good.

[00:37:28]Uh, we're going to need to bleach this eventually as well, but that's a future task.

[00:37:35]Um, this this file is getting very very long.

[00:37:41]Okay. So then there is something going strangely with all of this.

[00:38:02]Um I think the SSA test also showed something odd happening. I think that's also part of what was happening here.

[00:38:10]uh runtime library like what what is happening here? Why is this breaking? This might be easier to look at.

[00:38:20]Um yeah, a lot of this is fine.

[00:38:30]And it seems to mostly clean up at some point.

[00:38:36]Yeah, like a lot of this is just like minute differences in block storage order, which is like fine.

[00:38:43]Um, yeah, I've been stuck on a bug for two days.

[00:38:51]Am I cooked? Hell no. That's That's fine. It happens. Um, as long as you're still working towards fixing it, I think you're fine.

[00:39:00]So, where' the SSA test go? It looks like it stopped breaking.

[00:39:07]I guess it did. Huh. That's really odd.

[00:39:13]I guess somewhere we had a bug and then somewhere we fixed it, I guess. So, that might that might be good. Um, are there any that don't get preserved after optimizations? It looks like everything everything after the optimization passes turned out fine given all these are just 00.

[00:39:37]Um h yeah I'm very curious what's happening on that like really big number though.

[00:39:47]So if we go back to this whole pile um what are we doing here I guess? How how is this happening?

[00:39:57]I'm I'm very confused by that. So, that might be something to look at. I think that's probably the next thing I look at now.

[00:40:06]Um, sorry, checking something.

[00:40:14]Um, okay.

[00:40:17]Okay. So, where is this even happening?

[00:40:20]Let's look at the pre-process test.

[00:40:26]Um, select pre-process oz mir use proto. Okay, so that's something to do with our prototypes, I think.

[00:40:41]Yeah, that's something that we flagged there.

[00:40:48]That's really confusing, though.

[00:40:51]What are we even trying to do with this?

[00:40:53]I guess that's the other thing that I'm very confused about. I think it might be easier to look at in the runtime library because we don't import anything here at least. Um, so that should make things easier.

[00:41:07]So, this is specifically with using Oh, wait. No, we definitely import. Yeah, we definitely import there.

[00:41:15]Um, maybe we make a separate prototype test. I guess we have that. And that turned out fine, right?

[00:41:24]Oh, no, it didn't. It definitely didn't.

[00:41:26]Okay, so it is that is what we want to look at then.

[00:41:30]Um, so for context, the original was this. So, we don't have any imports there. It's just these directly.

[00:41:43]I'm not sure what we're doing with those stores, though. I have no idea where those are coming from.

[00:41:50]Um, yeah. I I could not even fathom or I have no idea where those could possibly come from even.

[00:42:03]Uh, we're going to commit a sin and use the mouse for a second.

[00:42:11]Okay.

[00:42:14]So look what I just like this looks this looks ridiculous and it is really ridiculous. I have no idea why this is happening or where these stores come from. So let's um let's see.

[00:42:38]Yeah, that doesn't make a lot of sense.

[00:42:45]So, huh.

[00:42:53]Where could this possibly come from?

[00:42:55]Maybe call call expert.

[00:43:08]Oh, wait. It might be this. Wait.

[00:43:13]Um, no, we generate the stores correctly there. Maybe this is args. I think this is args.

[00:43:28]So, we're generating the arguments here.

[00:43:33]But what the hell are we storing?

[00:43:37]What types are these?

[00:43:43]That's a smart pointer.

[00:43:47]It's an expert.

[00:43:59]Wait, what? Okay. Wait. So what? It just what? How?

[00:44:14]Why are we What the I don't think this is the problem at least.

[00:44:26]Okay, let's let's break this test up a little bit more.

[00:44:38]So let's split this up like that. Return a plus b.

[00:44:42]Why is a register big integer? Yeah, that's that's what I'm wondering. We shouldn't even be generating these lines is the other confusing thing.

[00:44:51]Uh that's like that's really what's confusing me at least.

[00:44:56]So yeah, uh we'll modify the test.

[00:44:59]Let's just regenerate.

[00:45:11]Yeah, maybe this was not a wise choice for me. Maybe I should have just regenerated one specifically.

[00:45:32]Um, okay.

[00:45:34]So then, okay. So now they still exist, but we split it up a little bit at least.

[00:45:49]But wait, what the [ __ ] Okay, wait. I'm I'm so lost. I'm so lost by this.

[00:46:00]Let's just Let's go back to what this was before turn one. We'll just do that.

[00:46:16]And then instead of regenerate tests, we just test regression or do we have panic on the path?

[00:46:26]No. So source enable panic test input.

[00:46:35]This is what prototype.

[00:46:39]Okay.

[00:46:41]Uh oh.

[00:46:46]Okay.

[00:46:49]So now we can look at that file.

[00:46:56]Oh, we need to ozero this.

[00:47:00]Okay, there we go.

[00:47:04]So, we're still doing that. But why?

[00:47:07]What what could possibly be generating this?

[00:47:14]Like what what actually is what could physically do this?

[00:47:28]Is there something that I'm like missing?

[00:47:35]Do I need to clear args after this or like wait is there something really stupid that I'm forgetting in like here we make pams Uh, do I need to move res?

[00:48:16]There's no way it's this, right?

[00:48:25]Okay, we don't need to rerun the tests.

[00:48:30]Okay, it isn't that. Okay, so then why is this worked? I guess I guess this shouldn't be It definitely shouldn't be make params then. I think I think that's fine because this only breaks on prototypes. This doesn't like this doesn't happen anywhere else.

[00:48:55]So then maybe maybe in here somewhere I'm like forgetting something.

[00:49:01]Type name params.

[00:49:05]We do a thing there.

[00:49:14]Is there something I'm like missing?

[00:49:22]Oh my god. What am I doing here?

[00:49:34]What the [ __ ] Um, okay. Okay, I'm getting really confused now.

[00:49:43]Like this should just be one to one. We just don't make a body.

[00:49:50]And then declaration versus definition.

[00:49:53]Yeah, like this should be fine.

[00:49:57]It seems like it's fine at the top here at least, right? Wait, wait a second.

[00:50:17]I think this is probably fine. This should be fine. Um, okay. So then why is this breaking?

[00:50:27]What happens if we just return one here?

[00:50:38]Okay. So, it's still like going crazy for some reason.

[00:50:44]So, it's not even related to that. I think it's What the [ __ ] Is there something I'm like forgetting to clear?

[00:51:04]Like what is there? Like what state am I forgetting about?

[00:51:20]This might be a make params thing actually. Right. Is there another test I can look at?

[00:51:30]Like what the wait okay so if we okay let's let's not mutate this test more let's just write like we'll do that we can do that int use fu or R.

[00:52:01]Save that.

[00:52:03]Instead of that, let's just give it WTF.C.

[00:52:07]Or wait, what?

[00:52:10]Oh, duh.

[00:52:12]Okay, so now let's get rid of that.

[00:52:17]Let's look at this. Okay, so I think it is just related to prototype then.

[00:52:22]So just to be clear, if we get rid of this and then we rerun this, this works perfectly fine.

[00:52:30]So it has to do with the prototype.

[00:52:36]So why the I think it's keeping the parameters in the buffer for some reason.

[00:52:47]All right. So then if we make this like return zero does this break as well doesn't so it is exclusively prototype that is breaking that I think Wait. Okay. Wait. I think I have an idea. Wait. Make params. Yeah, we make an allocate here. Um, that modifies instructions.

[00:53:29]Okay, this makes complete sense now actually. So, okay, let me let me draw this out. Um, I'm very glad I figured it out. So, let's see. Where's paint on?

[00:53:39]Okay, I could just use epic pen to scribble, but that's a little less interesting. So we have a program here.

[00:53:49]Let's represent like this or like I don't know we'll make it smaller. It's like int fu. So this is a prototype and then we have int bar and some sort of body here. So what happened was ideally these are not really supposed to share state beyond like saving functions. The problem is between them I reuse a function that processes the parameters.

[00:54:22]Um and the problem here is that function which is make params it does in fact modify state. So it modifies scope bindings which is fine because we've accounted for that. Um so like in uh when we visit function definition we make a new scope bindings and then at the end of that we pop it off or yeah we do it down here and then we also do that when visiting prototype. So that's all fine. The problem is the other thing that this function does uh which is yeah up yeah up here it modifies instructions.

[00:55:04]So we necessarily push instructions onto our instructions buffer um after we make a function. That's not a problem because we just like we have this giant instructions buffer um that's fine because that gets stored in the memory representation for this.

[00:55:20]But when we're doing a uh when we're processing the parameters inside of a prototype that buffer doesn't go anywhere. So this just lives here for some reason now. Or the the stuff for that is like load or allocate and then uh and then store.

[00:55:44]So those just live in here for some reason. Uh because we don't clear it. So we need to do something about that.

[00:55:53]Um yeah, I would like to reuse state here.

[00:56:02]Um we could we could do some interesting stuff here.

[00:56:13]Um, yeah, we could give it a flag, which is like we could give it a flag and then have it change behavior based on that, but that seems kind of clunky as well. I don't really like that. I don't like passing flags to functions generally.

[00:56:45]Um, so what we could do is we could just separate this logic out actually.

[00:56:50]Yeah. So we just do this and then we could we could just do another pass over it in the function thing.

[00:57:00]Okay. Let's close out of this stuff real quick so we can get full a full screen here.

[00:57:07]Uh, so we just want to nuke this pretty much, I think.

[00:57:13]Yeah, we kind of just want to nuke all of this.

[00:57:17]Uh, we care about res. Yeah, all we care about there is resz.

[00:57:22]So, that doesn't change any of that.

[00:57:26]But, so now we want to go back down to here.

[00:57:33]So we make params and then for auto param in params.

[00:57:39]We'll figure out the substance of that in a second.

[00:57:44]Um what's wrong here?

[00:57:53]So we have pram type and pram name. I guess we need to keep that in some capacity.

[00:58:04]H. Okay, I kind of understand why I did it the way I did now. Um H yeah, okay, that makes a lot of sense.

[00:58:20]So these are just values now though is the annoying thing.

[00:58:26]So, we're missing pram name now in both of these.

[00:58:34]Um, unless we want to like iterate over it twice. That's a little bit annoying.

[00:58:42]Um, we might just want to make a flag then and call it a day.

[00:58:48]Unfortunately, I think that's probably just the path of least resistance.

[00:58:53]So, we want uh let's see what do we call this?

[00:59:06]Um um alternatively we could just throw away the computation.

[00:59:18]I guess we could instructions clear, I think. And that might also just work. It feels a little bit awkward. It feels a little bit slow, but it's probably fine.

[00:59:31]Yeah, this is probably just the easiest way to do it if we're avoiding like optimal.

[00:59:37]So, this should fix everything. Now, I keep doing make build. So, if we do that now and then we look at this, that's still broken. Wait a second.

[01:00:00]Ah, that's not that's not supposed to happen.

[01:00:09]So, we do that now. Okay, there we go.

[01:00:11]Perfect.

[01:00:14]Uh okay.

[01:00:17]So now if we do test regression generate regression tests.

[01:00:24]Um yeah let's wait for that. We can get rid of these now.

[01:00:32]That's such a funny change or a funny thing we forgot about statewise.

[01:00:40]That should fix up a couple more tests and we should be good.

[01:00:45]Doesn't do anything on function prototype. Exactly. Um, yeah, I just forgot to clean up in like some intermediate state on it. So that's that's fixed now hopefully.

[01:00:56]Okay, this list feels much smaller again. This is good. This is very good.

[01:01:02]So we just have control flow things to fix now.

[01:01:06]Um, do I want to tackle this today? I don't really want to tackle this today.

[01:01:11]I probably should though.

[01:01:17]Yeah, this is all just control flow now.

[01:01:21]But it's all like very minute changes, so it's like probably fine.

[01:01:29]And like as long as there's no like major bugs happening here, I think it's all good.

[01:01:39]Um, yeah, like these are all just like small reorderings for the most part.

[01:01:49]Yeah. Okay. I would like to clean this up, but I don't care a lot about it, so I think it's probably fine. Um, do you work on this off stream? I do not at all. Um, all the time I spend on stream is all the time I spend on this.

[01:02:02]Sometimes I do stuff off stream, but nowadays it's very rare.

[01:02:07]And even if it's off stream, it's all like very small things. So yeah.

[01:02:14]Okay. So we want not that, not that. We want that.

[01:02:22]Clear pram instruction buffer after prototype.

[01:02:31]There we go.

[01:02:34]picture last night that okay the funny thing is that uh with that is every time I get a CI/CD fail I get an email from GitHub. So that is just from the email.

[01:02:43]So I clicked on it because I was curious and uh we figured out we figured out exactly what caused that uh caused that run to fail.

[01:02:55]So yeah, that was that was pretty funny.

[01:03:00]Um, okay.

[01:03:03]So now, do I want to even tackle this?

[01:03:06]This feels like a lot of work.

[01:03:12]This This does seem like just a lot of work.

[01:03:19]Um, I think this is mostly fine.

[01:03:26]Um, yeah.

[01:03:35]I guess this is kind of just default handling. Anyway, I guess we should we should rename it as such.

[01:03:45]So, we should live. It lives here. I think this is probably fine.

[01:04:10]or I guess yeah, we'll just we'll just comment as such just to be simple with it.

[01:04:22]Um, this is fine.

[01:04:29]Yeah, this closes the block. That's fine.

[01:04:40]What happens if we just have an empty function? Actually, I guess we're not we're not letting that happen. So, this is probably fine, though.

[01:04:51]Okay. Um, do we want to deal with this reordering thing? I'm down to not do this actually or this misde pile cuz like this is just like a small block reordering, right?

[01:05:11]Like I really don't care enough about it. I think it's fine.

[01:05:18]Although I am curious about this top thing.

[01:05:22]this fib test um expected. Let's go to fib 0 mir.

[01:05:37]What did this change from? What are blocks 28 and Oh, I see. They're down here. Okay.

[01:05:43]Wow.

[01:05:52]So it does just this pile.

[01:05:56]So this is just kind of the same. Like it's it's literally fine. We just ordered the blocks differently.

[01:06:07]Yeah, maybe I should just make the print order like a traversal instead of just like storage order. I think storage order causes a lot of headache like this.

[01:06:16]Um, I guess there are some small differences though. Maybe I don't think it really matters too much in the big picture of things.

[01:06:25]Like as long as the logic is correct, it's fine.

[01:06:31]It might be shorter in some instances even like I guess maybe not. But yeah, like this is this is fine. You just move things around.

[01:06:49]I'm I'm comfortable saying that this is still correct at least.

[01:06:55]So, let's just commit some stuff.

[01:07:02]Okay. This um handle remaining basic block stuff update. Or actually, we should just we could probably just commit this.

[01:07:35]So now test regression generate regression tests make test.

[01:07:41]This should all just be fine. This should all pass unless we have some silly thing happening.

[01:07:49]Uh, many red is slow. So, this is fine.

[01:07:52]Give it a second.

[01:08:08]Cool.

[01:08:10]Okay.

[01:08:12]So that's all good. Now we can to-do which are the what are the ones skipping? Um I have like some of the tests rely on like custom uh custom pass input. So we have like this passes file that lists like what passes get run on a very specific case.

[01:08:32]Um all tests run on O and 01. We don't have O2 or 03 yet. But there's also this like this like S thing, which is I guess that like custom I guess custom passes. I guess I called it like select passes, which is like really stupid. But yeah, the ones skipping are just the ones that don't have these like specific passes, I guess.

[01:08:58]Okay, let's let's do the cleanup now.

[01:09:01]Let's let's do this damn cleanup.

[01:09:04]Um yeah. So let's do make allocate with type.

[01:09:17]This is star.

[01:09:20]This is that we don't need those anymore.

[01:09:26]Yeah, we can do this now. Make install All right. And then we can do test regression generate regression tests.

[01:09:38]Again, I want to see these like uh I guess granular changes in tests because I think that's pretty cool. So, we're going to do it like that.

[01:09:53]Okay, that's that's fine.

[01:10:04]Did that change anything? That didn't change anything. Am I insane?

[01:10:11]This should fail tests.

[01:10:19]Maybe we just have to rebuild. I don't know. The install script is causing other problems obviously. So yeah.

[01:10:31]We love Cmate. We We freaking love Cmate.

[01:10:35]Who am I kidding? We hate CMake.

[01:10:43]Okay, there we go. Um, that is actually crashing a test somewhere surprisingly.

[01:10:51]What the [ __ ] Okay, that's that's interesting.

[01:11:02]Why is that different?

[01:11:09]Why is that psychulting now? What the hell? Wait, that doesn't make any sense.

[01:11:15]That like absolutely should not be psyching. Oh, wait. I know why it's psyching. Duh. We still need to make the store, I think.

[01:11:24]Yeah, we we still need the store obviously. So obviously that's going to site fault. Uh that's not what I wanted to do.

[01:11:34]Okay, so we can do that. We need that.

[01:11:37]We just do that now.

[01:11:41]Okay, so this is more paradigmatic I think.

[01:11:54]Okay.

[01:11:58]Still sack paltting. Um.

[01:12:04]Huh.

[01:12:11]Make install. We're just going to keep re reinstalling it.

[01:12:17]There we go. Okay, first try.

[01:12:28]Uh this way we can like commit tests at the same time or changes to tests at the same time and then it's like really cool.

[01:12:35]Uh then we can see the changes as they happen as we clean this up.

[01:12:42]Oh yeah. What the hell?

[01:12:51]Why is that suck faulting now?

[01:12:57]What are we serious?

[01:13:06]This is This is ridiculous.

[01:13:16]What the [ __ ] Okay. Um, is there like an all buffer we need to clear now? Like, is that what's happening?

[01:13:33]Oh my god, there is an all buffer that we need to clear now.

[01:13:38]God damn it. What am I doing with my life? Why Why do I keep doing this? Why do I keep making the same problem for myself?

[01:13:47]Um, okay. This lives in here.

[01:13:59]Yeah.

[01:14:15]That should work. This better work. If it doesn't work, I will be very upset.

[01:14:38]Come on now. There we go. Okay.

[01:14:48]Okay, so these are just like small reorderings, which is like fine.

[01:14:53]I don't think that substantively changes a lot of speed.

[01:15:00]Yeah, like this is just a small reordering. I think it's fine.

[01:15:18]Maybe we shouldn't actually.

[01:15:22]We're going to We're going to do it.

[01:15:23]We're just going to use it.

[01:15:25]Um yeah. So, we're just going to use this in where where does this live?

[01:15:38]up here. Yeah. Make params.

[01:15:43]Okay.

[01:15:44]So, next change.

[01:15:50]Oh, man.

[01:15:53]So, we have five to-dos. This one we actually care about, I think.

[01:16:00]Um, reorder is like clean up stuff, I believe, is what I told myself.

[01:16:06]So this should be make allocate and this should actually be fine.

[01:16:12]This should like actually be safe.

[01:16:19]Guess we don't need that anymore.

[01:16:29]Um, do we even care about using this allocate anywhere other than just red allocate now?

[01:16:40]I guess not. That's perfect.

[01:16:44]Um, okay. So, we can just reorder it like this now, I think.

[01:16:52]Yeah. So, we do that.

[01:16:57]Um, yeah. Okay. This sequencing makes sense to me.

[01:17:14]Yeah, this looks fine. This looks fine.

[01:17:17]That's all clean up.

[01:17:21]Um yeah. Okay.

[01:17:27]So, let's reinstall it again.

[01:17:35]Regenerate tests.

[01:17:49]Give it a second.

[01:17:53]It's taking a second.

[01:18:00]Okay.

[01:18:04]Uh, let's diff the thing again just because I'm curious.

[01:18:09]Um, yeah, that's just that just changes the order a little bit. That's fine.

[01:18:13]That's that's perfectly fine.

[01:18:21]Okay. So what did we change?

[01:18:27]Use make allocate in function definition.

[01:18:35]Okay. So that cleans up our code a little bit.

[01:18:40]And then there is one more to-do which is very big.

[01:18:44]um is this thing this stupid thing.

[01:18:49]So I think we are good to just delete all of this and then uncomment that. Uncomment that.

[01:19:02]Uncomment that.

[01:19:04]Uncomment all of that.

[01:19:07]And then we should be good.

[01:19:11]And then this will change the test again. but not by a lot. This is just an ordering thing.

[01:19:23]Yeah, I I've been fighting this for a while, but I think I think I have finally won. I'm fairly sure I have finally won.

[01:19:39]Um, yeah, this should this should be good. This should be very good. I'm very excited.

[01:19:46]We couldn't get like full test parody, but I think this is as good as we were going to get. So then from here, like it's just clean up uh code cleanup and then making the new tests fit our format properly.

[01:20:03]Yeah.

[01:20:06]So, we'll let this we'll let this run.

[01:20:09]Hopefully, it finishes in the next 3 seconds.

[01:20:14]That was a little ambitious.

[01:20:16]We'll keep waiting.

[01:20:19]We'll keep being patient. We'll keep biting our time.

[01:20:23]Are slowly taking away time. That's like Yeah. Okay.

[01:20:30]Let's do this again.

[01:20:34]Yeah. So we just like we just change the order of evaluation here and there.

[01:20:43]Okay.

[01:20:48]Uh revert parody changes for binary op.

[01:20:55]Okay. So now we can actually like clean this up. I think I think there's a way we can clean this up. I don't know if there is a good way, but I think there is a way.

[01:21:05]Um, we did stuff at the top there.

[01:21:20]Uh, huh.

[01:21:25]Huh.

[01:21:27]Um.

[01:21:30]Do we use putter type anywhere?

[01:21:35]I guess not.

[01:21:37]Oh, okay.

[01:21:44]Yeah. Okay.

[01:21:46]So then uh Yeah. Okay. This makes this makes enough sense to me.

[01:22:17]Yeah. Okay. So, then we can we could probably move this up somewhere as well, just to be like cleaner.

[01:22:25]or more consistent.

[01:22:35]Yeah. So, now we can just like clean the rest of this up as we see fit.

[01:22:48]Uh oh, wait. We can't do that. Um this is fine.

[01:22:56]Okay. So we we have right, we have left.

[01:23:04]Um yeah. So this is fine. This is very standard.

[01:23:19]Oh, wait. Maybe evaluation order does actually matter here.

[01:23:29]Oh, wait. Hold up. Hold up. That might matter.

[01:23:36]Um, okay. Let's Let's see. How do we want to do this?

[01:23:54]H I don't know. We'll see like that is annoying. This is really annoying that it does matter in some way.

[01:24:03]Um yeah.

[01:24:16]So we can do left prev.

[01:24:23]We'll just we'll buffer it like this. I think and I think this will let us simplify things a little bit, right? And then this if we reorder like this, I think this is safe.

[01:24:44]I guess not. We should probably not do that.

[01:24:49]Okay. So, we'll figure this out as we go. Uh, what's up, Turing? Um, how do you start these projects? Um, you kind I don't know. I I don't have a great answer for this. You kind of just got to do it. You just got to like you got to jump in and just try to make something.

[01:25:05]Um, don't be scared if it sucks because it will always start up being terrible, but you'll make it better. You'll make better stuff as you make more things.

[01:25:13]Um, yeah, there's like I remember reading this like quote somewhere which is like the master has failed more times than the novice has tried or something like that. I think that at least guides a lot of my motivation. Um, and like it it might feel a lot like you don't have a lot of time, but like just setting aside a little bit of time every day lets you get consistent and just like sort of build up to something larger.

[01:25:42]Yeah, I don't know if I answered everything, but hopefully that was a little bit useful.

[01:25:52]Um, okay, let's see. So, this is fine.

[01:25:56]So, we just do left and right.

[01:26:00]So, we have load for left. right is necessarily this.

[01:26:09]Um, oh, we need to Oh, that's really annoying.

[01:26:14]Okay, we need to No, I I don't deserve a lot there. I can't lie.

[01:26:25]Um, okay. We're just going to We're going to do it like this.

[01:26:35]I think this evaluation order stuff necessarily mattered.

[01:26:42]Um, can we just get reset soft head till the one?

[01:26:54]Okay, so all that's still staged.

[01:26:58]we can update tests and then we can see if that changes anything.

[01:27:03]Um yeah, so this is kind of just like clean up in a way as well.

[01:27:13]Um yeah, okay, this makes sense to me.

[01:27:22]So then we want uh we can do that.

[01:27:39]So that we just load from the putter and then we can do that.

[01:27:48]Yeah. Okay.

[01:27:56]Um, yeah. Okay. The rest of this looks fine to me at least.

[01:28:09]Yeah. And then this is very funny at least.

[01:28:14]Um so we don't care about we don't care about computing a lot of stuff here I think right this is just assignment so we don't care about left that much I think yeah we don't care that much about it Um, yeah. So, we can do this. That also lets us like decouple prev expert stuff as well, which is probably good.

[01:28:55]Yeah. So, that is a putter to the temporary. So, this is probably fine.

[01:28:59]Um, yeah. Okay.

[01:29:11]Right. Wait, hold up.

[01:29:18]I think this is correct. I'm fairly sure this is correct. Um, yeah. Okay.

[01:29:25]Oh, man. Okay.

[01:29:31]So then we want this again.

[01:29:49]We can just simplify it like that even and then let's see what this changes.

[01:29:58]And hopefully everything is fine.

[01:30:04]Um, actually, let's Okay, here's what we're going to do. We're going to recommit this.

[01:30:13]We're going to push and then we can re-revert that.

[01:30:26]And then we can test regression generate regression tests. That might change some things. If it changes things, then we can make a comparison.

[01:30:36]Um, yeah, it'll be it'll be really cool if it just like undoes the changes actually.

[01:30:43]I think I've like written it in a way such that it does just undo the changes, which is really funny. Um, if it does undo the changes, then we are in a very good spot. If it doesn't, then like that's also fine.

[01:30:58]Okay. So then add test.

[01:31:01]Okay. It just undo it undo the changes.

[01:31:03]That's so funny. Okay. That actually makes me very very happy.

[01:31:16]Um yeah. Yeah. So we can just recommit with the same error binary op but then rewrite it to be clean and unrevert them.

[01:31:42]Get push force. We're just going to force push. Call it a day. Okay.

[01:31:48]So make test. This should all run. It fails one test. That's not good. If it's the test that has just always been failing, then I care a lot less about it.

[01:31:59]Yeah, it is just the one test that has always been failing. That's That's fine.

[01:32:03]We'll we'll worry about it later.

[01:32:06]Whatever.

[01:32:07]If we rerun it again, I'm pretty sure it'll be fine as well.

[01:32:12]Uh while we're at it, let's see if we can just get this merged at least.

[01:32:21]Okay. Um, panic.

[01:32:27]Oh man.

[01:32:37]So we start or we write front end to use new coding or new style or modify.

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

[01:32:56]Flatten the history. Nah.

[01:33:00]Or at least I I rebase. But we're just we're just force pushing over the old commit and call it a day.

[01:33:07]Um, let's see.

[01:33:12]Wow.

[01:33:14]Okay, so we did that stuff.

[01:33:19]Um, and then we nuked HR.

[01:33:26]We just go from KC to MI now.

[01:33:33]Um, yeah, that look that looks fine.

[01:33:39]And let's rerun the tests just just for fun.

[01:33:45]Yeah. Okay. It's just going to keep failing that. That's fine.

[01:33:48]I'm not sure why that fails. We'll worry about it some other time. And I think I think this should just work as well is the funny thing.

[01:34:06]Yeah. So, this fails the format check as well, which is really annoying. This should not fail. I might just like ah that irritates me to no end.

[01:34:22]What?

[01:34:28]What claim format is this?

[01:34:39]Like are we serious?

[01:34:44]Like this isn't here.

[01:34:47]This is what line.

[01:34:51]Yeah, it's saying this formatting is wrong. But obviously when I format it, it changes it to that. So like what am I meant to do here?

[01:35:01]We'll just Oh my god, that irritates me so much.

[01:35:09]Why the [ __ ] I shouldn't do that.

[01:35:21]Okay, let's let's see if it passes the other check. At least if this passes, we're good and we can just commit at least cuz I'm lazy.

[01:35:39]One of them has pseudo pre-install while the other doesn't. What the hell?

[01:35:44]Yeah, that is that's so cooked.

[01:35:48]Wow. Yeah, that that really sucks. Holy [ __ ] Wow.

[01:35:54]Um, also what clang format.

[01:36:00]What version is this? 22.

[01:36:05]No tests were found.

[01:36:08]Are you serious?

[01:36:11]Oh, did I?

[01:36:27]Oh, I see. So, I need to I need to fix this real quick.

[01:36:32]Oh, man. That's so annoying.

[01:36:36]Oh, yeah. That's also something I need to add real quick to the thing.

[01:36:43]Um, cm make hell install enable file etc. Why?

[01:37:01]Oh, maybe I need maybe I do need to do it in this order then.

[01:37:13]What do you mean?

[01:37:18]What do you mean that didn't?

[01:37:24]Are we insane?

[01:37:35]Uh non-coding person here is compiler job. Um no it is it is just software. Um I'm looking for a I guess compiler engineer role is like the more accurate form of the title but wow I didn't want the title to be that much longer. So compiler role it is. Um, compiler is in the software, not as in the not as in like someone that compiles things.

[01:38:01]Um, yeah, apologies on that.

[01:38:08]Um, h yeah, this is annoying. This is really annoying.

[01:38:26]This does not run the tests.

[01:38:29]What does it do for build? This doesn't install, right? It doesn't look like it installs.

[01:38:45]Uh, maybe this will work.

[01:39:01]Why is this taking so long? Uh, do you have VPS for testing or you doing it locally? Um, I'm just using a GitHub runner. Um, I should probably set up something like more elaborate, but it works fine enough. And I'm just using like GEST uh for like local testing.

[01:39:19]It's all just like it's all just like automating some basic tests. So it's not like anything particularly fancy, but like it'd be cool at least.

[01:39:29]I'm not sure why this is struggling.

[01:39:34]Oh man. Okay, there we go.

[01:39:38]We made progress.

[01:39:41]This will take forever to run.

[01:39:47]So we can see test.

[01:39:55]Why doesn't this used to work?

[01:40:03]This used to have like actual testing or actual automation, but I changed something so it broke.

[01:40:11]We changed a lot of things actually and a lot of things broke. So I guess that makes sense. Uh can you hypothetically compile things fully manually? Um yeah.

[01:40:22]I mean like in some sense that's kind of what we already do when we like write um when we write code, right? Like we're we're compiling from like our abstract ideas down to like a language. But even just like writing assembly or like translating C code by hand um you could consider that as compiling.

[01:40:47]Isn't that how the first compiler was made? Yes. Yes. Exactly.

[01:40:57]Uh okay. It has to be this.

[01:41:05]Oh, this is this is what broke. Okay.

[01:41:08]All right. So then why is this borked? This should be fine.

[01:41:14]This should be perfectly fine.

[01:41:21]C test not finding tests.

[01:41:27]Um, this doesn't wait what that a This is what we changed.

[01:42:03]Are we what?

[01:42:09]Let's just make build instead of installing and then let's see if that works cuz this should theoretically work at least.

[01:42:36]Why is this so slow? Oh my god, this is actually like pissing me off a little now.

[01:42:48]Like, are we are we kidding me?

[01:42:52]Please.

[01:42:59]Okay. So now C test.

[01:43:15]Wait. What?

[01:43:22]H.

[01:43:30]Oh, we don't even need that anymore.

[01:43:34]Yeah. Why? Why did this break? When did this break?

[01:43:56]Did we change?

[01:43:59]We didn't change anything really here.

[01:44:03]Maybe we changed Ah, no, we didn't change anything.

[01:44:09]Why is Why doesn't that work then?

[01:44:18]Like this doesn't change anything.

[01:44:22]Unless that was like trying to install or we can ignore that hell. That's like its own misery.

[01:44:44]Yeah, I don't use C test, but I guess this stuff does for some reason.

[01:44:51]Build is fine.

[01:44:55]No, it was definitely fine before I feel like because I remember seeing a bunch of really slow output, which would mean that it necessarily works. So, if we go to like our old pull requests, close. Let's go to like back here.

[01:45:13]If we look at the run for this uh checks, there we are.

[01:45:24]Yeah, like we had a bunch of output here. So, it was definitely working at some point.

[01:45:29]I don't know why it stopped working.

[01:45:36]Does does it make sense why this is like so confusing now?

[01:45:41]I wonder if it has something to do with like the install stuff actually.

[01:45:56]What happens if we use release actually?

[01:46:09]So let's let's see uh GitHub Ubuntu latest Is there non YubUbuntu that exists?

[01:46:31]No.

[01:46:35]Great.

[01:46:56]H. Is there a better way to do this that doesn't I think there might be a claim format version difference that's going wrong here.

[01:47:14]Yeah, we'll worry about that in a second. For now, this is the bigger concern.

[01:47:27]Okay. Um, so let's look let's compare it to like what we have in here.

[01:47:42]So what happens if we change the build type then?

[01:47:52]What happens if we dash J32 here as well? Just for fun.

[01:48:06]Yeah, let's do let's do that. Let's be evil.

[01:48:10]Um, yeah. I'm not sure. I'm not sure what's happening here at least with C test.

[01:48:25]Okay. So, I think we just got to fix C test then.

[01:48:30]What's in this testing directory? It's just temporary.

[01:48:34]Okay.

[01:48:38]I'm I'm curious if J32 will do anything.

[01:48:41]So, we'll we'll see. But um H.

[01:49:01]Yeah. So, we add these things. That makes sense.

[01:49:08]Right. Yeah. See, we make a library called middle end, right? Like this should just work. This really should just work. I don't know why it doesn't just work.

[01:49:48]Like we we did this. Maybe we need to do this before that as well.

[01:50:07]Let's do this.

[01:50:10]It's going to hang again. Oh, okay. It didn't hang. Let's go.

[01:50:15]Um, make C test.

[01:50:18]Still doesn't find any tests.

[01:50:25]Uh, do you draw the profile picture yourself? No. Um, I just I took a goose.

[01:50:34]Yeah, I didn't I didn't do any drawing.

[01:50:47]Wait, what?

[01:50:56]Wait, this should be fine. We should just look in build.

[01:51:05]What do you mean no tests were found, though? That's really strange.

[01:51:12]Okay, let's uh Okay, let's let's keep looking.

[01:51:27]Oh, what the hell?

[01:51:41]Okay, wait. Sorry. I'll I'll rehat in a second.

[01:51:48]Uh, set wrap.

[01:51:51]So, we have include this.

[01:51:57]Oh god. Yeah. So, these should exist.

[01:52:04]So, why isn't it working?

[01:52:13]This This literally does exist here, right? Am I going insane?

[01:52:27]Oh god.

[01:52:29]Oh man.

[01:52:34]Little test regression regression tests.

[01:52:44]Yeah. So, this runs. This literally runs.

[01:52:50]So, why isn't it being picked up?

[01:52:52]Anyway, um what's the goal of the current build? Um, I'm making a compiler from C to x8664 and I'm trying to recreate a lot of like LVM's existing infrastructure. Uh, why don't use Linux? I'm using WSL right now, so I'm working in like a Fedora environment, but I'm just too lazy to dual boot and I play Valor, so I kind of want Windows around. Um, yeah, my laptop is running Arch, but I'm obviously not going to stream off of that if given the choice.

[01:53:26]Yeah. So, why isn't this finding it?

[01:53:31]Okay. So, there we go. So, we just have to change that. Same from day one. Um, I had a couple of like I took a tangent somewhere in the first week or two for like uh to work on like LVM's kaleidoscope tutorial, but for the most part, it's been focused on this project.

[01:53:54]Okay. So, do we just need to change the C test directory then? I think I think that's what we need to change then.

[01:54:12]Workflows testing.

[01:54:19]Um, can we just CD build and then do that? Is this a thing we can do?

[01:54:34]Or wait, let's change this real quick.

[01:54:45]Uh, C or fix C test.

[01:54:51]Let's see if that works.

[01:54:54]I hope this works.

[01:54:58]It's going to fail the damn formatter again. Obviously, it's really irritating, but it's fine.

[01:55:11]Although, why is it taking so long?

[01:55:13]Okay, there we go.

[01:55:16]All right, we'll we'll wait for paint to dry. Use lazy git. Um I prefer command line.

[01:55:27]Yeah, I like tried using some form of git in neoim and I just I don't know. I just couldn't get used to it. Command line is portable. Command line will always be there for me.

[01:55:42]So I I may as well just stick to it.

[01:55:52]Are we serious?

[01:55:58]You ever work with ML? Um, I'm going to um hopefully I will be taking a class in the fall where I get to mess around with it. Um, but I have not up to this point.

[01:56:08]No.

[01:56:13]Um, okay. Okay. Why is this failing then? What what directory does this live in?

[01:56:28]Where is this building?

[01:56:34]Cake build.

[01:56:40]Oh, wait. That should just work.

[01:56:45]Right.

[01:56:55]Am I stupid or like this? Should work.

[01:56:59]So, or wait, what? What the f?

[01:57:06]Wait, I'm so lost.

[01:57:14]So that is the working directory. So we've what the [ __ ] This should just work.

[01:57:35]Let's see. um choosing a single main OS and studying cyber. Um I don't know. It's I feel like that's more just like personal preference at that point. Um Arch has been fun because I like the customizability, but like I think Fedora is perfectly fine.

[01:57:54]Um there's like that one very specific Dro that like everyone says is like the hacker Dro. I don't remember what it was called though.

[01:58:01]Um, it's called Yeah, Kali. That one.

[01:58:10]Uh, what's up, Siki?

[01:58:13]Um, apologies if I mispronounce your name. Uh, you'll make it. I appreciate it a lot. Thank you.

[01:58:21]Uh, do I need to do this then?

[01:58:25]It's in 3.9, so we can just do this.

[01:58:35]Right.

[01:58:47]This should just This is so annoying.

[01:58:57]So, why doesn't test work?

[01:59:05]Or how do we Is it worth the effort?

[01:59:37]Let's see. Is there a better CMake with C test? Okay, this might be closer to what I'm looking for.

[01:59:51]Okay. So, this doesn't help me because it doesn't tell me what went wrong.

[02:00:03]Okay. So, Huh.

[02:00:21]What if we just rewrite this?

[02:00:47]This should be fine.

[02:00:50]Unless maybe I want to move this to the other directory.

[02:01:11]Uh okay, that's all running. So now C test.

[02:01:31]Oh.

[02:01:41]Um.

[02:01:47]Oh, okay. So, we're just we're just running it in the current directory, which obviously isn't going to work.

[02:02:09]Um, okay. Wait.

[02:02:14]See you. Test. Test. Dur.

[02:02:21]Okay, there we go.

[02:02:26]Do we just need to like change the That's so annoying.

[02:02:34]So, let's go back to workflows.

[02:02:41]We have this.

[02:02:44]I think J32 worked. Ironically, it looked like it was fine, which is really funny.

[02:02:55]Uh we we'll look at that again closer later.

[02:02:59]Um what if we just do uh what did we do again? dash tester.

[02:03:24]And then we can just yink that or just push.

[02:03:45]Sorry. We're going to force push like a like a good student.

[02:03:52]Hopefully this works so I don't have to babysit this even longer.

[02:03:59]This is This is getting a little old. I don't know. Just Just a hunch. This is getting a little bit old.

[02:04:17]Okay, it looks like dash J32 did not in fact do a lot. That's very unfortunate.

[02:04:24]I guess it doesn't hurt to have though, so we may as well keep it on.

[02:04:31]Also, I have a blue Jolly Rancher here.

[02:04:35]I don't want to eat it on stream because that would be annoying.

[02:04:39]Well, what's what's Ys's like Jolly Rancher flavor ranking?

[02:04:43]Do we do we like blue? Do we think watermelon is the worst flavor? Okay, it works now. Wait, let's go.

[02:04:53]That's quite fast actually.

[02:04:59]Red on top. That is respectable. Um like cherry red, not like watermelon red.

[02:05:07]Um, okay. That worked. Perfect.

[02:05:11]God damn it, I hate C test.

[02:05:16]Um, is there something we can clean up with here?

[02:05:21]Maybe we could edit this workflow file install or install claim format. H I don't know. I don't care enough about this. Can we like rewrite this to not do this? This is like really annoying me.

[02:05:48]We'll just I don't know. We'll just ready for review. Ranking for Gushers.

[02:05:54]It's been It's been so long since I've had Gushers, so I don't I don't actually have a good opinion on them.

[02:06:01]Uh, is this all we needed here? I think I think this is good.

[02:06:06]Right. Is there anything else?

[02:06:09]I don't think so.

[02:06:12]Okay, we'll just rebase the merge and call it a day.

[02:06:16]Yippee.

[02:06:18]Okay, that's that's a lot of commits, but they are all there now. I'm going to get another email about this Chud thing failing, and it's going to be great. Um, yeah, we'll we'll worry about that later.

[02:06:34]Um, yeah, I think that's a pretty good place to call today's stream, though.

[02:06:38]Um, next time we're going to continue the big rewrite. Um, if we look at our list of objectives, all of this is done now. So, this is all we need to do. I think this we figured out already. So, we don't worry about this.

[02:06:52]Um, what was I doing here?

[02:06:57]Yeah, we don't care about this. We've fixed all that.

[02:07:01]Okay. So, this is this is our like stack of stuff that we're working on. All of this is in a goal to get DREF generating and then implementing arrays.

[02:07:11]Um, yeah. So, we're going to pop this off the stack.

[02:07:17]Um, and clear our buffer by accident, so we have to redelete it.

[02:07:23]Um, yeah. So, we can do this now.

[02:07:27]Um, yeah, I think that's all we need. Uh, do you understand hardware as deep as you do software? Um, I need to learn more about hardware. So, I'm going to say I don't understand it enough and I would like to learn more.

[02:07:43]Um, yeah, this is this is what we're gonna continue doing next time. I think this was a good start, though. Um, anyways, thank you all so much for showing up today. Like the stream if you haven't, sub if you haven't. Um, join the Discord. It's linked in the description. It's the best place to get pinged when I go live, and stay up to date with the rest of the community.

[02:08:04]Everyone there is really chill. Um, I guess my GitHub sponsors is also down there if you want to give me money and my socials are there if you want to add me on anything. Um, yeah, that's about it. Take care y'all. Take it easy and I will see you all tomorrow.