part 2, I'm a little bit scared of this.

(clears throat) All right, so what's going on?

Where are we, why am I here?

You might remember me from Logo Interpreter Coding Challenge

number 121, look that's me,

I'm almost wearing the same clothes.

This is a challenge where I looked at

the Logo programming language, a language from

designed in 1967, turtle graphics,

you might be familiar with,

I talked a bit more about it in that video.

I encourage you to read about the history

and also to check out the Logo Foundation

which is the foundation that supports a variety

of wonderful initiatives, including Scratch Day.

So check that out but what I did

was I made this Logo interpreter that is able

to interpret simple commands like forward 60,

left 90, forward 100.

So while this implementation of Logo

interpreting these Logo commands

like forward, left, forward, et cetera works,

it's missing crucial components.

And so there are many commands in Logo

and I implemented pen up, pen down, some of these,

but one of the most important ones

that I did not implement is repeat.

So this is a tutorial from a Brown University page

about the history of Logo that I'll also link to

in this video's description,

but what I want to attempt to do is

add the repeat functionality which you would think

would be a really simple thing,

but it's a little bit more complicated than,

well, there are some simple ways probably to do it,

and I will point out, in fact, that when I posted

this code, 16 pull requests came in with suggestions

and techniques for how to implement repeat,

and I would encourage you to go check all these out.

I want to highlight one of them that was pretty interesting

to me, I'm going to look for it, Regex implementation,

is this the one I'm looking for?

Yeah, this one, oh yeah, I love this,

which is just basically using a regular expression

to search for the repeat command

and then just replace the repeat command

in the string itself with what's the thing

to repeat multiple times.

So kind of like unrolling the string recursively

with a regular expression.

Pretty wild implementation.

I'm not going to use that one,

I'm going to try to spin up my own.

So this is my idea.

So, one thing that I think will help

is object oriented programming.

What if I have this idea of a command class?

So I make this idea of a command class

and it has the name of the command.

That could be forward,

left,

picks the pen up, et cetera.

It has an argument

so if the command is forward,

maybe I would have an argument like 100.

And by the way, the command could be repeat

and I know I'm about to leave your view here.

Repeat and then the argument could be a number also

'cause you're going to repeat something

a certain number of times.

So you have this idea of a command class.

And then maybe what I think would be useful

is to create a parser object.

And actually, instead of using split,

so I used split as a way of looking at the Logo instructions

and just splitting it into a big array,

but I think what I want to try to do

in the most absurd thing ever is just actually step through

the string one character at a time so that I have

the idea of a parser is keeping track of a index.

So the parser is always has basically a pointer

into the command and can step through

and if it finds repeat, it can then pull out a chunk,

it can do all sorts of stuff.

So, if what I'm kind of thinking about here

is this idea of a command.

A command could just be a thing that you execute

with an argument but if the command is repeat,

then it could also have a list of,

it could have an array of its own commands,

that those are the things you repeat.

And then inside of this array, there could be a command

that is a repeat command so it could nested and recursive.

So this is my idea, I have not actually,

I thought about this quite a bit

and probably helped by looking at everybody's pull requests

so I don't know to what extent this is an original idea

or it just came from suggestions,

but it through osmosis, my brain has come up

with this idea but I have not tried to implement it

so what you are about to watch is me actually trying

to implement this for the first time,

and it might be a terrible idea and things will go wrong

and you'll probably notice this video is 342 hours long,

but if you want to stick with me, here we go.

Okay, so let me go to the code.

I'm going to keep the code that I had before,

I'm going to add a new JavaScript file called parser.

Maybe it should be interpreter,

I don't know why I'm going to call it parser.

Parser.js, I'm going to write a parser class

and the idea is that when you create the parser,

you give it some text.

So this is the full text that needs to parse

and then also it has an index which starts at 0, okay.

And, one of the functions that I would have here

is nextToken so it could maybe look and sort of find

the next token or something

in this text by stepping through it with the index, okay.

That's what I'm thinking about.

