Transcript of RSM Episode 1

RSM project page

00:04 okay hey um so this is what i've been thinking about doing um this week a little
00:14 sort of uh virtual machine little virtual computer platform
00:19 i thought it would be fun to have something that is sort of um
00:26 both of you know learning projects to to build one of these things and also something that can be sort of a sort of a little foundation or something
00:38 like that for other hobby programming languages i put together a couple of couple of
00:44 compilers and languages and stuff like that in the past and and i think you always come to this point where
00:50 um you either need to go reach for lbm
00:54 which is you know obviously a huge chunk of
00:59 code to include and complex dependencies and stuff you're including to generate code for any type of machine right or
01:05 you can go with something and say like well i'm only going to generate code for this specific thing and there are other options like banarian and stuff like and a few times i've attempted to to
01:18 write my own uh you know ir and also a few times my own um
01:24 machine code generator and that stuff obviously is just like very complicated
01:27 really really time-consuming task and sometimes
01:31 that's fun you know sometimes that's for for learning how that stuff works but you know other times you just want something um something that's running
01:40 so that's one of the goals so it could be kind of nice if um
01:44 if this little thing could um it could be an escape patch for for the time so i want to create a little hobby programming language and just kind of want to run it on some machine
01:56 um so generating code for this should be pretty straightforward um
02:01 and from the first goal like just having fun and learning i think simplicity is
02:07 um is pretty important because you know it's a limited amount of time we're that
02:19 computers are just sort of moving very quickly there's
02:23 there's some weird connection to sort of consumerism in
02:28 um the way we write software right there's this sort of you know
02:31 write it ship it run it and then we just move on
02:35 to the next thing and the thing that we just shipped it's it's dead right
02:40 even the web is something where you constantly have to maintain your program for it or your web page or
02:49 whatever for it to keep like working right if you just build something you
02:53 put it on a web page and you wait a few years it'll just be broken right unless you use a very small
03:00 subset of the web platform um and you know that's kind of natural right uh
03:06 i think that comes from the um some of the origins of uh of of web um
03:15 and some of the uh you know that there's no versioning right there's there's no different versions of the api and stuff like that um and also
03:23 the fact that it serves a a huge economy of use like
03:29 software and stuff like that right and and then of course we have specific
03:34 kind of operating systems or platforms like you know mac os micros 11 micros 12
03:44 you know a variety of linuxes some bsds um
03:50 and uh yeah obviously you can you could write a program i think linux is probably the thing that gets the closest
03:59 uh to me of all the offices right now if you if you only consider the linux kernel uh which obviously gives you a very limited sort of way to express yourself
04:07 but if you only go the links kernel
04:12 um you have sort of the syscalls which is kind of like a virtual machine in a way if you you know if you bend it a little bit in your mind um and that's pretty much stable you can
04:21 write a thing you can run a thing that was written in the 90s essentially on a
04:26 on like a kernel from yesterday um but obviously as soon
04:31 as you you include third-party libraries like those things are gonna change and you know you're gonna be gonna be back in this company anyhow i digress
04:40 uh long long long side conversation interesting about that anyhow i think the third the third point would be um and maybe i should take these out
04:55 so a couple of little goals so first off learn oops
04:59 learn have fun right uh so the second point i was talking about um
05:25 there we go some sort of substrate um
05:30 uh thing to okay
05:37 and the third point we're just gonna i wouldn't say perma computing but sort
05:45 of um
05:55 so you know i want to be able to run a program where is it is multivideo is that
06:10 program in um
06:20 and that was interesting like looking at things like uh nintendo right nes and
06:28 snes um game boy there's like a whole bunch of
06:35 these like you know c80 things um c64 there's a bunch of these systems
06:41 from the past they're really simple that people are still building programs for and um
06:52 that's probably the closest we've gotten i think to something that's um
06:58 somewhat of a of a longer life right i don't think anything is permanent everything is transient you know if you
07:04 want to be philosophical about it but so i wouldn't go as far as calling something permanent or permanent
07:11 uh anyhow um that's stadium
07:16 and here we have a couple of other notes i shared used on the on the twitter the
07:20 other day um
07:24 i think it did at least well i think that this thing whatever it should just embrace the linear memory model you know
07:33 this idea that um that c embraces uh uh web assembly for example many things right this idea that there is sure there might
07:41 be on actual hardware you know multiples of segment memory models and stuff but let's just say that memory starts at
07:48 zero and it ends at some sort of like large number right uh and the way you address things is by
07:55 you know giving you an offset right from the serum
08:01 um pretty straightforward proven uh simple really flexible um uh model so
08:07 let's go with that rather than anything high level that's like oh memory is just
08:11 a concept man now uh let's just you know
08:18 put like an address in our register or whatever we'll end up using um
08:22 and you just treat it as a number treat that as an address you just do uh pointer arithmetic and
08:29 stuff like that um that stuff i think uh sometimes people are like shying away from that and see or say that's the root
08:36 of a lot of a lot of bugs and yeah sure that might be true but i think that that is also the root of a lot of uh the
08:43 awesomeness of something like c okay uh simple semantics
08:46 um there should probably just be actually i think i've changed my mind about this a little bit uh that there
08:54 should probably just be like low sorry global constants as a concept
08:59 like there's just constant data you can bake into a rom or executable whatever you call
09:06 that like a little program and then you can reference those constants right so if you want to have like the you know constants for pi or something like that you can just pick that into a program like you reference that in all the different functions
09:18 uh there are some constant mutable locals um and that includes parameters and
09:24 variables i think those are all treated the same um so inputs to functions outputs from
09:30 functions and temporary sort of like
09:36 variable data inside a function are all the same thing um and then there are conventions around
09:40 like you know in in
09:45 how do you how do you provide parameters before a function call how do you read the results of the
09:55 the i think that the virtual machine should use registers because i think that's just like a really neat
10:01 es model i just kind of like that stack models are cool too but i think it
10:06 would be more of a fun challenge to go with registers um but
10:12 the there might be a little like i'll get to that in a minute here but there
10:16 there might be a little sort of like layer on top a very very lightweight
10:21 tiny sort of assembler slash compiler that might allow you to
10:25 say hey you know just call this thing x and
10:30 go pick a register for it later automatically for me i don't want to pick registers i think that would be neat that would just make
10:37 a bunch of stuff like easier to to do essentially when you don't care about a register for temporaries which i think is the is the merit of cases you can just give them um
10:48 usable names um
10:52 and finally some sort of simple syntax and this is about uh the little input language um which i won't start with
10:58 writing this this would probably come a little later but some sort of simple syntax that is released to parse
11:03 and read um and so here's like uh here's some sort of
11:12 little idea um i'm obviously i'm playing with the
11:17 syntax and this doesn't you know mean much but semantically like there's this idea that you have a a local right so
11:24 one of these things like a register essentially but you can name it so you say one and then you say one it's like
11:31 number one uh which would be a constant a global constant that you reference here so this we just simplify that for you um and then you say two and it's like load the other global constant which would be number two and then you say something
11:47 like uh you know in this 30 register put the result of adding
11:51 this register and that register together right and then put the uh the result of that um and return the result of that inverse
12:07 result value one stuff like that um
12:12 so that that's that that's the that's the unreal idea um let's see
12:17 then i share this on twitter i think two days ago
12:20 so the next thing i started playing with like you know what is the
12:25 what is the um the level at which you are
12:29 um deciding on where things going were you putting these little programs together as text as source code not
12:37 the the vm instruction set i'll get to that a little later but
12:41 um and i think that there are three options there is a register style right where
12:48 you're explicitly naming your registers you're explicitly storing loading uh into memory and front
12:56 memory um there is an ssa style this is usually
13:01 what you find in like most compilers and immediate representations like if you've ever looked at llvm's ir for example it
13:07 will look roughly like this as to say i guess like com
13:12 you know sorry let me just mention the last one the last one is like local style
13:19 um and this is what you'll find in things like i think this is more common with stack machines you'll find this but both the web assembly and lua uses this
13:26 kind of abstraction i guess lou i got kind of registered so they they call them that but yeah
13:33 and yeah i think the what ssa brings um a constant and pros
13:39 comparative reduces style is um that uh
13:44 you you have this kind of like named values right rather than you explicitly um
13:51 define registers you then though have to deal with like fights which are essentially like a kind of a
13:59 fan in thing if if you're familiar with this you know this is but if you're not fight is essentially um
14:05 um it's like let's see what's the good metaphor for this okay let's see that let's say that the three doors in front of you right
14:16 and a your friend now goes away somewhere around the house and then
14:20 comes back to you out through door number one right
14:25 uh and then the friend goes around again goes through the house and come out through door number three
14:30 right and maybe the friend is bringing different like i don't know treats or something like a cupcake when they come out of you know door number one and maybe like
14:39 they've eaten the cupcake when they come out through door number three um
14:46 for you to be able to like know what um i don't have to phrase this yeah so
14:53 fi is essentially saying that you know this person can come out of these three different doors right and whatever the
15:01 number of cupcakes is going to be whichever door they came out of right so
15:05 in this little case um uh you have result one here so when you
15:12 get to this block so you go you know it goes one two three four like this so we start here and this just says yes jump
15:18 to block one right so it just continues um this will be
15:23 this this thing will be important later actually this is dumb i think you can skip this anyway um
15:31 and the first thing it does it says fi like if it comes from door you know block number zero then the value is one
15:38 but if it comes from door number three right block two which comes down here
15:43 then uh the the value of rest one is the value
15:47 of rest two and you can have more things if you have you know more um uh and the same thing is here anyhow it
15:58 gets a little complicated just explaining it it's a little complicated
16:03 once you once you groggify it's not it's not that hard of a concept but it definitely does complicate things a little bit logically you for example you
16:10 have to sort of like as you're writing this you sort of have to have the uh the premonition or the foresight to
16:18 to see that you're going to write this block down here and that's going to become a predecessor of annotated
16:24 predecessors here on the site um and yeah i ruled this out pretty quickly i think this this is something that is really useful
16:32 especially for optimizations ssa is useful um serve as an intermediate but not as
16:38 something that you write i think either like kind of traditional assembly
16:44 with uh when you name the specific registers or the local style
16:49 i think the local style is the best one so actually i think it we ended up with a
16:55 combination of both of these so for the virtual machine it explicitly names
17:00 registers there's no concept of locals in the in the virtual machine
17:05 but as you're writing these little assembly these little programs that that little thing will put together into virtual machine programs
17:16 you do deal with locals and then the reducers are allocated for you automatically when this text is parsed and compiled into vm byte
17:23 codes up codes so that's the deal
17:30 you um you write this and this is kind of
17:34 what it looks like on inside okay
17:38 i did some explanations here but i'm not going to talk to these i think these are some some things that also made me excited about just the the concept of things like to be able to write programs at this level they can draw to the screen they can play sound
17:50 and stuff like that without having to involve any um any particular operating system concepts again to satisfy um
18:01 longevity and substrate points for the so
18:07 um yesterday i was sketching out a little bit um of what the uh
18:14 mistake what the what the uh
18:26 encoding might look like um i think lua has a pretty like elegant yet
18:35 maybe slightly over engineered i don't know no actually i i would say it's pretty elegant it's pretty nice um
18:42 uh in instruction encoding um and what i ended up with something very similar to lua which is um
18:52 so as you might have noticed i've put together a really simple
18:57 program here let's see put the copycat away um if you look at the the code it's it's
19:04 pretty little just some stuff i put together to get started um and build
19:16 uh i forgot about this um
19:26 where it's gonna end up um all right so okay i just have this little build script that it just generates maybe i should tell
19:38 um it just generates like an uh a linear build file and then is like ron's ninja
19:42 essentially um so to keep the super minimal the only dependency here is bash and
19:50 ninja and obviously a compiler i'm using click um
19:56 okay so build it run it this program right now doesn't do much maybe i'll get to this in a few minutes
20:02 um but let's just look at this first okay okay let me just clear this uh
20:12 okay so uh instruction encoding um i also looked at risk five risk five is
20:17 obviously pretty cool um and uh yeah there's there's a bunch of
20:21 other architectures that are that are interesting and and neat and stuff like
20:26 that it'll give them various ways um this ended up in a place where i was
20:36 like oh can i pack these bits together really like i probably only need seven bits for like the the the operation code
20:43 right and maybe i can even get away with six bits
20:47 like 64 operations seems fine and stuff like that and i try to be really clever about it and i was like you know what so let's just keep it simple the
20:59 um each instruction is a fixed size and
21:04 that's kind of that allows some cool things like the pc can be uh
21:09 instructions and jump offsets and branch offsets and stuff are instruction counts
21:14 and that means that you can just make it so that memory addresses is always
21:18 always like data memory there's no execution executable memory that you
21:22 deal with you only deal with like instructions um and instruction distances right and that may
21:30 might make a code more portable um so they're 32-bit long uh they're a
21:38 little endian um the uh this is kind of mentioned this
21:43 line here that you know their expression instructions rather than bytes
21:47 um and then i give the um
21:52 the uh what is this this is most significant i always forget about this i have to like go look this up now i feel like them
22:06 okay whatever this is at least they're both i think it's most significant right anyhow they i believe this is the most
22:12 significant bits these these bad boys these first eight
22:17 bits um i give those to an up code
22:23 uh so risk five and lua for example has like a smaller code field it's got seven
22:27 you step six it's got seven bits now and then it's got one bits like the squishes
22:32 in here that they called k um which is sort of like a flag that
22:37 like shane just left slightly the meaning of the arguments for the operator or the operation and then i
22:44 think i don't know if if i'm right here but i think that's sort of like a bit of an afterthought realizing looks like well we should have like a move
22:51 operation for like reduced register and a separate
22:55 move operation for um a constant to register
23:01 but instead this k flag indicates if like you know the the b
23:05 the b immediate names a constant names a register and it gets a little complicated and similarly like risk five
23:12 has what they call funk funk like three and seven i don't know why they're called three and seven but they have these two one or two different fields in
23:19 the instruction that that comes with the operation so like i
23:24 think now i might be wrong i have the i have the risk five hope you can see
23:29 this let me bring this into the viewport um all right
23:37 where is it base instruction format it's here somewhere
23:41 all right here we go um so this is kind of what risk five does
23:48 which uh makes it a little tricky like there's the up code six bits uh so 64 of
23:57 um make sure i'm insane um
24:02 and then you got this thing here funk three funk seven so that this
24:07 this thing actually like together with this
24:11 describes the actual operation to perform all right so there's there's some examples maybe integer i'm just gonna
24:18 okay yeah so for instance here are some
24:23 this will do right so here's like an up code called up
24:30 operation immediate maybe i don't know and then in funk three you have this
24:34 like secondary up code that's like add an integer or you know there's other operations right so essentially like
24:42 what what what they could have done here and i'm sure they have really good reasons and risk five is like you know a
24:49 real industry strength architecture but i think semantically at least you could say that this is really just like an up
24:55 code that's called add eye immediate right if you smash those together
24:58 so uh so i was thinking you know this is just a hobby project i'm not gonna make it very complicated i'm gonna try to make it like the most performant thing or anything like that so let's just have for anything like that
25:12 like where you have a move from you know constantly register register register
25:15 let's just make those different up codes and make the op code field um
25:19 large enough to fit a bunch of operations so 256
25:23 probably more than what i ever need for something like this
25:28 the reminder of the instruction encoding is just a bunch of fields so like for
25:32 things that need four arguments there is uh five bits for uh slot a five
25:41 for b c and then the remaining bits nine is for a fourth slot
25:47 and uh and then it's like you you only need three arguments then um the the third argument then is like a
25:54 wide one and i just choose w here inspired by lewis like
25:59 naming scheme i think they call it k or d i don't know they call it some letter i didn't know what it was i was like well it's wide so let's use w so that's
26:07 what this little nomenclature in here means that the the third argument here now is
26:13 like sort of a wide one um so for stuff like immediate values you now have like
26:18 14 bits instead of five bits right to express something um
26:22 so if you have something like a conditional branch then um
26:28 due to 14 is is going to give you like 16 000 um possible like uh
26:34 up code sorry instructions that you can skip
26:40 forward to right or i guess um 8 000 8 000 that's more reasonable
26:46 because it would be a signed number um so it would give you 8 000
26:50 um instructions that you can jump forward to or backward from this is just an
26:57 example of like a an immediate like a branch instruction with an immediate value of like how many dm2
27:04 for for one that uses like a register as the indirection you can just use this so
27:10 so the registers there are 32 registers for each type for integration floats
27:19 and yeah so you can see this picture what happens if you only need you know
27:23 if you only need one single argument you have 24 bits and now suddenly you can express really large numbers um okey-dokes so then what i've done here in this project is i've set up a couple of just couple of macros just to like make this encoding
27:38 stuff um less of a headache this i took from um let's see this other thing it's going to lift this over to this is from a different project i put together this
27:52 hobby vm many years ago called sol so i have retrofitted these
28:01 these macros to this new project um so you can see i've just put here
28:06 like sort of like the size of the operation eight bytes bits sorry uh of the arguments abs c and d and then
28:14 sort of like what is the size of you know when the d argument is not used
28:20 what is the size of c and b and a and so forth and then the position of them
28:25 which is just you know it's going from from this direction into this direction
28:30 just most significant
28:34 sorry i have to look this up i'm going crazy i'll figure this out later um it really doesn't matter i just want
28:48 okay so this is kind of yes what i put together this morning um i've got just
28:52 some code i recommended from previous project this is a super simple memory allocator it is grabs um is does my map
29:00 just grab a chunk of bytes and then just you know hands them out essentially and
29:04 then a super simple just array implementation um
29:10 and then this file just has uh i've just generated a list of
29:16 names of the operations and the types that the header file has defined just to
29:21 make things easier to print and the header file here is made a list of the types i think the
29:29 there are really only a few types um so the the register size is 64 bits at
29:35 least i think that's what i'll stick with and that means that there are five sizes of of integers
29:41 um one bit you know for bool essentially
29:46 uh and then their two size floating point and then this i think just get rid
29:51 of this this doesn't really i don't know i just tossed it in there so play around but a pointer type
29:57 but i don't think there will be point like pointers as in um
30:02 um like executable memory partner distances
30:05 or anything that will be needed let's use the i64
30:11 and uh and then just like a few operations i
30:15 just wanted to plug a couple of these in just to uh just to figure out if this was like sensible um and then i have a just a couple of
30:25 typed ups uh like the uh the type code
30:30 this is just this thing right it's like eight byte
30:34 um and then just like generate an enum for that and similarly the up code is
30:39 like a byte it fits in here and generate an enum for dose
30:47 and then just say that an instruction is u32 right unsigned 32-bit integer
30:52 and then here is just a little structure for the memory allocator that i show you a little structure for an array
30:59 the two function definitions for getting the name of
31:06 and an operation for again for like printing and debugging and stuff like that and then a few routine series for the yes for the memory manager don't have to
31:12 like look at those it's just run-of-the-mill stuff um a function for growing an array um
31:22 and then this thing i tossed this in i'm pretty sure i'm gonna need it because i i need this in pretty much every project
31:28 uh um oh i didn't name this
31:36 uh so this thing is essentially as like a um append buffer
31:41 yes for you know doing things like string formatting basically always needs
31:46 something like that in projects um yeah so that's it
31:50 uh so there really is no code yet there's just a couple of some definitions of um of types and operations and surely i
32:00 will be chained in this and definitely definitely be changing this list of operations here
32:07 and then the uh the program itself right we i show you these kind of macros
32:12 that it's kind of it looks kind of nasty but it's it's just sort of
32:16 shifts and and awards and ends um i'm trying to just put together this
32:28 factorial example program that i showed you from in the where is it idea
32:33 file so earlier i was talking about
32:37 i was thinking about should this should be style of the vm and or the
32:43 style of the um the assembly format that you write as a
32:47 person deal directly with registers should it
32:53 deal with ssa named values or sort of locals you know variables
32:58 um and uh anyhow so i grabbed this
33:04 um and they just pasted it in here in a comment and then they recreated it here with the
33:10 uh with the operations right so uh r up underscore move it's just
33:17 this thing here right and let's just generate it's just generated with a pre preprocessor macro
33:23 here and then we have the arguments
33:35 so this little this little macro here maybe i should grab this down here so we can look at this table um
33:43 so i'll just lock it in here i made my skewer a little smaller so it fits on a video thing maybe i can
33:52 okay squish this in yeah perfect
34:01 okay so the first thing
34:12 the first thing that happens is that we're copying um
34:17 registered zero which is the first argument which is the number we want the to factorize
34:25 so we copy this into register eight so this is just a temporary you can see this light up here in my editor this is temporary uh and we make this copy this is just
34:34 implementation of factorial it's nothing to do with the vm but we just do this to simplify the return value since in
34:44 my this hobby i say here and my hobby calling convention um
34:49 uh you let's see
35:03 oh yeah separate file um yeah so there's a little calling convention here that the first eight
35:11 uh in integer registers are both inputs and outputs
35:16 um to a function uh same for a floating point right see i'm going back here that means that the this function has one input
35:24 parameter and one output result right and that means that this guy is in r0
35:30 and this guy is also in r0 so i read this is zero and factorial and at least this tail recursive version of factorial used
35:42 accumulates like a result so we'll using uh r8 as the accumulator
35:47 and we just initialize that to n and then we're gonna use this uh other register to just get our return value
35:54 and that that way we don't have to do an extra copy and stuff in the end um you can you can write this probably in many ways uh also i have not run this i
36:02 don't know if this works i've just like looked at this and thought about it so i
36:06 might have made a mistake here but i think i think this function would work if it was compiled um and sort of use corresponds to the same thing eight here register eight that's just this number down here right so
36:17 move or it's maybe i should name this copy instead it's annoys me sometimes because
36:23 it's not really move like what what the move instruction does the most is copy
36:29 right you you copy the value and resist zero to register eight like after this
36:33 operation it's not like where this is zero it's like invalid now register a
36:37 and it releases crs the same value says more copy but anyhow so this copies zero
36:41 to eight and an ip here i don't know if you saw it earlier this is just like a i just
36:48 allocate a bunch of a bunch of memory here for like 32
36:53 instructions which is probably more than enough it is certainly for this program
36:59 um and so what i do this is just an array of 32 instructions right and then
37:03 i have a little program counter right
37:07 it starts 0 zero right here starts right here at zero and then as i
37:13 add um as i add instructions to this array i p
37:17 i just increment the logical program counter okay
37:24 so the next thing is just uh loading an immediate
37:28 all right so this loads the immediate value one into register zero
37:35 okay so into reduces zero load one i've added it here and so
37:39 the next thing that happens is a conditional branch
37:47 so we want to check in the factorial function we want to check if the if the uh if the argument is um
37:57 zero because if it is we're done and there's nothing to factorize so we check here if
38:04 equals right so if the value in our in a register 8 is equal to 0
38:09 then branch to end right so if n is 0 go to end and end is
38:16 down here so then it just skips all of these things three instructions and just
38:22 we'll issue the return um uh instruction which ends the function
38:27 um and the return value will be one since we changed that here right so you give it um zero am i wrong about this
38:36 i should go look up the factor function later but i'm pretty sure
38:43 um okay so branch
38:47 i'm just playing with language if it's if equals or the more traditional br for
38:52 branch i don't know so
38:59 branch uh looking at register eight if it's zero then branch
39:07 by jumping three instructions forward so it's a it's a relative uh
39:11 branch right uh and three instructions these are the three that will be skipped the next three right and the and the final one is red so if if uh if the value industry
39:23 eight here is zero then it's going to increment the uh the program counter by
39:33 three here right which one is one is evaluating this uh which means that it would skip these
39:39 and then it would resume up uh with return right
39:44 almost cpus do it um there's there's also like a probably an absolute um absolute branch instruction that this
39:55 thing should have that says you know go to and and a specific number of like go to
40:02 instruction offset um 1828 you know from the very first
40:08 instruction of your whole program so you can do absolute jumps and stuff like that but um what i want to do is just start really small and you'll see if i can get this a really simple um function just working uh and then work my way out of from there right so there's there will be no
40:26 parser or anything like that for this until this thing works the next step after getting this together sorry for
40:31 scrolling the next step after um getting this
40:36 thing together i think will just be a little um a little function that that i
40:40 can give this array of instructions to that will then just print out
40:46 the do the opposite essentially if this disassembly whatever you want to call it print out exactly what they are i just
40:54 like to if i hit save here you'll see on the right side that
40:59 save a couple of times um this is just the way i like to work i like to kind of explore programming and have it
41:07 sort of like live updating more or less as i'm writing programs and so
41:13 right now you see this is the end of it it just is print out the size of the instructions right which is
41:19 28 bytes it says up here the other stuff is just some printout to tell me what's going on so you know when i hit save here it um it
41:27 runs that build script i showed you earlier which just um uh runs ninia the kind of like i make
41:35 system really simple uh and that just like recompils any files that have changed and dependencies links the program and then the build script just runs the program for me here um so this is just the pit of the program running so it runs the program
41:51 and bytes is a print statement where did i print that oh and
41:56 i was like when i was trusting up the memory thing earlier so remove that let's go back keep it simple
42:03 uh seriously runs this program right and here is um is that a blog message okay so that's it
42:12 that's what's going on here so for that reason the next step i want to do uh
42:17 that'll be in another video but the next step i want to do is um um
42:22 to to format this so i can get feedback about like how much did i screw up
42:26 because you know i always screw up i always make some mistakes um and so i
42:31 want that feedback of like what does the program look like versus what is the
42:35 encoding i believe i made for the program so it's kind of mixed up and after that um
42:42 after that sort of formatted formatter or debugger or whatever or not the formatter that's called a formatter uh
42:47 will be an evaluator like the
42:52 sort of the heart of the virtual machine the thing that that that runs this
42:56 little program and spits out the result of you know the the the computation of
43:02 this function right where we can give it an input value an input argument and
43:07 then we just print out the uh the result from it um and we can and from there up there is is
43:16 it's a little fussy to tell but at some point after there will be
43:20 some some parser for writing this sort of uh little simple assembly language to
43:28 to avoid having to do this kind of compile time program building
43:32 um yeah so so that's that's it that's the summary
43:38 um and uh yeah let's see what happens
43:43 uh if you're interested in this stuff just reach out on the twitter
43:47 um i've tried to do these like live streams on twitch before and it's been just like a very like unpleasant experience not from a human
43:58 oh well not from an audience perspective but from like a technology perspective it's just like super junky stuff and that's a i'm not gonna do that but i'll try to do
44:09 these kind of um offline videos and yeah you can also reach out on twitter
44:12 until next time