How Time Traveling Works

In this video, Huiqi and I talk about the time traveling debugging I've been working on. We plan to explain the architecture and inner workings of the debugger as well as covering some important computer science concepts along the way over a series of episodes.

Transcript

The following transcript was automatically generated by an algorithm.

00:00 : i want to sort of give you a demo
00:03 : of my time machine which is what i
00:07 : sometimes call it my time traveling
00:10 : debugger
00:11 : and and i want to try to explain how
00:15 : that works
00:17 : because i feel like nobody
00:21 : else in the world understands how it
00:24 : works other than me
00:26 : the source code if you ever care to look
00:29 : at it
00:30 : github.com airport yh slash
00:33 : play lang it's play lang because
00:37 : i called it the play programming
00:39 : language
00:40 : it's a very basic programming language
00:43 : kind of like
00:44 : javascript or python
00:47 : it doesn't have a lot of features
00:50 : for example it doesn't have classes and
00:53 : objects and methods and stuff like it
00:55 : doesn't have any oop in it it's just a
00:58 : very very basic
00:59 : language it's like javascript without
01:02 : the
01:02 : objects kind of it does have
01:06 : it it does have dictionaries but just
01:08 : like basic dictionaries
01:10 : not not objects and methods so i'll do
01:12 : an example so i like uh
01:14 : i'll show you a piece of code when you
01:16 : design it do you
01:18 : um want it to be more like functional
01:22 : um in in one of the other languages i
01:26 : did
01:26 : but this one i didn't care this this one
01:30 : um actually it started as another
01:33 : programming language where i did want it
01:35 : to be functional but it was um
01:38 : that one was called the fun programming
01:40 : language um
01:42 : but that one i wanted it to make it so
01:45 : that
01:46 : the there's a subtle way in which you
01:49 : can say
01:50 : this function is pure function and this
01:53 : function
01:54 : is not a pure function and the language
01:57 : will
01:57 : know in which context it is and it will
02:01 : automatically enforce for you
02:03 : the pureness as needed gotcha
02:07 : uh that was the idea of that one and
02:09 : then but i
02:10 : forked that one basically to this one
02:13 : because i want because i wanted to focus
02:16 : on my energy
02:17 : on this debugger concept and then i kind
02:20 : of i kind of removed
02:22 : the part about the pure functions
02:25 : in this one just to simplify it so that
02:28 : i have less work
02:29 : every time i decide to add a feature
02:32 : gotcha
02:32 : yeah so anyway so this is a tac toe game
02:36 : that i made it's a terminal base game uh
02:41 : so in the i decided that every program
02:44 : is going to have a main function
02:46 : which is going to be your entry point cc
02:48 : also requires that
02:50 : and then there uh this game is just like
02:54 : wow true you can play more than one game
02:56 : hence the wow true and then you play a
02:58 : game
02:59 : and then after the game is done you ask
03:01 : them do you want to play again right
03:02 : and then we have a play game function
03:05 : there's a tic-tac-toe board
03:07 : you're gonna draw the board and then
03:10 : you're gonna ask the human to move
03:12 : check if there's a winner or check if
03:15 : the current player is the winner
03:17 : and then if he's the winner you're gonna
03:19 : say that's the winner
03:21 : and then game over is gonna it's gonna
03:24 : break out of this while loop
03:25 : otherwise you check for draws
03:29 : there's a one one second delay here
03:32 : sleep i don't even know whether this is
03:35 : necessary
03:36 : and then i have this smart smart
03:39 : computer i
03:40 : implemented this ai based on the media
03:43 : based on the minimax algorithm
03:47 : and then and then you check for winner
03:49 : again and and then you go again go back
03:51 : to the human move and so forth so this
03:53 : is the basic program
03:55 : obviously there's some more functions um
03:59 : i'm gonna run this program
04:03 : [Music]
04:04 : this is tic-tac-toe term there was a
04:06 : previous version that's
04:08 : dom based that ran on a web page but
04:11 : in this version i'm running it in a
04:13 : terminal
04:15 : okay okay so this is like your move and
04:18 : you've you select one of these squares
04:21 : basically
04:22 : okay so which square do you want to
04:25 : choose
04:26 : oh let's do five okay let's do it
04:32 : oh i i have this timer to to tell you
04:35 : the time
04:35 : because i'm working on performance and
04:38 : my
04:39 : my time traveling logging stuff causes
04:42 : this to be slower than
04:44 : it otherwise would be so currently it
04:46 : took like 2.3 seconds
04:47 : for the computer to think uh what move
04:50 : do you want to make now
04:51 : uh let's do uh
04:54 : two two is here right
04:58 : right okay all right
05:01 : he blocks now with the one oh no
05:04 : okay let's do three uh-huh
05:11 : he flocks there where do you want to go
05:15 : now okay
05:16 : let's do four four
05:20 : oh the computer won he he had a double
05:23 : attack
05:24 : okay oh yeah that's okay it's pretty
05:27 : smart right cool
05:28 : i mean yeah i mean first first game
05:31 : you're not warmed up
05:32 : but uh but still like you can tell
05:35 : there's an ai playing right
05:37 : now i want to show you the time
05:39 : traveling debugger so
05:41 : as a result of playing that game it
05:44 : logged
05:45 : all of the game state like every
05:47 : snapshot of the program
05:49 : it logged to a file and that file
05:56 : is going to be the name of the program
05:59 : dot history so
06:00 : tic-tac-toe term dot history i'm working
06:04 : on
06:04 : two different database backends for this
06:07 : history file
06:08 : so currently i have the sqlite version
06:12 : where the data is stored in a sqlite
06:15 : database
06:16 : i'm also working on using leveldb
06:20 : which is a popular low-level embedded
06:24 : database
06:25 : so you're trying different ones because
06:27 : of the performance
06:28 : because you have large amount of data
06:31 : yep yep yep uh
06:32 : this one one of the big reasons there's
06:35 : multiple
06:37 : metrics about performance that i care
06:39 : about
06:40 : one one of them is how fast
06:43 : can the logging occur so that i i
06:46 : slow down the program minimally the
06:49 : other thing
06:50 : is um you know i
06:53 : i wanna utilize the disc
06:56 : minimally as well and and then the final
07:00 : one is like well once you get the data
07:03 : in there
07:04 : the querying it has to be reasonably
07:07 : fast
07:07 : as well for for the debugger to render
07:10 : stuff
07:12 : but i think the third one is the least
07:15 : heart
07:16 : like like getting the debugger to read
07:18 : the data is the least
07:20 : performance intensive of the three
07:23 : problems
07:24 : but anyway so we're gonna browse the
07:26 : data so um
07:28 : so basically there are these snapshots
07:32 : so currently there are that many
07:34 : snapshots
07:35 : uh that were that were taken
07:39 : uh during the execution of this program
07:42 : each snapshot has an
07:43 : id it has a fun call id which is a
07:46 : id of a function call that was made
07:49 : every function call
07:50 : that is made inside the program is also
07:54 : logged
07:55 : in this fun fun call table and it has
07:57 : the name
07:58 : it has the name of the function the
08:01 : parameters that were passed to the
08:04 : function
08:05 : uh this is an id because it links to an
08:08 : object in the object table
08:12 : the object the object table contains all
08:15 : the objects
08:15 : that were ever created in the program
08:18 : and the parameters
08:19 : is an object that is like a dictionary
08:23 : that has a name and value of the
08:26 : parameters that were passed to this
08:27 : function
08:28 : for this instance of the function call
08:31 : and then apparently the parent id is
08:34 : the parent function call of this
08:36 : function call
08:37 : somebody called your function within
08:40 : another function so this id is
08:43 : the parent function the function called
08:45 : the parent function yes you can
08:48 : function yeah yeah you can you can
08:50 : actually see that because the
08:52 : call to the play game function its
08:54 : parent is
08:55 : uh one which is a call to the main
08:58 : function
08:59 : yeah uh and then the objects
09:03 : look like this so this is the object id
09:06 : and then
09:07 : and then this notation is a
09:11 : extended version of json which gives you
09:14 : references
09:15 : so whenever whenever you see star and
09:17 : then a number
09:19 : that's a reference to the object
09:22 : in this table with that id that's cool
09:26 : yep so that that's how the data space
09:30 : is structured at least for uh sqlite
09:33 : gonna run the zoom debugger
09:42 : how do you handle asynchronous stuff
09:46 : like in in the programming language yeah
09:49 : i guess in the
09:50 : programming lab yeah language and also
09:52 : in the debugger
09:53 : is i use uh async away
09:57 : implicitly when the compiler compiles
10:00 : this program uh it converts it into
10:03 : javascript
10:04 : and that javascript looks like this uh
10:06 : this is the source code itself
10:08 : i saved it to a variable called code
10:11 : so that the debugger later on has access
10:14 : to the source code itself so this
10:16 : doesn't matter
10:17 : the real javascript that it got
10:19 : translated to
10:21 : all the functions are async so
10:24 : even though they're not async in the
10:26 : actual programming language
10:28 : uh there are async when generated
10:32 : as jobs um and anytime you call a
10:35 : function
10:36 : you await it okay always
10:40 : always so that that way
10:44 : you don't have to i don't i don't know
10:47 : there might be drawbacks to this
10:49 : approach but um
10:50 : you know this is just a prototype i'm
10:52 : just trying different things out
10:54 : so i decided to take this apart
10:57 : um and but what's nice about that is
11:01 : like node.js is very very heavily
11:04 : asynchronous environment like every
11:07 : everything
11:09 : everything that's io that you do in
11:10 : node.js is async
11:13 : and and this like even ask
11:17 : asking for the user to type in something
11:20 : and then hit enter that's asynchronous
11:22 : as well so we can just
11:23 : await that now and it it can just be
11:26 : it just seems like a normal function
11:29 : where we're like oh
11:30 : prom and then you'll get the answer
11:32 : right away
11:33 : gotcha yeah so this is much simpler to
11:36 : learn
11:37 : it's it's kind of like python so that's
11:40 : the asynchronous
11:41 : aspect let's see oh what's going on
11:45 : oh i forgot to start the history api
11:49 : server so there's a back-end
11:52 : rest api that i've implemented
11:56 : in node.js and
12:00 : i'll just briefly show you that server
12:05 : and it it's kind of ghetto right now i'm
12:09 : hard coding the name
12:10 : of the history file in here
12:13 : that to be served up you could make that
12:16 : a parameter but i haven't bothered to
12:18 : so now i think i should be able to run
12:21 : this debugger there we go
12:23 : so you've seen this before uh this is a
12:26 : deep zoom debugger uh we're looking at
12:29 : the main function
12:30 : like a box and if you zoom in close
12:33 : enough you can see the
12:34 : source code and and also
12:37 : you can see the intermediate values of
12:39 : the program as
12:40 : it's evaluating stuff so we're going we
12:44 : can drill into
12:44 : play game
12:48 : and then you can actually get a high
12:50 : level overview of what happened in the
12:52 : game
12:53 : you can you can kind of make out what
12:55 : happened in the game by looking at the
12:57 : board
12:57 : the state of the board at each turn
12:59 : right initially the board is all empty
13:02 : and then the human made a move and
13:04 : well you chose this move uh five that's
13:07 : that in the center
13:08 : it'll be nicer if this were laid out
13:10 : like a grid
13:12 : but but it's not it's it's an array
13:15 : and and then the computer went here and
13:17 : then you went here and then the computer
13:19 : went
13:20 : here and you went here and so forth
13:23 : i i think this scheme for debugger is
13:26 : pretty cool because you can at a glance
13:28 : you can get an overview of what happened
13:31 : in the game at a high level and instead
13:34 : if it's a
13:35 : look um so that you can see look like
13:38 : flat
13:39 : in a flat way yeah which is quite
13:42 : different
13:42 : from a normal debugger experience in the
13:44 : way that i
13:45 : imagine it i mean i i'm like i hope this
13:48 : actually you know gets adopted and then
13:52 : there's actual people using it for
13:53 : production work
13:55 : and the way i imagine this would be
13:58 : beneficial is
14:00 : usually you're looking for that one spot
14:03 : where something went wrong different
14:05 : from your expectation
14:06 : right but but there's different levels
14:10 : of
14:11 : granularity to what that spot is
14:14 : that it could be like the line very very
14:18 : deep down in the car stack
14:20 : this one line that caused the problem
14:23 : but
14:24 : it can you can also look at it as a
14:26 : higher level like
14:28 : if you're playing a tic-tac-toe game you
14:30 : don't have to necessarily
14:31 : drill down to the deepest level but if
14:34 : you're looking at a high level like this
14:36 : you can tell when there's one move that
14:39 : seems
14:40 : out of place right maybe the human the
14:43 : human after
14:44 : this human made a move something just
14:46 : looks wrong or after the computer made
14:48 : that move something just looks wrong and
14:51 : then if you saw something
14:52 : fishy then you would know to drill down
14:54 : to that step
14:56 : yeah that makes sense well what if the
14:59 : the person
15:00 : instead of writing a loop the person
15:02 : write like something that's
15:03 : uh using recursion instead of loop
15:07 : then that will mean we we can't do
15:10 : something like this
15:12 : or uh natural recursion
15:15 : i'll show you what that looks like
15:17 : because the the the ai
15:18 : does use recursion okay so
15:22 : like that's the smart computer calculate
15:24 : move
15:25 : that's the ai and that's a recursive
15:28 : function
15:31 : and i don't know if my mind
15:34 : is sharp enough to try to explain
15:37 : minimax
15:38 : we don't even have to know exactly how
15:41 : minimax
15:42 : algorithm works to sort of get a high
15:44 : level understanding of what it's doing
15:46 : here
15:48 : because you can you can see the shape of
15:50 : this thing
15:51 : you can see it's making these recursive
15:54 : calls to itself
15:56 : in here right right and it's making
16:00 : a whole bunch of them this is one two
16:03 : three four five six it made six
16:06 : recursive calls to itself
16:08 : which i think it makes sense it's about
16:11 : the middle ish of the game
16:13 : that i zoomed in so maybe like move four
16:16 : or something like that so there's like
16:18 : six squares left that it could choose
16:21 : so it's trying all the possibilities
16:23 : here it's
16:24 : actually trying to calculate the
16:26 : opponent's move
16:28 : here i believe yeah it's like given
16:31 : that i am me which i'm x
16:35 : here it it it's like switch player to to
16:39 : figure out who the opponent is the
16:40 : opponent is o
16:42 : given this board it's imagining a new
16:44 : board
16:45 : where i am going to move to this
16:49 : i which is going to be 2. so
16:52 : i moved to 2 which is here so
16:55 : where me is x here so imagine if i moved
16:58 : here now i'm going to calculate
17:02 : the computer's next move
17:05 : for my opponent like if i moved here
17:09 : what would my opponent do that that's
17:12 : what that does
17:13 : and now i could drill into that guy
17:18 : and and see the calculations there as
17:20 : well
17:21 : so i think you still what is the what's
17:24 : the depth
17:25 : let me see it's only three i think i
17:28 : made it three
17:29 : so that it won't try as hard but i could
17:32 : do four or five
17:33 : right when i do that is levels
17:36 : you're trying and then you're just like
17:39 : trying each
17:39 : one out yeah you need to figure out
17:41 : which one yeah like if i go here and
17:43 : then what would you do and then
17:45 : and then as you i'm thinking well if i
17:47 : did this what would you do but but only
17:49 : up to three levels
17:51 : um and that's more or less how people
17:53 : play chess
17:54 : or something like that but people are
17:56 : much less efficient than the computer or
17:59 : much
18:00 : more error prone than a computer at
18:02 : doing this that's a
18:04 : demo of what this is but the real thing
18:07 : i wanted to do
18:09 : is more to explain to you how this works
18:12 : how this was implemented because there's
18:14 : a lot
18:15 : there how about we just try to do an
18:17 : overview
18:18 : this time sure okay so
18:22 : first there's a compiler so given the
18:25 : code
18:25 : which is written in the play programming
18:28 : language
18:29 : the syntax of the language is like a
18:31 : cross between
18:32 : python and javascript
18:36 : kind of or ruby like i
18:39 : at one point i use fun yeah
18:42 : i might switch back to that because i
18:44 : kind of like
18:45 : writing the word fun all over the place
18:47 : i didn't use
18:48 : python's indentation thing but i
18:51 : i still just use brackets but i decided
18:54 : to not use
18:55 : javascript's curly brackets because i
18:57 : decided they are noisy
18:59 : too much visual noise and i prefer this
19:02 : square bracket
19:02 : which is like cleaner looking uh okay
19:07 : yeah yeah and then other than that if
19:10 : statements
19:10 : do not require parentheses around the
19:13 : conditional
19:14 : and other than that this is like a
19:16 : programming language you're used to
19:18 : there's no innovation in about this
19:21 : programming language i wrote a compiler
19:24 : which translates this code into
19:26 : javascript um
19:27 : i think i'm going to call it javascript
19:29 : star because
19:31 : even though it's it's normal javascript
19:33 : is 100
19:34 : runnable javascript you can easily
19:36 : translate this code to javascript
19:38 : by just changing the syntax a little bit
19:41 : here and there right
19:42 : but um but that's not the code
19:45 : that the compiler is translating to
19:48 : because
19:48 : there's this immutability that's built
19:51 : in
19:52 : to the system all the mutations that
19:55 : this javascript performs are immutable
19:59 : how how do you escalate something that
20:01 : is mutable to an image like say if i
20:04 : just want to assign things to a variable
20:07 : later how do you okay i'll talk about
20:11 : that
20:11 : even even though this code that's
20:13 : written at the beginning
20:14 : is immutable can very well be mutable
20:17 : after
20:18 : it generates this javascript code all of
20:21 : the code is
20:22 : immutable and then there we have this
20:24 : logger
20:25 : that's embedded in this code and this
20:27 : this
20:28 : logger is gonna log all the
20:31 : immutable state into a database and then
20:35 : after this logger locks the information
20:37 : to the database
20:39 : we have this um i have i implemented
20:42 : two different debuggers uh and the one i
20:45 : showed you is the zoom debugger
20:47 : zoom debugger is this web-based
20:49 : canvas-based
20:50 : user interface that's that's gonna
20:54 : be driven from the data from the
20:57 : database
20:58 : but as i mentioned i also have a
21:01 : api history api that's serving the
21:04 : information from the database for the
21:06 : use of the debugger
21:08 : history api is reading information from
21:10 : the db sending it to the zoom debugger
21:13 : in an on-demand basis and then the
21:16 : zoom debugger is rendering this visual
21:19 : that you are seeing
21:20 : there's also a step debugger because i
21:23 : do want to give that option
21:24 : as well like a traditional step debugger
21:27 : that's also gonna read from this
21:29 : history api uh yeah so that's more or
21:32 : less
21:32 : the high level overview of how this
21:35 : stuff works
21:36 : if we could break the compiler down to
21:38 : like parser
21:40 : ast code generator as well
21:43 : but that's more or less the overview so
21:46 : did you write the parser
21:48 : yep yeah so uh did you write a parser in
21:51 : the ast
21:52 : and the code generator uh yourself or
21:55 : you were using like a i use this tool
21:58 : called nearly js it gives you a handy
22:01 : way
22:01 : of writing a parser you can write the
22:04 : grammar
22:04 : we worked on a project where you we use
22:07 : a thing called pec.js this is similar to
22:09 : that
22:10 : it's also possible to write your own
22:12 : parser by hand
22:13 : i i've also done that before but this
22:16 : one i'm using this tool
22:18 : well yeah you mentioned the step
22:20 : debugger uh because but because
22:21 : you have all this immutability stuff so
22:24 : the step
22:25 : i assume the step debugger can make you
22:28 : able to like go back
22:29 : yeah so you can look at it as the
22:32 : information that is stored inside the
22:34 : database
22:35 : and by the way this is partially
22:37 : inspired by
22:38 : redux remember in redux we have this
22:42 : concept of the timeline and then every
22:45 : time
22:45 : every time you make a change to the app
22:48 : you have like a reducer
22:49 : that produced the next state of the app
22:52 : based on the previous state
22:53 : of the app so so we have like state one
22:56 : state two
22:57 : state three etc that's how the data
23:00 : is stored in the database it's for me
23:04 : it's snapshot one snapshot two snapshot
23:07 : 3
23:07 : etc right so in order to implement
23:10 : the step debugger the step debugger
23:12 : would fetch
23:13 : a particular snapshot and each snapshot
23:16 : is a particular point in time
23:18 : so if you hit next you just have to move
23:21 : to the next snapshot in the database
23:23 : not sure if you want to drill down into
23:25 : the function call you would still just
23:27 : move to the next snapshot because
23:30 : the snapshots are based on lines of code
23:34 : so if if the code is going to go into a
23:36 : function call
23:38 : the snapshots are going to start getting
23:40 : taken
23:41 : within the nested function if you want
23:43 : to skip a function
23:44 : then you can actually you can write
23:46 : logic which
23:47 : that's what the step debugger would have
23:49 : to do you would
23:51 : write logic you say i'm going to
23:53 : continue to advance the snapshot
23:55 : until like if the next snapshot has
23:59 : a taller stack frame than my current
24:03 : stack frame
24:04 : that means the next statement is in a
24:06 : nested function
24:08 : right yeah i get the idea yeah so so you
24:10 : just you just
24:11 : keep you just keep advancing the
24:14 : snapshots
24:15 : until you you your your stack frame is
24:18 : back to the same height
24:20 : as what you started with and that you
24:22 : get then you get to skip
24:24 : the function call okay so it's pretty
24:26 : it's pretty much like a like a tree
24:29 : of like this each stack
24:32 : and then the stack has children stack
24:34 : yeah yeah yeah so um
24:36 : so i can talk a little bit about this
24:39 : middle bubble
24:40 : how how can you take a mutable code and
24:43 : convert it into
24:44 : immutable code a lot of that is
24:47 : like coming from what we already know
24:50 : about functional programming it's like
24:52 : well
24:53 : if you're not allowed to modify an
24:55 : object
24:56 : then how do you modify an object well
24:58 : you need create a new object
25:00 : that's like a copy of that old object
25:02 : except you modify this one thing about
25:04 : it
25:04 : right say you have your program is like
25:08 : x equals one and then we're gonna
25:11 : mutate it to what am i going to do
25:15 : right um in a normal programming
25:17 : language this information is stored in
25:19 : the stack frame
25:20 : right so if if you have a if you have a
25:24 : function
25:25 : f then we're creating a stack frame for
25:28 : this particular call of function f
25:32 : and this stack frame is going to store
25:34 : the values
25:35 : of the its variables so initially we're
25:38 : going to put a one minute once it
25:40 : reaches this line
25:41 : we're going to erase it and put a 2 in
25:43 : it right
25:45 : so the way i make that immutable is
25:49 : i represent instead of using the
25:52 : systems stack frame mechanism which
25:55 : which javascript
25:56 : itself has stack frames built in i don't
25:59 : use that
26:00 : i made a synthetic stack frame in my
26:02 : synthetic
26:04 : and my synthetic stack frame is
26:06 : represented as a javascript object i
26:08 : need to remember the
26:10 : name of the function call so i have a
26:12 : fun name
26:13 : i need to represent the parameters that
26:16 : were passed in
26:17 : oh right you could skip that actually
26:20 : you could so i'm not gonna
26:21 : include it but you definitely need the
26:23 : variable and that can just be
26:24 : represented as
26:26 : a dictionary that contains the values of
26:29 : the variables right
26:30 : so so let's say i represent the stack
26:33 : frame like this
26:34 : um well except if you have another frame
26:38 : underneath it like f cos g and then
26:40 : there's more stuff
26:41 : you need another one of these right so
26:44 : you can
26:45 : either use an array or a linked list it
26:48 : at one point i use an array uh now i've
26:51 : switched to linked lists
26:52 : it's cheaper to modify things with a
26:55 : linked list than an
26:56 : array when you when you want to modify
26:58 : an array
26:59 : you have to create a brand new array
27:01 : every single time and and copy
27:03 : all the things over to that array if
27:05 : you're it's just a linked list then
27:07 : you're just modifying
27:08 : the head of the thing so i don't yes
27:11 : so i do it as a linked list now g's
27:14 : parent is
27:14 : f actually so this this frame becomes
27:17 : the parent
27:18 : of another friend this is going to be
27:21 : another frame
27:22 : the function name is g and then it will
27:25 : have its own variables
27:26 : blah blah blah and it will also have a
27:29 : parent
27:30 : that happens to be pointing at that
27:33 : so if you can represent the stack as
27:36 : objects then you can mutate that object
27:39 : in an immutable way
27:40 : right you just instead of changing the
27:43 : value here
27:44 : you just make a new version of the
27:47 : object um
27:48 : you can reuse the bits that didn't
27:50 : change but
27:51 : but then the bits that did change you
27:53 : you have it point to a new value so
27:55 : in this case do you create a new object
27:59 : uh for this frame yeah i i would have to
28:03 : create a new one of these
28:04 : and a new one of these if there's other
28:07 : variables i would have to copy them over
28:09 : in in here and then just change this one
28:12 : right
28:12 : okay so another question how do you have
28:15 : the unique identifier to say hey
28:19 : i want to go back to when x okay so the
28:22 : the unique identifier is a
28:24 : is an auto incrementing id like a
28:27 : database would do
28:28 : if you had an auto incrementing id okay
28:31 : so if
28:31 : so if you see like uh a mutation you
28:34 : will
28:35 : create another thing which yeah exactly
28:37 : new id
28:38 : yes okay so yeah and i'll show you some
28:42 : of the code
28:42 : that's making this stuff work so these
28:44 : are the nyx id counters
28:47 : that's generating the new unique
28:50 : identifiers
28:51 : for for these database objects so
28:53 : instead of doing it in the database
28:55 : i do it in the program itself because
28:58 : that way
28:58 : i don't have to ask the database for
29:01 : what the next id
29:02 : is and then the logger can just be more
29:05 : be faster because it doesn't have to
29:07 : wait on the database f
29:08 : it can generate its own ids so if we
29:11 : looked at if
29:12 : let's search for where that gets
29:14 : modified so that gets modified whenever
29:17 : we
29:18 : call this log new object method
29:21 : which is part of the logger so
29:24 : i have this logger guy i have multiple
29:27 : implementations of the logger there's a
29:29 : no
29:30 : logger which does not log but we have
29:33 : the sqlite logger
29:35 : all of them have the same api when do we
29:37 : log a new object
29:39 : uh this is this is push frame guess what
29:42 : push frame is
29:43 : push frame happens when you call a
29:45 : function
29:46 : it pushes a new frame onto that stack of
29:49 : frames
29:49 : so it makes sense that right we need to
29:52 : because we're generating a new variables
29:54 : object to contain the new variables and
29:57 : we
29:58 : need another object for the new frame as
30:00 : well so that's
30:01 : this is exactly what that is happening
30:04 : um and then we
30:06 : the way i the way i implement a language
30:09 : is actually with an
30:10 : array array of length two now the first
30:12 : one is the this frame
30:14 : the next one is another array of size
30:16 : two
30:17 : that's how i implemented linked list
30:19 : okay what is the next
30:20 : what is the dollar size stack dollar
30:23 : sign here
30:23 : dollar sign stack is the current stack
30:26 : uh
30:27 : so during the during the execution of
30:29 : the program
30:30 : itself whenever a function call is
30:33 : called
30:34 : we have to modify the stack and then
30:37 : dollar stack is always the current stack
30:40 : oh okay
30:41 : gotcha okay so you basically just like
30:43 : add a new layer
30:45 : yeah exactly okay and then you and then
30:49 : yeah in inver inversely we have pop
30:52 : frame
30:52 : which is going to take that like i said
30:55 : the first
30:56 : item in the array is the like current
30:59 : frame
31:00 : so it gets the current frame and it does
31:03 : some
31:04 : cleanup the cleanup is another thing i
31:06 : need to talk to you about
31:07 : that that concerns garbage collection
31:10 : and
31:11 : automatic reference counting so
31:14 : uh that will be a interesting topic for
31:16 : another time
31:18 : but basically it removes it the stack is
31:21 : now the second thing in that array now
31:24 : which is
31:25 : like the parent stack so we just popped
31:28 : but
31:28 : okay more or less that's how
31:30 : immutability
31:32 : works we should try to talk about
31:34 : garbage collection
31:35 : and automatic reference counting
31:39 : at some point this is something i want
31:41 : to talk about because
31:43 : i love developer maybe are not aware of
31:46 : these things happening and and also you
31:48 : know might not have program in a
31:50 : programming language that does not have
31:53 : these things
31:54 : in it