Live Code: Make a Programming Language from Scratch

I have yet to make a complete programming language in my "How to Make a Programming Language" series. I want to change that, starting with this stream.

Transcript

The following transcript was automatically generated by an algorithm.

00:04 : okay we're live
00:06 : hi business Toby I thought I would I
00:11 : thought that I would make a programming
00:14 : language from scratch on the stream
00:17 : because in my how to make a programming
00:20 : language series which if you don't know
00:25 : about that one
00:26 : you can find it on my website
00:31 : Toby ho com oops
00:35 : it's this one oops okay this one down
00:39 : here so in this series I serve talk
00:43 : about first at a high level what is it
00:46 : like to make a programming language and
00:48 : then I go to the more low level how to
00:52 : actually do it in particular I teach how
00:55 : to use a parser generator tool called
00:58 : nearly yes to make a parser there's a
01:02 : big part of the series as how to use
01:04 : that tool to build your own parser but
01:09 : then after that it goes into how to
01:11 : build a code generator how to deal with
01:14 : a STS etc although that part of it is
01:17 : not quite as fleshed out but throughout
01:21 : the series I have never actually built a
01:23 : sort of complete programming language I
01:26 : dealt with smaller examples such as how
01:31 : to make a JSON parser how to make a
01:33 : parser for simple arithmetic like like
01:38 : rhythmic expressions like 1 plus 1 times
01:42 : 2 and stuff like that so I would like to
01:46 : change that I would like to give an
01:48 : example of what it's like to build an
01:50 : actual full-fledged programming language
01:53 : starting with this dream so let's just
01:56 : get started let me check the stream
01:59 : condition currently it says excellent
02:02 : condition and that's cool
02:08 : okay I am going to do this so so what's
02:15 : the programming language I'm gonna be
02:17 : building I just caught it X because I
02:21 : couldn't think of a good name for it um
02:23 : this is off of the cuff and I came up
02:27 : with this search syntax I wanted the
02:29 : syntax to be conventional enough but
02:32 : also somewhat different from what you're
02:35 : used to so it looks very much like a
02:40 : Python or a ruby in the simplest cases
02:45 : of when you're just assigning a variable
02:48 : declaring a variable and doing simple
02:50 : arithmetic but it deviates in some
02:54 : places in one one particular thing that
02:59 : I sort of feel strongly about is in
03:05 : order to improve the do to remove
03:08 : there's one ways of the language noise
03:19 : I'm gonna sort of remove the characters
03:25 : that are as an ASCII characters that are
03:30 : noisy and one of those that I really
03:32 : hate is the curly bracket so curly
03:38 : brackets are out so you can see whenever
03:42 : like a conventional language would use a
03:45 : curly bracket I'm gonna use a square
03:47 : bracket another thing and these arrows I
03:53 : might change them to the colons to be
03:57 : more conventional because I feel like
03:59 : the arrows are also there's more visual
04:02 : noise there I also decided to remove
04:04 : this commas so maybe another rule is
04:09 : commas are out and and also semicolons
04:14 : are out I don't like these I think they
04:18 : have more visual annoys because there's
04:21 : like very fine detail in this little in
04:26 : the did and blip embellishment of the of
04:30 : the character has fine details in it and
04:33 : I think that that's like too much visual
04:37 : noise this is my opinion you can totally
04:40 : completely disagree with that and I
04:44 : thought yes I thought this is how you
04:47 : would do classes this is how you would
04:49 : define functions when you're calling a
04:51 : function with multiple parameters you
04:53 : don't even separate them with commas and
04:57 : the blocks again use the square brackets
05:00 : instead of the curly brackets so that's
05:05 : what I thought the language would look
05:07 : like let's get started on building this
05:12 : thing I thought maybe for the first name
05:16 : I would do something simple so I could I
05:20 : could make variable assignments work I
05:23 : could make function calls work and for
05:27 : the for the moment for the for the first
05:30 : draft of this the function call would
05:33 : just support the print function and
05:35 : nothing else and if we have time it will
05:40 : do something more maybe the if statement
05:44 : or the while loop these are some
05:46 : features I wrote now that can definitely
05:49 : be revised okay so that's the idea let's
05:54 : get into it let's see let's see how much
05:57 : we get done so Oh actually I'm gonna try
06:00 : to use this stickies on the Mac and in
06:05 : particular I heard from from Professor
06:10 : mark Gus dial that sub-goal labeling is
06:15 : a very useful tool for learning so I'm
06:18 : gonna try to do that so right now what
06:22 : I'm gonna start with is I'm gonna set up
06:27 : the project so project set up
06:32 : maybe like step one his project set up
06:35 : which means which means NPM in it and
06:44 : install dependencies okay so we're doing
06:48 : project setup right now let's go ahead
06:50 : and do that
06:51 : so I already created this excellent
06:55 : folder here and currently it has these
07:00 : these two files this example I kind of
07:04 : sketched out and a feature list that I
07:06 : sketched out um I'm gonna do NPM in that
07:09 : me make this fun bigger so you can see a
07:12 : little bit better oops not 10 p.m. OS
07:15 : NPM in it and with the - white flag
07:19 : which will skip the question there okay
07:23 : so this is my NPM and the one dependency
07:29 : I want is the nearly GS package MPM
07:35 : install yes
07:44 : I think I want this to always be on top
07:52 : how do I do that I made this one almost
07:58 : on top always on top no I don't want to
08:06 : delete this note how do I make this
08:08 : always be on top
08:11 : bring oh there's another one
08:15 : I'm gonna delete this one excuse me
08:18 : well I figure out the stickies float on
08:22 : top okay so is this floating okay
08:25 : there's sticky is floating on top great
08:27 : that's what I want okay so I set nam in
08:32 : it I meant NPM in it
08:34 : sorry okay and perhaps I can make this
08:38 : text bigger too okay I think that's
08:46 : pretty good okay so I have actually done
08:49 : project setup now and now first the
08:54 : first thing I'm gonna do is build a
08:56 : simple parser just to get me going so
09:01 : and I think what I would what I might do
09:06 : is well there's a desert royce actually
09:10 : do it do I want to build the lexer first
09:14 : and then build the parser they did cover
09:19 : using a lecturer which is Mooji yes
09:22 : let's do that
09:23 : I'm gonna install mu J s as well
09:36 : we're still in the project setup so
09:39 : we've installed new GS and and nearly GS
09:45 : now the next step is how about let's
09:48 : let's build a lexer you'll build a
09:52 : lecture using moody s so that's gonna be
09:54 : our second step build lexer using okay
10:01 : all right so how do we build a lecture
10:04 : I'm gonna make a lecture file it's going
10:09 : to use ok so I'm gonna go back to the MU
10:18 : J s website to get a basic example of
10:23 : how it works
10:31 : so the basic example is you first you
10:39 : first make this call to this compile
10:41 : function with this specs and and each
10:47 : spec or you could call each one of these
10:50 : guys a match or perhaps has this regular
10:55 : expression in it and most of them do
10:58 : some of them have these array of choices
11:01 : so and and the this this matter
11:08 : basically where there's a it's a regular
11:10 : expression or an array of string
11:13 : literals will be used to parse the text
11:17 : and then generate tokens if so if if
11:21 : this guy mattress it's gonna generate a
11:23 : ws token and so forth so so let's do
11:30 : that so in my language we have these
11:33 : guys which are identifiers so the tokens
11:37 : I'm going to throw out the tokens that
11:39 : we might have in our
11:41 : language mm give me one second - I'm
11:45 : gonna try to log into my phone or log
11:50 : into the stream using my phone okay
11:55 : that's myself talking okay I'm gonna say
12:01 : hello okay that's in case anybody locks
12:06 : into the stream and ask questions I can
12:09 : answer
12:09 : okay so what I'm gonna do is say so sort
12:16 : of draw out what the different kinds of
12:18 : tokens are in this language so one kind
12:22 : of token would be these which are
12:27 : variable names or function names for
12:30 : that matter so this is a function name
12:33 : this is a function name and this is a
12:36 : variable name for example these guys I'm
12:39 : gonna call and there's more of them I'm
12:41 : not gonna draw out every single one but
12:44 : I threw out some more perhaps I should
12:47 : draw out every single one I don't know
12:51 : so these guys here all of them
12:57 : they're called identifiers typically in
13:02 : programming languages and speak because
13:05 : identifiers they identify actual things
13:08 : that are in your program so they are
13:13 : called identifiers and they can either
13:15 : be variables or functions so that's one
13:18 : kind of token another kind of token is
13:20 : this that's just the assignment operator
13:24 : perhaps yeah or I could call it the
13:28 : equal sign although calling it the equal
13:31 : sign is kind of a misnomer I'm gonna
13:36 : call it the assignment operator so let
13:45 : me write that down
13:46 : actually while I'm doing this so that
13:50 : don't forget
13:58 : so in a comment so I'm gonna need
14:02 : identify burrs I'm gonna need a sign and
14:10 : operator I'm going to need these
14:15 : parentheses so this left ran and the
14:19 : right paren here this is I'm gonna call
14:22 : this the left print and this is the
14:24 : right print and right plan and then
14:31 : we're gonna have the plus and the plus
14:35 : minus times divide for now we'll just
14:43 : deal with simple arithmetic so these are
14:46 : the arithmetic operators what else
14:50 : so there's white space obviously white
14:54 : space perhaps I just call it WS so this
14:59 : is white space this is white space etc
15:03 : this is white space there's this left
15:08 : bracket how could it left bracket and
15:14 : right bracket so this is a left bracket
15:19 : and this is a right bracket
15:20 : I think this I'm gonna switch it back to
15:23 : the colon maybe what do you think
15:31 : so for dictionaries entries look like
15:35 : this and perhaps we use the whitespace
15:41 : to be like like I don't even want to
15:46 : have commas in this language so the
15:49 : entries are just separated by white
15:52 : space you could optionally put white
15:54 : space in here too but if you do that you
15:58 : probably want even more white space in
16:00 : between the entries so that otherwise
16:04 : this might look a little confusing I
16:07 : guess that that's sort of a aesthetic
16:09 : choice though that the programmer is
16:11 : gonna make so that is a dictionary so I
16:16 : so I'm gonna say :
16:18 : here's another one what else the if
16:25 : keyword if else if your house keyword
16:33 : and for keyword these these are keywords
16:38 : go at the end keyword as well and I
16:44 : suppose this new that doesn't actually
16:47 : have to be a keyword but there's a class
16:49 : keyword I don't know maybe the neo is a
16:53 : keyword but I'm not totally sure or Neil
16:58 : could just be a special identifiers to
17:01 : it doesn't necessarily have all four
17:03 : strings for Strings we're gonna have
17:09 : this quote here so double quote and are
17:17 : those are the tokens that we're gonna
17:19 : need probably that's probably all the
17:23 : tokens we have at least in this example
17:27 : so I'm gonna gonna write a lecture based
17:30 : on this okay see if see if it works
17:36 : load that compile okay I'm gonna move
17:48 : this back in the center of the screen so
17:51 : the white space thing there's actually a
17:55 : difference there we might need to
18:02 : differentiate between a new line and a
18:05 : white space so let's say new line is
18:07 : also a yeah let's say new line is also a
18:17 : token which is this different from West
18:21 : basement okay let's see how that goes
18:26 : and we might even be lazy here and not
18:32 : implement all of these tokens for now
18:34 : and only implement enough of them so
18:37 : that we get the objectives done and I
18:43 : would say today's key objectives are
18:46 : getting variables variable assignments
18:50 : going and getting print statements going
18:53 : and maybe if statements to not sure I'm
18:59 : not sure if I want to do the arithmetic
19:01 : thing yet because I've yeah I've covered
19:06 : that in another video
19:08 : and I feel like you know I don't maybe
19:11 : just do something different try this go
19:14 : mmm okay I'm gonna make sure I do
19:19 : identifier and add the assignment
19:21 : operator and oh I forgot about numbers
19:24 : oh I would say string literals string
19:32 : instead of the call yeah instead of
19:35 : modeling the double cool I'm just gonna
19:37 : have the lexer figure out the string
19:40 : literals and the number literals and let
19:43 : that be that yeah that's how I
19:48 : and that's how it's usually done okay so
19:51 : I'm gonna need to figure out number
19:52 : literals and string literals um I think
19:56 : I can probably just steal these steal
19:59 : this example from UJS because these guys
20:03 : that are so common so I have my number
20:08 : literal and string literal this string
20:11 : literal I guess it's saying it matches a
20:14 : double quote and make this text a little
20:16 : bigger it's gonna match a double quote
20:19 : and then and then this question mark and
20:24 : then : that I believe that it's just
20:27 : saying I'm not trying to capture
20:29 : whatever is in it so that that's kind of
20:33 : inconsequential here to what it's
20:36 : actually trying to match and then this
20:38 : is saying what is it actually saying
20:45 : double O this is a slash
20:47 : this is escape and then it wants to
20:50 : escape the slash so this is a literal
20:53 : slash here this is a literal slash
21:06 : so if there's a slash because the user
21:10 : wanted to escape something and there
21:12 : they can escape either a double call or
21:16 : they can escape a slash in their program
21:19 : got it or if it's got a work Oh
21:31 : or if it's not a new line or a double
21:40 : quote or any this is any character
21:45 : anything that that is not a not a new
21:55 : line a double quote or a literal slash
21:59 : and you need two slashes to mean a
22:02 : literal slash so as the between the
22:05 : double quotes you can have anything
22:10 : that's not one of those guys or that's
22:14 : the or so that means or or you can have
22:19 : a double slash and then a double quote
22:24 : and a slash so you can escape a double
22:27 : quote and escape a slash basically so
22:30 : that's what a string is that's good
22:31 : enough for me and then for a number of
22:33 : what's a number it's a either a zero or
22:39 : first you have a non-zero digit and then
22:42 : any number of zero above digits that's a
22:46 : number this doesn't account for decimal
22:49 : numbers but I actually don't care for
22:51 : now so this is fine this definition for
22:54 : number and strings it's fine and
22:59 : I probably gonna copy his whitespace
23:02 : definition that's just any space or tab
23:06 : that's a white space I'm gonna lowercase
23:12 : it and then I like hear about friends
23:17 : yes I do care about prints so I'm gonna
23:19 : steal his left print and write print as
23:23 : well because I need the same thing I
23:27 : need and then I need an assignment
23:29 : operator so a sign operator he doesn't
23:37 : have that I should use the underscore
23:40 : convention or or different convention
23:48 : [Music]
23:50 : camelcase convention or I could spell
23:58 : this all out left and right
24:01 : although it may not even matter
24:04 : practically speaking because um I'll
24:08 : just use the underscore convention so a
24:10 : Simon operator is an equal sign and what
24:13 : else do I need a sign I got numbers I
24:19 : got strings so I should be able to match
24:23 : that identifier do I have a identifier
24:28 : no and he doesn't have identifiers
24:31 : either so I'm gonna have to make that
24:34 : myself so what's an identifier
24:38 : identifier is a it's any number of
24:44 : [Music]
24:46 : in JavaScript you start with a alphabet
24:52 : letter and then it's followed by alpha
24:55 : and numeric letters and plus the
24:58 : underscore or the dollar sign I'm not
25:00 : gonna allow the dollar sign does it I
25:02 : think it's weird I'm going to excuse me
25:17 : excuse me
25:18 : okay so I'm going to say it starts with
25:23 : an alpha followed by alphanumeric I'll
25:43 : throw underscore in there okay
25:48 : so get more or less like JavaScript
25:52 : except you can't do dollar signs and
25:54 : this yeah and this for those of you new
26:01 : to read X this star means zero or more
26:06 : repetition zero oops
26:11 : zero or more of the preceding thing
26:16 : which is that so zero or more of that
26:20 : which is a character class that includes
26:23 : this range this range and this range
26:26 : plus that underscore here so I think
26:33 : that's good enough for what I want so so
26:36 : far I have done done West basis number
26:44 : literal strings left ran and ran
26:52 : right oh I'm gonna need new lines I'm
26:56 : just gonna steal his new life
26:57 : so in mu you have to configure if
27:01 : there's a token if there's a token that
27:10 : can take line breaks you have to set
27:13 : line break to true so I'm gonna call
27:15 : this new line I'm not really gonna spell
27:18 : out whitespace because there isn't
27:23 : actually I don't think it'll end up
27:25 : making my code verbose to call it white
27:30 : space here because I'm probably just
27:33 : gonna give it an 80s once I get into the
27:36 : near the grammar so I'm gonna do it like
27:41 : this so so far I have left print
27:50 : whitespace number string left paren
27:52 : right print assignment operator
27:58 : identifier and newline so I have these
28:03 : things the rest of them I haven't done
28:05 : yet so I'll grab their DS and I'll say
28:14 : to be here these are the things that are
28:21 : not done all right maybe I say not done
28:28 : so these are not done yet but now what I
28:34 : can do is perhaps I do a module that
28:39 : exports equals this lecture and now I
28:44 : can or maybe even simplify it to know
28:52 : this is okay maybe I could just do this
28:56 : I'm just gonna export this and then I
28:59 : make another script that would use this
29:02 : so so let's make test lexer let's make a
29:11 : script called text lexer and we have
29:14 : this example let's have a smaller
29:15 : example example one I'll call this maybe
29:25 : example full okay so I'm gonna just go
29:31 : with example one which I'm gonna have it
29:36 : basically test out all the other
29:38 : features we have so far I'm gonna split
29:43 : right okay so I want to have Y space
29:50 : which has some white space here and okay
30:06 : and oh maybe oh is a string our strings
30:13 : always have our are delimited and closed
30:19 : in double quotes always okay so I'm
30:25 : gonna print out mmm mmm and oh we have
30:31 : identifiers because that's what an MNO
30:34 : are and print and I will have left paren
30:38 : and right paren here I'll print again
30:46 : I don't know maybe I was separate yeah I
30:54 : was also possible to just print a number
31:04 : okay and print a string like that
31:09 : yeah I think I think all these token
31:13 : types have been represented so I'm gonna
31:16 : I'm gonna write a test script to read in
31:20 : this file and ask the lecturer to to Lex
31:24 : it if it works so I'm gonna do and I
31:35 : used to promise this version of the FS
31:37 : API
31:38 : I like doing async await so I'll stick
31:41 : to that I'll say read in example 1
32:06 : print this out first see that part just
32:16 : relax okay oh that's a buffer I want to
32:22 : convert it and do a string you do it
32:25 : like this called a two string method
32:30 : okay there's the code so there's the
32:38 : code I'm gonna now require the lecture
32:41 : okay
32:50 : and have the lexer how do you do it
32:54 : put the lexer I have to call Luxor that
32:57 : reset put the tote that does feets then
33:02 : put into it and then you call next next
33:04 : next so while true I'll make a token
33:13 : variable well true token equals Wexford
33:19 : that next token token token pulse rate
33:34 : you might be wondering why I didn't
33:37 : write the wild token you closed that I
33:40 : could write it like that too all right
33:42 : for some reason I've been liking the
33:44 : wild true patterns I'm probably a
33:51 : minority in that opinion but that's ok
33:55 : ok so I'm gonna try to write this and
34:04 : those are our tokens and everything
34:06 : seemed to work fine let me think
34:13 : we get the text so perhaps to get this
34:17 : to get this to look a little more clean
34:22 : or shorter I'm gonna just print out the
34:28 : type of the token so a token has a type
34:32 : I believe ya has a type and a value
34:42 : he's just trying to type and the value
34:45 : so and I guess I'm gonna JSON if I it
34:53 : the value so that the new line doesn't
34:57 : actually be become a new line so I have
35:02 : an identifier let's do it side by side
35:07 : with my program so okay yeah so these
35:14 : are the tokens and and I hate that
35:16 : there's this warning message when I use
35:19 : the promises version of the API whatever
35:22 : ignore that okay so given this program
35:26 : these are our tokens first we have an
35:28 : identifier whose name is n and then we
35:31 : have a white space and then we have an
35:35 : assignment operator and then we have
35:37 : another white space and then we have the
35:39 : number four with the number we might
35:42 : decide to convert this guy to a number
35:45 : which we can do let's go ahead and do
35:48 : that like actually convert it to a
35:50 : number and mu J s allows us a
35:54 : configuration option to do that
35:57 : actually let's find it
36:03 : what is it called
36:05 : it's caught the value so if you if you
36:09 : provide a value transformer and it'll
36:13 : call your value transformer to convert
36:15 : the string the text to a something that
36:20 : might not be a text in order to do that
36:22 : you have to wrap this bad boy in an
36:26 : object first and call the matcher match
36:30 : and then you can supply a value
36:40 : and then for my value I'm gonna just use
36:43 : the number function because number
36:46 : function is a function which if you call
36:48 : it with a numeric string it will give
36:51 : you the cross bonding number so not even
36:54 : gonna write an arrow function or
36:56 : something like that I'm just gonna plug
36:58 : in the number function and run this
37:01 : again and now I should have four numbers
37:08 : hello where's my number oh yeah I got it
37:13 : I got it number is four and this is not
37:16 : double quoted so that good indication to
37:19 : me that it's an actual number okay and I
37:24 : could go through a bit more verify
37:26 : everything is correct but it looks
37:29 : pretty good to me right now I'm not
37:31 : gonna dwell too much on it so now we
37:35 : have a lecture I have Flexer so we've
37:38 : completed a step lecturer using milk
37:42 : although we haven't completed all the
37:44 : features I'm gonna save some of the
37:46 : feature for the few some of these
37:47 : features for the future so we have to
37:50 : come back later and revisit the lecture
37:53 : at some point but now I think we're
37:55 : ready to start writing a grammar to try
37:59 : to turn the stream of tokens into an
38:02 : eight ast which stands for abstract
38:06 : syntax tree
38:11 : okay how do we do it do that I'm gonna
38:16 : make a file let's call this guy grammar
38:24 : or maybe parser that parser that any
38:28 : hard grammar I'm gonna cook grammar that
38:31 : Annie Annie is the file extension for
38:35 : nearly okay
38:39 : and I'm I'm gonna look look up how to
38:43 : plug in a lecture into nearly again
38:46 : because I don't have it memorized so I
38:52 : can look at the tokenizer section okay
39:00 : so this is how you do it you make a
39:02 : block that starts with at sign open
39:06 : curly bracket and percent sign and then
39:12 : you you you do what you need to get your
39:16 : lecture in the scope and then later you
39:18 : do app sign lecture and then put the
39:21 : identifier of the lecture after this
39:25 : this statement here so this is the the
39:28 : key one the fact that he did this mu
39:31 : compile in here and I decided to do it
39:33 : in a lecture battery guess that doesn't
39:35 : matter I'm just going to require lecture
39:36 : at yes instead of mu here okay so in
39:42 : this grammar so here I'm gonna update my
39:45 : step I'm gonna make a make a grandma
39:51 : okay I'm gonna make a grammar in nearly
39:57 : okay so it looks like app sign and the
40:01 : open curly and then percent sign and
40:03 : then % close curly to to stop that block
40:10 : so this is a block that allows you okay
40:16 : I have I set
40:19 : i sat is here I'm gonna say hello to him
40:25 : like he can hear me
40:27 : why am i typing okay I'm not used to
40:31 : this so so now I'm going to require my
40:36 : lecturer okay which I have already
40:39 : declared in my lecture just so I'm just
40:42 : gonna import it or require it in this
40:45 : way so that's gonna get whatever I
40:48 : assign is the module exports here is
40:51 : that guy that guy gets gets required and
40:56 : it goes into my lecture constant over
41:00 : here and then after that I have to still
41:02 : tell it that this lecture is the lessor
41:06 : I want to use because I could have named
41:08 : this to like my lecture and then and
41:13 : then use this name over here okay I'll
41:17 : leave it like that I'll call it my
41:18 : lecture okay so now with the lexer
41:25 : plugged in I'm I should be ready to
41:28 : write my grammar
41:29 : so the first scrap the first element I
41:32 : want to write I think is just maybe the
41:36 : assignment okay all right or maybe I
41:42 : could write let me just write an
41:45 : assignment first so assignment was an
41:47 : assignment assignment is gonna be an
41:52 : identifier I then took fire and in
41:59 : nearly the % is how you identify a token
42:05 : by its type name okay so if you want to
42:08 : identify it by this business the type
42:10 : name the % is how you do it if you want
42:15 : to add identify token by its string
42:18 : literal you can actually just write a
42:20 : string literal but identifier is this
42:24 : dynamic thing that you could potentially
42:26 : have any name identifier so it makes
42:29 : more sense to identify
42:31 : by the type name whereas if it were
42:34 : something like a Left bran well left ran
42:39 : you could write this to identify the
42:42 : left paren but it's actually more
42:45 : convenient to just write the string
42:47 : literal for the left ran because the
42:50 : string literal for left Tran is always
42:52 : going to be the left paren so those are
42:55 : the choices you have when you're working
42:57 : with the MU J s tokens in nearly je s
43:02 : actually you don't necessarily have to
43:04 : use mu j s to to make the tokens you
43:08 : could potentially handwrite your own
43:10 : lecture if you want to okay so I'm gonna
43:13 : say an assignment is an identifier and
43:16 : then an assignment op but and Simon op
43:19 : is um I know it's always gonna look like
43:22 : an equal sign so I'm gonna just write it
43:24 : like that and then after an assignment
43:28 : we'll have a literal value which can
43:32 : either be a number literal or a string
43:35 : literal I'm gonna actually make another
43:39 : symbol for literal okay so I'm going to
43:44 : say literal and then I define what
43:46 : literal means literal yes now do another
43:52 : line yeah a literal is either a number
43:55 : or it's a string okay so that says
44:00 : assignment is first an adept I an
44:03 : identifier then this equal sign and then
44:07 : a literal and what it's a literal as a
44:09 : literal is either a number or a string
44:13 : and I guess that would work for
44:17 : assignment but we haven't done the white
44:19 : space so I'm gonna start with a simple
44:22 : simple this is another project I had I'm
44:25 : gonna close that out I'm gonna start
44:29 : simple so maybe like I'm gonna make
44:34 : maybe just play example
44:40 : I have this example 1 maybe I'll make
44:46 : another example called
44:47 : example just assignment just dealing
44:55 : with assignment like N equals 4 I'm
44:58 : gonna do the white spaces later ok
45:01 : not just now so I need to compile this
45:12 : grammar first
45:13 : and I need to actually write a script to
45:16 : drive this grammar
45:18 : Jenny compile it to compile it you do
45:23 : npx nearly see the name of the grammar
45:29 : file and then tell it what the output
45:33 : file should be in this case I'm gonna
45:35 : kind of output it to grammar doctor yes
45:38 : and it should have generated grammar yes
45:41 : it did
45:43 : so I'm gonna copy this come in now you
45:47 : don't have to copy the npx part when you
45:50 : copy it I'm gonna make that one of the
45:53 : scripts I'm gonna call this gen parser
45:58 : that way it's more convenient I don't
46:01 : have to type this out or remember this
46:02 : so I can do NPM runs and parser and
46:07 : it'll regenerate the parser for me but
46:10 : once I have generated the parser or
46:12 : generated the grammar perhaps I should
46:15 : say I still need to do this write a
46:19 : script to take this grammar file and
46:23 : make a parser out of it so let's do that
46:27 : and I don't have that memorized either
46:31 : are so I'm just gonna go back to this
46:33 : getting started
46:35 : example and use that I'm gonna make a
46:38 : new file called parse
46:42 : okay and I actually I did call my
46:46 : grammar grammar js-- so this totally
46:49 : works for me and I'm gonna then feed
46:53 : something into it and then whatever the
46:56 : parser got as its result that's the
47:00 : result since I made this example
47:05 : assignment X I might as well use it so
47:08 : and perhaps I will even have passed in
47:12 : as a parameter to parse what what the
47:16 : file is I want to parse okay so again
47:19 : I'm gonna use the async await because
47:27 : that's how I like to do stuff in nodejs
47:38 : okay I'm gonna do it like this and then
47:40 : I'm gonna get the file name from process
47:44 : that hard to beat - why - because when
47:49 : you write when you write an ood parse
47:53 : dot yes and then and then the name of
47:58 : the file example assignment X this is or
48:05 : a zero
48:06 : this is part one and this is art -
48:10 : that's why we need to get art - so we
48:13 : want to get the filename as art art -
48:18 : that's why and then I'm gonna say if
48:21 : they didn't provide the file name then
48:24 : we're gonna read an error message and
48:27 : say please provide a file and and then
48:33 : just return if they don't provide a
48:36 : filename we're not gonna do anything
48:37 : and then we're gonna read in the file
48:40 : wait FS read the file the file name -
48:46 : string as you remember again I used to
48:54 : promise this version of the file system
48:57 : here's the code now and the code is what
48:59 : we're gonna feed into the parser and
49:01 : after the parser is fed some code it's
49:05 : gonna have some results and we're gonna
49:07 : print that out so let's see what happens
49:08 : so we're gonna no parse example
49:14 : assignment it's it's that please provide
49:20 : he founding
49:21 : oh if not founding if they did not
49:25 : provide a proper name then do that okay
49:27 : so okay I think that means it worked
49:33 : China it got because if it didn't work
49:37 : then we should have done an error like
49:40 : let's say we made a syntax mistake like
49:47 : didn't have a four ah then you would oh
49:52 : because at this point this is actually
49:54 : still not an error because it hasn't
49:57 : gotten to the point of like this is if
49:59 : it received more input it could still be
50:02 : correct but if I gave it something that
50:05 : it doesn't know then no it definitely
50:06 : that's actually a lexer error okay but
50:12 : in any case this means it worked
50:15 : if it if it printed out something that
50:17 : means it has made a full parse but
50:21 : that's not good enough because we want
50:22 : it to be translated into an AST that's
50:26 : easy to consume and usually the way I
50:30 : construct the STS is I just follow the
50:34 : example of the JavaScript parsers where
50:37 : they they each ast node is represented
50:41 : as an object that has a type so this if
50:46 : this one is called an assignment then
50:50 : the type might be called an assignment
50:53 : or an assignment statement and then it
50:57 : can have additional stuff like the
50:59 : identifier that you're assigning to I
51:03 : call that for name usually or we could
51:08 : call it identifier if you want and then
51:10 : this is maybe an identifier node and so
51:14 : forth and then it would have a left-hand
51:17 : side like we are assigning the value and
51:20 : so this has the VAR name of N and the
51:25 : value has the actual number that has the
51:29 : value of 4 and so forth so that that's
51:34 : what we're gonna build but before that
51:37 : let's allow white spaces because
51:40 : currently this wise basis doesn't work
51:46 : yeah well it's business doesn't work I
51:48 : just wanted to prove that point and I'm
51:50 : gonna modify the grammar to allow the
51:52 : white spaces to work nearly sort of
51:56 : recommends this
51:59 : this convention of using underscores to
52:03 : mean to mean optional whitespace I'm
52:08 : gonna follow that so I'm gonna say
52:10 : underscore is a whitespace okay and this
52:12 : is the wet space token that is supported
52:15 : by our lexer here who actually spelled
52:18 : it all the way out like that
52:20 : okay so underscores meaning whitespace
52:23 : now okay so now it should support white
52:29 : spaces being in there now I need to
52:33 : regenerate a parser
52:45 : okay good duck run it and now it works
52:49 : and that was supports white space but
52:52 : this output is still kind of hard to
52:53 : read so I want to rectify that so how do
52:56 : we do that the first thing is for any
53:03 : for any rule where the left hands the
53:06 : right hand side only has one symbol in
53:08 : it such as this this one and this one so
53:14 : the right hand side only has number in
53:17 : it in this case and string in it in this
53:18 : case I'm gonna I'm gonna use this ID
53:23 : function which says just unpack the
53:28 : thing in there because otherwise it's
53:30 : gonna give you an array with just that
53:32 : thing in it so this unpack that array so
53:34 : we don't get the extra array so if we
53:37 : did that I need to Gen parser again if
53:44 : we did that then we actually get that
53:48 : number unboxed and we can see it now and
53:52 : we get that identifier in box but
53:55 : unboxing we also want to do that here so
53:59 : here I'm gonna write a little
54:02 : transformer and say and give it a
54:09 : function that this ID is like a
54:11 : prepackaged or out-of-the-box function
54:14 : you can use but you can make your own
54:16 : functions and and I have covered this
54:19 : before in other videos so I'm not gonna
54:21 : get too detailed into how it works
54:25 : but basically these guys these symbols
54:30 : the Mac each one matches some string and
54:34 : each match is put into this array so you
54:37 : ends up looking like like an array like
54:42 : that and this array is gonna have five
54:45 : elements in it right so that array is
54:49 : gonna be fed in as the parameter of that
54:55 : function
54:56 : gonna call this array data data is gonna
54:59 : have five elements in it I'm only gonna
55:02 : pick out the ones that I care about
55:05 : which is identifier and de literal okay
55:08 : so I'm gonna say I'm gonna return an
55:11 : object to represent what an assignment
55:15 : is an assignment is a object that has
55:18 : the type of assignment and its name may
55:23 : be var name where variable may be the
55:29 : variable is our name I'll clip var name
55:35 : is the zeroth element of this array see
55:40 : this is the zeroth element of beer and
55:42 : this is the last one which will have
55:43 : index four and the value is index four
55:47 : is the literal okay so if we did this
55:51 : we'll end up with an object that looks
55:53 : like this at the end will regenerate the
55:56 : parser run the script again and now
56:01 : indeed we have an object that has a var
56:04 : name which is an identifier and a value
56:06 : which is a number token and and these
56:11 : tokens have actually have offsets and
56:13 : line numbers and colon column numbers
56:17 : which um which yeah which this is will
56:29 : be helpful information for error
56:31 : reporting so if you've an error you want
56:33 : to report the error to the programmer
56:35 : you can do that okay and then why is
56:38 : this an array Doh okay why is this an
56:41 : array is because sometimes your grammar
56:46 : can be ambiguous
56:47 : it could be parse in multiple ways and
56:50 : such as such as like if you have 1 plus
56:57 : 2 times 3 well you could either
57:00 : interpret it as what 1 plus the result
57:05 : of 2 times 3 or you could and
57:07 : put it as 1 plus 2 first and then that
57:11 : result times 3
57:13 : there's could potentially be multiple
57:15 : parse trees and and nearly will actually
57:19 : give you both parses in in that case
57:21 : it's usually bad to have ambiguous
57:25 : parses so that's not something you want
57:27 : in general even though it's possible I
57:31 : discourage it
57:33 : so I'm just gonna try to detect that if
57:36 : that happens and try to rectify it by
57:39 : changing the grammar so here I'm gonna
57:41 : actually gonna say if parser that
57:45 : results length is greater than 1 I'm
57:49 : gonna give a warning the parse the parse
57:57 : tree generates multiple results and I'll
58:09 : I'll log the results
58:16 : now in either case we're locking the
58:19 : results I guess yeah
58:23 : all the results in other otherwise I'm
58:26 : only gonna lock the first result how
58:29 : about that okay so now it's only gonna
58:37 : lock the first result because the the
58:40 : the tree is not ambiguous or the parser
58:43 : so far we haven't seen it to be
58:46 : ambiguous so basically this tree this is
58:50 : the AST tree this guy is the AST tree
58:56 : AST tree well st already has it or tree
58:59 : in it and we're gonna build on build on
59:03 : this so the things so we have we have
59:09 : done making grammar in nearly now and a
59:13 : parser and now we're gonna add a couple
59:19 : more features I I think I said that I
59:22 : wanted to be able to have a function
59:25 : call yeah in addition to a variable
59:28 : assignment right so let's do that let's
59:32 : make make the grammar allow to support
59:35 : function call so I'm gonna say function
59:39 : call what does a function call look like
59:45 : well there's an identifier the name of
59:49 : the function and then we'll allow some
59:53 : optional white space here and then we'll
59:55 : have a left paren which I'm gonna write
59:57 : out the literal for it and then I'm
59:59 : gonna say this is gonna be a parameter
1:00:05 : list actually
1:00:11 : and then a close and a right prat okay
1:00:18 : and what is a parameter list let's
1:00:21 : define before I do that it's bothering
1:00:24 : me I'm gonna
1:00:29 : oh hi balagia balaji welcome okay so
1:00:37 : let's see I wanna I want to allow the
1:00:43 : syntax to either be an assignment or a
1:00:47 : function call right so I'm gonna have
1:00:49 : something called a top-level statement
1:00:51 : or just a statement and I'm just gonna
1:00:54 : say a statement is either an assignment
1:01:00 : which I'm gonna use the ID to unpack it
1:01:04 : automatically because whenever there's
1:01:06 : only one thing usually whenever there's
1:01:10 : only one thing in the right-hand side of
1:01:12 : your production rule you should use the
1:01:15 : ID function to unpack it so a statement
1:01:18 : is either an assignment or a function
1:01:20 : call
1:01:27 : okay so then we also we still need to
1:01:35 : allow any number of lines so we'll do
1:01:40 : that next but for now let's deal with
1:01:43 : this function call bit so let me make a
1:01:46 : example for a function call first so
1:01:51 : example function call the x so example
1:01:57 : function call might be something like
1:01:58 : I'll print hello world okay which we we
1:02:04 : should this should work once we get the
1:02:08 : parser going because the lexer already
1:02:10 : supports string literals okay so that's
1:02:15 : what a function call is going to look
1:02:16 : like so function call starts with an
1:02:18 : identifier optional whitespace let's
1:02:20 : also do optional white space here
1:02:22 : probably and then now we need to answer
1:02:25 : the question what is a parameter list
1:02:33 : parameter list is going to be a probably
1:02:36 : a value like an expression but like
1:02:41 : which is either a literal or a or an
1:02:45 : identifier at this point so I'm gonna
1:02:47 : call it expression I'm going to define
1:02:52 : that as an expression is either an
1:02:58 : identifier or a literal and again I'm
1:03:04 : gonna use this ID thing to unpack the
1:03:08 : array again and whenever you were
1:03:10 : matching only one your right hand side
1:03:14 : of the rule has only one thing you
1:03:17 : usually want to do the ID thing okay so
1:03:21 : an expression is either an identifier
1:03:24 : which is a variable or a literal like a
1:03:26 : literal number of five or something so a
1:03:30 : parameter list can have just one
1:03:31 : expression or it could be
1:03:36 : a expression and then a comma
1:03:44 : oh not Tama I said we're not gonna allow
1:03:48 : commas in this language so it would be
1:03:50 : mandatory whitespace oh wait space I
1:03:59 : didn't differentiate between mandatory
1:04:01 : white space and optional white space let
1:04:04 : me see how the lecturer works okay I
1:04:08 : think okay so why space is actually some
1:04:13 : white space so double underscore should
1:04:15 : be mandatory white space I'm gonna write
1:04:18 : a line of comment yeah how do you write
1:04:21 : comments okay
1:04:22 : Concorde is mandatory white space hi
1:04:28 : nasty mixture welcome and then I'm gonna
1:04:32 : call this optional white space optional
1:04:37 : white space is gonna either be no I
1:04:43 : think either be no or or the mandatory
1:04:55 : white space I believe that's how we can
1:04:58 : do it and I call this optional white
1:05:03 : space is that how I did it in the past I
1:05:06 : hope I hope this is right okay so this
1:05:09 : is optional white space and this is
1:05:11 : mandatory white space and I'm saying
1:05:15 : because I don't want to even use commas
1:05:19 : in this programming language I'm gonna
1:05:22 : use mandatory white space to separate
1:05:25 : the parameters in the parameter list
1:05:27 : instead of a comma and so I'm gonna say
1:05:34 : and then after this mandatory white
1:05:37 : space you can have more parameter lists
1:05:41 : there's some nuance to this which I
1:05:44 : can't
1:05:45 : but I'm just gonna test it and see if it
1:05:47 : works and if it doesn't work we'll have
1:05:49 : to fix it okay so this is a pram
1:05:53 : doorless yeah this is try this before I
1:05:59 : try it I'm gonna I'm gonna write this
1:06:04 : just converter to convert these matches
1:06:08 : to an ast note so this guy here let me
1:06:13 : do it here first so this guy only has
1:06:15 : one thing so I'm gonna do ID but this
1:06:18 : guy this guy actually has d3 things in
1:06:29 : this match array c3 things and I only
1:06:36 : care about that guy and that guy and
1:06:38 : this guy is zero and this guy's 1 right
1:06:41 : so I'm gonna say something of tight
1:06:53 : actually I mean this is not even gonna
1:06:56 : be an ast note I'm just gonna return on
1:06:58 : array I believe an array of whatever the
1:07:04 : things inside it are which can either be
1:07:07 : identifier for literals okay and the
1:07:11 : data this guy is gonna be one individual
1:07:15 : thing so data zero this is data index 0
1:07:19 : this is data index 2 but that's gonna
1:07:22 : give me another is supposed to give me
1:07:25 : another array so that makes this one
1:07:28 : wrong actually I have to go back and fix
1:07:30 : that so the data index 2 is supposed to
1:07:34 : give me an array I want to spread it on
1:07:36 : to this array 2 to make a larger array
1:07:40 : with this additional item which means
1:07:44 : this one I actually wanted to do it like
1:07:49 : this
1:07:55 : [Music]
1:07:56 : do like this start off with an erase so
1:08:00 : that next time it returns from here this
1:08:04 : is actually an array and not an
1:08:05 : individual item and it can be spread
1:08:08 : onto this array and then now here the
1:08:14 : function call for this function call I'm
1:08:23 : gonna take so this gonna have a type I'm
1:08:30 : gonna do a return statement okay this
1:08:35 : guy is gonna have a type of function
1:08:37 : call and what there's a function call
1:08:40 : has well yes the function name I'm gonna
1:08:42 : call it fun name the function name is
1:08:45 : gonna be at index zero because that's
1:08:47 : very first thing so data at zero and
1:08:50 : this will be a identifier token directly
1:08:54 : from the lexer and then we're gonna have
1:08:58 : the parameter list I'm just gonna call
1:09:00 : that parameters and where does that come
1:09:03 : from well index zero one two three four
1:09:09 : so it's index four is where the
1:09:12 : parameters are coming from and there we
1:09:14 : have our function call so let's let's
1:09:17 : try this and see if this guy works I
1:09:20 : need to run Jan parser that didn't work
1:09:29 : I think there's a syntax error and my
1:09:31 : grandma so I'm gonna to see where this
1:09:35 : it doesn't like this syntax on line
1:09:39 : seven hmm
1:09:44 : oh because I needed a I needed a
1:09:47 : vertical bar so this should look like
1:09:52 : this
1:09:54 : hi web scrap welcome welcome
1:09:58 : um okay so let me let me try to compile
1:10:03 : this again okay it compiled now I'm
1:10:08 : gonna try to have to parse script parse
1:10:13 : this file now see if that works this is
1:10:19 : called example function call that seemed
1:10:24 : to have worked we get an ast node which
1:10:27 : is has the type of function call and
1:10:29 : it's got a fun name it's the function
1:10:32 : name which is an identifier it has the
1:10:35 : value of print so the front we're
1:10:38 : calling the print function basically is
1:10:40 : what this means and it's got parameters
1:10:42 : the parameter there's one parameter in
1:10:45 : the parameters array and it is a string
1:10:49 : literal hello world that makes sense I'm
1:10:52 : gonna try it multiple parameters so
1:10:54 : again in this language I decided to not
1:10:56 : have commas because I want it to be just
1:11:00 : slightly odd so so you just separate the
1:11:05 : parameters with spaces it's sort of like
1:11:07 : Lisp in a way because that's how this
1:11:10 : does it and that seems to work that can
1:11:14 : do now we have parameters string literal
1:11:18 : number and then another number we can
1:11:21 : even have identifier so say XYZ that
1:11:26 : should still work yep those are
1:11:30 : identifiers now we've got X and z are
1:11:32 : identifiers and a number before that and
1:11:36 : a string literal before that so that's
1:11:38 : cool what about if it has no parameters
1:11:42 : then what happens then it doesn't work
1:11:47 : my grandma doesn't support a function
1:11:50 : call with no parameters so maybe I
1:11:53 : should fix that so one way I could fix
1:11:58 : that is just add another Clause here not
1:12:02 : here but here to say well it's okay you
1:12:06 : don't have a parameter list that's fine
1:12:10 : another way I could fix it is by
1:12:13 : allowing the parameter list to be empty
1:12:18 : [Music]
1:12:22 : let me think about it
1:12:24 : maybe I allowed this to be empty yeah so
1:12:35 : I'm gonna say and in in nearly Jas the
1:12:40 : way to be empty is no to match something
1:12:43 : empty is no and I'm gonna say if well if
1:12:46 : you match no then you should return an
1:12:52 : empty array because because yeah does
1:12:58 : this work I'm gonna just try this again
1:13:07 : I feel like there's some nuance to this
1:13:09 : one that um it does work
1:13:13 : I'm just a slightly worried that I might
1:13:16 : have like an ambiguous grammar or
1:13:18 : something though just test it so print
1:13:22 : one two three
1:13:25 : this seems to be okay so we got a AST
1:13:28 : now so I'm gonna wrap it up but before
1:13:34 : we wrap up I'm just gonna make it
1:13:38 : slightly nicer so that this print script
1:13:41 : will generate an AST file that is nicely
1:13:45 : formatted okay so perhaps what I do is
1:13:49 : I'm gonna take whatever the file name is
1:13:52 : and rename it to ast like this the St
1:14:02 : file name is equal to
1:14:10 : so half that base name-based name of the
1:14:15 : file name plus dot EST and that's the
1:14:22 : ast founding I'm gonna say FS wait I
1:14:26 : missed that right file right to the ast
1:14:30 : file name and then the thing I want to
1:14:33 : write is json stringify the ast with
1:14:43 : this level of indentation
1:14:47 : what's EST that the password that
1:14:57 : results index zero that's our ast
1:15:00 : there's the thing we've been printing
1:15:02 : our along
1:15:04 : [Music]
1:15:05 : Oh after this I customarily I write I'll
1:15:10 : put this as I wrote this file I mean
1:15:18 : justice yep so we wrote this AST photo I
1:15:26 : kind of wanna this is actually okay I
1:15:29 : think having this X in here so so let's
1:15:35 : look at this AST file and that's DST for
1:15:38 : this program that looks pretty good
1:15:42 : oh there's one one more thing I want to
1:15:44 : do which is currently this parser
1:15:48 : doesn't support multi lines and that's
1:15:50 : kind of messed up I think everything in
1:15:55 : this file should be supported if if
1:15:59 : multi line were support were worked so
1:16:03 : I'm gonna add multi line support and
1:16:05 : then H and it can parse our example 1
1:16:08 : dot X ok so how do you do multi line
1:16:11 : first let me prove that it doesn't work
1:16:13 : for this file example1 X yeah it doesn't
1:16:20 : work it's so a new line token it didn't
1:16:23 : know what to do about it so what I'm
1:16:26 : gonna do is say the top level or the
1:16:28 : program is actually not a single
1:16:30 : statement because right now the top
1:16:33 : level is a single statement which will
1:16:36 : allow only allow the file to have a
1:16:38 : single statement in it the top level of
1:16:41 : the of the parse tree should be a number
1:16:44 : of statements any other statements and
1:16:47 : we're gonna do this repeating trick
1:16:50 : again that we did over here
1:16:52 : so the perhaps do do it like three
1:16:57 : separate statements like this or maybe
1:17:00 : allow for an empty file yeah let's do it
1:17:05 : like that so now if we have it's an
1:17:08 : empty file then
1:17:13 : our statement is empty array but if we
1:17:19 : have one end one statement then the
1:17:28 : thing that represents the program should
1:17:31 : be an array with that statement in it
1:17:37 : which is gonna be data index zero
1:17:41 : because it's referring to just stuff in
1:17:44 : here and then but it could also be a
1:17:48 : statement and then a new line and then
1:17:52 : more statements okay
1:17:55 : in which case in which case we're gonna
1:18:04 : do it we're gonna return a new array
1:18:07 : we're gonna spread the rest of the
1:18:11 : statements on there while appending this
1:18:15 : new statement well I can't call it just
1:18:17 : statements I'm gonna have to call it
1:18:19 : index 0 1 & 2 so this is 2 and then this
1:18:27 : is index 0 names this statement okay so
1:18:31 : I think this makes multi lines work
1:18:34 : let's see I need to generate the parser
1:18:40 : and it's parsed it and it generated the
1:18:45 : ast file I mean look at the ast file
1:18:48 : yeah it has an array of statements now
1:18:52 : the first daemon is an assignment
1:18:55 : assigns the number four to identifier
1:18:58 : and
1:19:02 : never do a side-by-side that looks right
1:19:14 : okay there we go so so yeah we're doing
1:19:18 : a side by side so that's the first
1:19:21 : statement first statement was this one
1:19:23 : second statement is another assignment
1:19:25 : assign still number five to identify M
1:19:30 : that looks right and the third one is
1:19:32 : another assignment assigns the string
1:19:35 : hello world to the identifier
1:19:37 : oh so that looks correct the next one is
1:19:40 : a function call it's calling the
1:19:44 : function print with identifier print and
1:19:47 : it's parameters are the identifier and
1:19:51 : followed by the identifier M that looks
1:19:54 : correct another function call and again
1:20:00 : calling the print function with the
1:20:03 : parameter oh and then another and a
1:20:06 : couple more function calls after that so
1:20:08 : everything looks like it's an order I'm
1:20:12 : gonna I think what I'm gonna do is post
1:20:21 : this on github
1:20:24 : perhaps I'll do that right now on stream
1:20:27 : so that for those of you who are
1:20:30 : following or watching you can access the
1:20:35 : code
1:20:40 : and play with it I'm gonna get ignore
1:20:48 : the not marios footer really quick and
1:20:57 : then check this in to get there this
1:21:07 : okay so I'm gonna make a new repository
1:21:11 : call it a Sling a demo programming
1:21:20 : language I'll say code stream live
1:21:33 : create a repository I'm gonna push this
1:21:40 : code out here so this
1:21:52 : oh I didn't I didn't make it first
1:21:55 : check-in you're welcome I set okay now I
1:22:05 : made the first chicken and now I can
1:22:09 : push this code and oh I didn't write any
1:22:14 : readme file so but I'll probably do that
1:22:19 : after this dream so so this repo is
1:22:23 : there for those of you who are
1:22:25 : interested in getting this code or
1:22:28 : comparing your programming language to
1:22:31 : mine are just using mine as a reference
1:22:34 : I'm planning to do this as an ongoing
1:22:37 : series so adding more features of the
1:22:40 : language in the upcoming weeks so keep
1:22:43 : an eye out for that
1:22:44 : for now tentatively I'm planning to do
1:22:49 : it every Friday morning so if you're
1:22:52 : interested in watching this then then
1:22:56 : yeah
1:22:58 : beep either next Friday okay I'm going
1:23:06 : to end the stream bye everyone thank you
1:23:09 : for attending