Now, I am also going to then create another JavaScript class

called command, and this would be,

this is what I'm talking about,

it would have a name and an argument.

And then it could also have potentially subcommands.

Recursively, a command could also include a list

of other commands.

So this is my idea, now, let's go to sketch.js

and basically,

this go turtle function, I'm actually going to just

basically take out what I did before

'cause I don't think this, I'm not going to use split anymore

and I'm not going to have my own index here.

I'm going to say let parser = new parser with that code.

So let's just for example say console.log

and parser.nextToken.

So let me at least see if I can get parser.nextToken

to work, and so...

And this should probably return the token

so return "test".

So if I just run this now,

parser's not defined, right, I always forget this.

I've added a bunch of new JavaScript classes

so I want to make them separate, reference those files here.

Probably should get into bundling and building

and all that sort of stuff at some point.

Parser and command.

Let me go back to sketch, refresh, okay, so, great,

I see test there.

I have got my command but I didn't really get the token.

What I need to do is here, I really need to say all right,

so I'm going to step through the text one character at a time.

So what I mean by that is I'm going to say let char = this.text

charAt

this.index, okay.

So, while the character is not a,

I guess I could use a regular expression here.

So, I want to...

Let me just say, let me just do it this way for a second.

While the character is not a space.

What I want to do is I'm going to start with an empty token,

and I am going to say,

oh I don't need a...

While the character is not a space, token += the character,

character = this.text.charAt,

charAt ++this.index.

So what's going on here?

The idea here and, again, I could use regular expression

and substring but I'm trying to do this in a very manual way

to understand it.

What I'm doing is I'm saying let me look

at the first character and as long as that character

is not a space, I'm going to add that character

to my token and then look at the next character.

And this is basically, remember, this is something

I covered in the first part of the challenge.

This.index ++ this.index is increasing the index by 1

and giving back that new value.

So now if I say return token,

let's see what happens.

Refresh.

This text chatAt, charAt, a little typo there.

There we go, look.

(bell dings)

I got the first token, that's great.

Now, what if I now want to say

here

next token?

Ooh, it got a space, so look at this,

a space is not a valid token so what I can actually do here,

back into parser, is I can actually say if,

if char = a space,

return next,

increase the index, go to the next one

and return this.nextToken.

So this is a way of basically skipping and, again,

this is definitely a clear example

of I'll refactor this later,

I need a little theme music there for that,

but,

this is a start, okay,

so this is basically saying ignore

the space and so now,

we can say I've got forward 60,

but here's what I want to do really.

Here, I want to say...

And let me actually, let me use a regular expression here.

So I'm going to say,

there's a category of command which is like

a movement command, forward, backward, right, left,

so I'm going to say that would be a regular expression

that is forward or backward, this is fb followed by d

or left or right followed by a t

and probably, I should probably also make sure

it's the full string,

so put this beginning and end.

So now I could say

let token = parser.nextToken

if movement

test(token)

so if it's a movement command,

then create a new command

with token and token and parser.nextToken.

Right, 'cause I think I said the command is,

I said the name of the command and the argument

and the argument always comes next.

So, again, I'm not doing a lot of error checking

for people making mistakes in their Logo code

but we'll get to that later, I suppose.

Okay, I'm setting myself up for hopefully being able

to do a repeat.

Where am I here?

So let's just see and actually let's make

an array of commands, I mean I might want to put

all the commands into an array or I might want

to process them one at a time, there's various ways

of doing this but let's actually put it

into an array right now, I think that'll be helpful.

Oops, okay, so let's see and now let's look at commands.

Okay, refresh, look at that, I've got a command

with arguments, the name is forward, the argument is 60

and it doesn't have any subcommands

because it's not a repeat.

Woo, I like this so far.

So now, hmm, this is where I'm going to get into trouble.

Let's do something like while parser

is not empty, while parser has remainingTokens,

I don't know, come up with a better name for that.

While parser has remainingTokens, keep doing this.

So what does it mean here in the parser

to say remeainingTokens, well, on the one hand,