Time Machine Status Update 1

I give a status update on the project I've been working called the "Time Machine".

Transcript

The following transcript was automatically generated by an algorithm.

00:01 : hi there this is toby um
00:03 : and welcome to a status update on the
00:05 : time machine
00:07 : i thought i'd start with some a little
00:09 : bit of brazilian music this time
00:13 : put ourselves in a good mood i'm gonna
00:16 : fade this out
00:21 : okay uh i'm gonna fade this out so that
00:24 : uh
00:25 : hey this video doesn't get taken down
00:28 : hopefully
00:29 : um but anyway um
00:32 : i thought i would do a sort of a status
00:35 : report
00:36 : on the research project i have been
00:39 : working on
00:40 : um on and off for a while now
00:44 : the main repository for this project is
00:47 : the play lang
00:48 : repository which stands for the play
00:51 : programming language but um
00:53 : as the project description says the play
00:55 : project the play
00:57 : is a program language intended for use
00:58 : as a testbed for various
01:00 : compiler runtime and debugger
01:02 : technologies and the
01:04 : particular thing i'm working on right
01:05 : now is the time machine
01:08 : the time traveling debugger which i have
01:12 : explained um in various videos so if you
01:16 : feel like you would like to get more
01:18 : detail about that
01:20 : please watch those previous videos um
01:23 : this is going to be
01:24 : a um status update as in
01:28 : i feel kind of lonely um and
01:31 : just working on this by myself without
01:34 : anyone to
01:35 : talk to bounce ideas off of so this
01:39 : uh creating a video like this if nothing
01:41 : else
01:42 : lets me talk about it um
01:45 : and uh best case scenario is one of you
01:49 : watching can actually give me some
01:50 : feedback and perhaps give me some ideas
01:54 : about it okay so what have i
01:58 : been working on so um i actually publish
02:02 : a lot of live coding videos
02:04 : [Music]
02:06 : of myself working on this deep zoom
02:08 : debugger in the past
02:10 : and then later uh do i even yeah i
02:13 : have this reap repository
02:16 : a separate repository for the deep zoom
02:19 : debugger
02:20 : um uh there it is but um
02:24 : i created a couple of introductory
02:27 : introductory videos explaining the deep
02:30 : zoom debugger
02:33 : and actually i might just play one of
02:36 : those for you
02:37 : to just give a very very brief
02:40 : overview
02:44 : introduction of what that is and my
02:47 : computer is a little bit slow because
02:49 : i'm trying to record
02:50 : this this is only a five minute video
02:53 : i'm not going to play all of it
03:01 : actually it might actually be better to
03:03 : instead of playing
03:04 : so it's largely inspired by google earth
03:08 : the the concept of deep zoom and
03:11 : and if you go here you'll see that
03:14 : with this debugger
03:17 : um you can kind of zoom into the
03:19 : execution of the code
03:20 : like so so this is a fibonacci
03:23 : function uh
03:27 : you can keep drilling down into the
03:30 : recursion um
03:32 : and um and then i also made a video
03:35 : with my colleague koichi jo explaining
03:38 : the concept to her and
03:39 : she gave me some pretty good feedback
03:41 : about it
03:42 : um what i've been working on more
03:44 : recently in the recent
03:47 : maybe three or four weeks is uh sort of
03:50 : merging the code in the deep zoom
03:52 : debugger back into the play
03:54 : programming language and i will sort of
03:57 : show you that
03:59 : so at this point you can
04:02 : i have this tic-tac-toe game which i
04:03 : will show you but before that
04:05 : let me just show you like a very very
04:08 : simple program
04:09 : say something that counts to 10.
04:13 : so this is a program that counts to 10.
04:16 : and we're we're able to
04:20 : let's see if this works
04:25 : oh i have i have a web compile command
04:30 : which will actually compile a program
04:32 : like this
04:33 : for the web page to execute
04:40 : let's see if this works so you end up
04:42 : with this
04:43 : um this is actually currently optimized
04:47 : for a
04:47 : canvas based application which
04:51 : this count to 10 application isn't but
04:53 : what you do get is this debug button
04:56 : here which if you click on it
04:58 : will allow you to let me move this
05:01 : in so you can see all the controls so
05:04 : you can step
05:05 : backwards and forwards in time and you
05:07 : can see the variables
05:09 : stay at any point in time again this is
05:12 : similar to the python tutor this is
05:15 : the step debugger where you can
05:18 : walk forward and backwards in time
05:21 : there's also this zoom button
05:22 : you may have noticed which if you click
05:25 : it switches the
05:26 : step debugger into the zoom debugger
05:30 : and with the zoom debugger you can
05:32 : actually zoom in
05:34 : and see this visualization of what the
05:37 : program
05:38 : is doing and the way
05:42 : a while loop is visualized in the zoom
05:44 : debugger is actually it
05:46 : just repeats the while loop over and
05:48 : over again
05:50 : every line that gets executed is
05:53 : surf display on a separate line and
05:56 : whenever there's an
05:57 : assignment to a variable it shows you
05:59 : the value that was assigned to it so you
06:01 : can
06:01 : follow the execution of this code this
06:04 : way um
06:06 : we don't have anything that helps you
06:08 : visualize
06:09 : what it prints out unfortunately uh i
06:12 : imagine if we had that it might be like
06:15 : a little
06:16 : transcript that's on the side but cannot
06:18 : you can also traverse
06:20 : it the the value of the transcript over
06:22 : time by
06:23 : hovering over here maybe i'm not sure
06:26 : okay so that's what the zoom debugger
06:29 : looks like when it's integrated into the
06:32 : language
06:33 : um oh i want to show you the
06:36 : tic-tac-toe game now
06:38 : [Music]
06:40 : one idea that i got from watching
06:43 : jonathan blows videos jonathan
06:46 : below if you don't know him he created a
06:50 : programming language called jai for the
06:52 : purpose of
06:53 : making high-end games of which he's
06:56 : in the he's in the industry of doing
07:01 : and what he has
07:05 : um that really works well for him is
07:08 : that
07:09 : while he's building the programming
07:11 : language
07:12 : he's actually using it to build a real
07:16 : production level game on the programming
07:19 : language
07:20 : so he gets sort of real feedback
07:23 : from real world usage scenarios so i
07:26 : took a page from that and tried to build
07:28 : something that's closer to
07:30 : a real world scenario um
07:33 : i haven't fully gotten there yet but i'm
07:36 : approaching
07:37 : it that direction uh building
07:40 : out basically more complex applications
07:44 : applications that can be considered more
07:46 : real world
07:48 : and i was thinking of building a chess
07:52 : game actually but i thought that's kind
07:55 : of hard let's build something slightly
07:56 : simpler
07:57 : and that is a for me that was a tic tac
08:00 : token
08:00 : so let me show you that tic tac toe
08:10 : okay so this is the tic-tac-toe game i
08:12 : can play against the computer
08:15 : i wrote an ai for this tic-tac-toe game
08:20 : based on the mini max algorithm
08:24 : which is already giving the
08:27 : the debugger some troubles which i will
08:30 : explain later
08:31 : so i'm going to play a couple of games
08:34 : here
08:38 : and if i go into debug mode uh again i'm
08:41 : able to use the step debugger to step
08:43 : backwards in time
08:44 : and i can also use the zoom debugger uh
08:47 : let's expect
08:48 : step backwards um and we'll step into
08:52 : one of the games
08:52 : that was played
08:57 : there's a draw board function that draws
08:59 : the board if you want to step into the
09:01 : draw
09:02 : board routine and step through how
09:06 : how the board was drawn you can do that
09:10 : uh by the way this is uh this is a
09:13 : html5 canvas that is drawing on top of
09:16 : i provided functions for the runtime
09:20 : in the runtime for the program to draw
09:22 : to
09:25 : and have these uh arrow functions for
09:28 : stepping
09:29 : out stepping in etc um
09:32 : human move that's human move and if
09:34 : you're
09:36 : wondering how the computer ai works well
09:40 : here's this
09:40 : smart computer you can step into the
09:43 : code
09:44 : line by line and so forth let's look at
09:47 : it
09:48 : using the zoom debugger though so this
09:51 : is the zoom debugger and
09:52 : you could see that
09:56 : using the zoom debugger very quickly oh
09:58 : we played two games
10:00 : and i i can zoom into the execution of
10:03 : the first
10:04 : game
10:09 : i actually have done a lot of work on
10:11 : the visualization
10:13 : of the arrays
10:16 : and dictionaries so currently the board
10:19 : looks like this
10:21 : uh which i think is a pretty good bird's
10:24 : eye view of what's going on
10:26 : so i can see oh first human move was
10:30 : the o in the center and
10:32 : [Music]
10:33 : and then the first computer move was
10:35 : over here etc
10:37 : and if you want to drill down more
10:41 : into how the computer works you can
10:43 : drill into
10:44 : this smart computer function call
10:47 : and then most of the meat of what
10:50 : happens is in this smart computer
10:52 : calculate move
10:54 : function which i hope it will let me
10:58 : drill into
10:59 : but
11:02 : one problem i have yet to solve is
11:05 : when the text gets too small
11:08 : versus the aspect ratio of the box
11:12 : sometimes the the layout is slightly
11:15 : wonky
11:17 : but anyway so there's there's the the
11:19 : code in the next level
11:21 : so this is a recursive function call so
11:23 : for each function called to smart
11:25 : computer calculate move
11:27 : it calls it again for each possible
11:30 : move at that level and what it does
11:34 : is um basically tries
11:38 : every move so like it finds the first
11:40 : open
11:41 : square and then try that it's like
11:44 : imagine that i moved here with this
11:48 : imagine move function and if you give a
11:51 : board
11:51 : to the imaginemove function and tell and
11:54 : say
11:55 : i want to move myself to that square
11:58 : identified by that index it'll
12:01 : basically generate a new board
12:04 : for you uh
12:10 : which would be the result of you having
12:12 : made that move
12:14 : and then given that it caused itself
12:17 : again
12:17 : to calculate the opponent's move on
12:20 : behalf of the opponent see what
12:22 : the opponent would have made this is
12:24 : based on again
12:25 : based on the minimax algorithm okay
12:28 : so all of that to say that once i
12:32 : once i did this
12:35 : i actually saw huge performance problems
12:40 : and in particular if
12:44 : like first of all it is already very
12:48 : intensive to run this
12:51 : this this this ai algorithm
12:54 : on a very very small board uh
12:58 : this is just a tic-tac-toe game with
13:00 : nine squares i don't even know what's
13:02 : gonna happen with a
13:03 : chess board right um
13:06 : what happened was when when the depth
13:10 : was significantly high uh up to
13:13 : level five then the entire browser just
13:16 : froze
13:18 : and i found that the memory usage
13:21 : was way up it was up to like
13:24 : 200 megabytes more than 200 megabytes of
13:28 : memory usage for that browser tab and
13:31 : then
13:32 : the browser just froze i i guess the
13:35 : the chrome didn't want to give this tab
13:38 : any more
13:39 : memory so i thought long and
13:42 : hard about about this problem about how
13:45 : i could fix it
13:46 : one way i could fix it obviously is to
13:48 : improve this
13:50 : implementation of this ai algorithm
13:53 : to make it use less memory but
13:56 : that's actually not the point i'm i'm
14:00 : building a
14:02 : programming language runtime and i want
14:05 : it
14:05 : to be able to handle big loads so
14:09 : even though this the the minimax
14:11 : algorithm is
14:12 : obviously implemented in a very poor way
14:17 : i don't want the fix to be the algorithm
14:20 : itself
14:21 : but i i want it so that the
14:24 : time machine can do what it's supposed
14:26 : to do
14:27 : but uh uh even even when it's
14:31 : having to deal with a large large load
14:33 : so the reason that it was
14:35 : using memory way too heavily is because
14:39 : at this moment at the the code that
14:42 : you're seeing right now
14:43 : the program actually saves every single
14:46 : state
14:46 : of the program itself in memory
14:50 : um that's that's what allows you to step
14:55 : backwards in time because every single
14:58 : state that the program has been in
15:01 : is saved into memory and what happens
15:04 : when we exceed
15:05 : the available memory well the program
15:07 : just dies
15:08 : so instead of doing that what i decided
15:11 : to do
15:12 : was okay we're no longer going to store
15:15 : every single state
15:16 : of the program in memory we're going to
15:18 : let
15:19 : the previous states be reclaimed
15:24 : and we're just going to not keep
15:27 : references to them anymore and allow the
15:29 : garbage collector to
15:30 : take them and reuse them for the current
15:33 : program
15:34 : and instead of that we're going to save
15:36 : that state
15:38 : into a database we're going to save it
15:40 : on disk
15:42 : um so that it's no longer a memory
15:44 : problem but it's a disk space
15:46 : problem let's defer the problem onto the
15:49 : disk
15:50 : so that's what i did i decided to use
15:54 : sequel light i considered using actually
15:58 : i went down this path of
16:02 : um i went down this path of
16:05 : like learning how to build a program
16:08 : build a database myself and there's
16:12 : there's very little information
16:15 : about uh how to actually build a
16:19 : database but i did found
16:20 : find a few and i was actually going to
16:22 : do that
16:24 : um but stopping short
16:27 : barely i decided to design a database
16:30 : schema
16:31 : and just build this using sql lite and
16:34 : possibly level db as well as i think
16:37 : that both of these are good choices for
16:39 : what i'm doing because
16:40 : both of them are are in process
16:43 : databases and you save the data into a
16:46 : single file
16:47 : instead of requiring like a database
16:50 : server
16:52 : okay so um so i implemented that
16:56 : uh json r is a json-ish format
17:00 : that i made which i'll explain a little
17:02 : bit later so
17:05 : so let me now switch to my database
17:07 : branch
17:11 : and oh i'll just dash
17:18 : okay i want to show you a little bit of
17:22 : how how that
17:25 : works now so i did a bunch of database
17:28 : work
17:29 : um loading the runtime
17:33 : state of the program into a sqlite
17:36 : database
17:36 : as the program is running and
17:40 : so to give you an idea of how that stuff
17:42 : works
17:44 : um if i compile a program now
17:47 : let's say this tic-tac-toe program
17:51 : and that generates this javascript file
17:53 : oh um
17:54 : and okay there's actually a lot
17:57 : i i'm gonna have to explain um
18:01 : the current state of the thing is the
18:04 : the code
18:05 : i decided to bring the runtime back into
18:07 : node.js
18:08 : instead of being in the browser so now
18:11 : the node.js
18:12 : the tic tac toe i made a terminal
18:16 : version of the tic tac toe program
18:20 : uh instead of the canvas version
18:24 : i just ported that one to to to be a
18:27 : terminal based version
18:29 : and now uh when this this is the
18:33 : generated code
18:34 : when you compile the tic-tac-toe
18:38 : terminal version
18:45 : okay so this is the tic-tac-toe terminal
18:47 : version uh instead of
18:48 : using like if you look at the draw board
18:51 : function for example instead of using
18:55 : fill rect to draw the board it's just
18:57 : going to use the print command to print
18:59 : it into the terminal
19:00 : and so forth but the computer code
19:02 : actually mostly did not change
19:04 : the the ai code that uses the minimax
19:07 : algorithm it stayed the same so i still
19:11 : get to
19:12 : test that part of the code which was the
19:14 : point is like when
19:16 : the execution of the program blows up in
19:18 : complexity can i handle it
19:20 : um and and what happens is
19:24 : uh i have this function to initialize
19:28 : the sqlite database at the beginning
19:30 : which gets called here
19:33 : and it creates the tables that are
19:35 : needed
19:36 : and it will initialize the file
19:38 : basically
19:40 : and then i'll generate these prepared
19:42 : statements
19:43 : for inserting into the database
19:47 : and i have
19:51 : two functions uh one is called the send
19:54 : objects function and then another one is
19:57 : called the
19:58 : send oh the there's
20:01 : three functions the send function call
20:03 : function the send
20:04 : snapshot function and the send objects
20:06 : function
20:08 : each of them will take the state
20:11 : a particular snapshot of the state of
20:14 : the program
20:15 : and insert it into the database using
20:17 : one of these prepared statements okay
20:20 : and because all of the objects in the
20:23 : programming
20:24 : runtime are immutable when you mutate
20:27 : things
20:28 : it just generates new versions of the
20:30 : objects instead of
20:32 : mutating actual objects
20:36 : there's no worrying about mutating the
20:40 : records in the database everything that
20:43 : happens to the database
20:44 : is an insert so that made that part of
20:47 : the implementation
20:49 : quite simple so we're just inserting a
20:51 : whole bunch of objects
20:53 : into the database so let me try to run
20:56 : this tic-tac-toe game here
20:59 : and show you
21:04 : i hope it still works okay so you can
21:08 : pick a move
21:08 : between one and nine i'll pick five
21:11 : which is the center
21:12 : and it's running the ai algorithm now
21:16 : which is actually taking a while it took
21:20 : 5.7 seconds i believe it's probably
21:24 : a little slower while i'm recording
21:29 : uh this video because my video recording
21:32 : software actually takes a lot of cpu
21:34 : but uh when i tested uh last
21:38 : it actually took about uh two seconds
21:41 : for the first move which has to do the
21:44 : deepest traversal
21:47 : so i'm going to block this x down here
21:50 : with
21:50 : 7 and i win the game
21:54 : so now i'm going to say no and once i
21:58 : stop the program um
22:01 : a a history file is generated and
22:04 : that history file is actually a sqlite
22:08 : 3 database file and i can open
22:12 : it up so let's open it up to see what's
22:15 : going on
22:23 : uh where is it oh there it is
22:27 : okay so the first thing you see is that
22:31 : there's a fun call table um every record
22:35 : in the fun call table
22:37 : is a function call it's a particular
22:39 : function call
22:40 : with particular parameters
22:43 : and you can see the parameters column is
22:46 : actually a number
22:47 : that number is a reference to an object
22:50 : in the object table and i'll show you
22:53 : that
22:54 : so what this says is there's 2919
22:58 : function calls
22:59 : made in the execution of that game and
23:02 : we see the function name
23:04 : of each of these function calls there's
23:07 : also
23:08 : the snapshot table a snapshot is
23:11 : a snapshot of this state of the entire
23:14 : program
23:15 : at any one point in the execution of
23:18 : that program
23:19 : so there are 80 80 000
23:22 : more than 80 000 snapshots of the
23:25 : program
23:27 : each snapshot has an id it has the
23:31 : current stack state and the current
23:34 : heap state and each of those again is a
23:37 : number
23:39 : it's an id to the objects table
23:41 : interrupt is a thing that i am
23:43 : i also invented a little bit earlier to
23:47 : store when i was implementing the canvas
23:51 : uh like
23:55 : yeah implementing the canvas drawing and
23:57 : trying to figure out how to walk
23:59 : backwards in time and
24:00 : and still have the debugger update the
24:03 : state of the canvas back to what it
24:05 : was i use something called the interrupt
24:08 : which is
24:09 : whenever you send a message to the
24:11 : canvas i capture it in here so that
24:13 : later on i can play that back
24:15 : that the debugger can play that back so
24:17 : but that's not used in here because
24:19 : it's a terminal app now and then we have
24:22 : a line number
24:24 : uh corresponding to that snapshot
24:28 : saved in the database now let's look at
24:30 : the object
24:31 : table object table has an id
24:34 : which is referenced by the other two
24:36 : tables and then it's got this data which
24:39 : is
24:39 : in this json r format and
24:43 : json r is another project that i created
24:47 : as an npm package which you can install
24:50 : this way
24:50 : it's basically json with refs
24:54 : it allows you to define these ids
24:58 : for your objects and arrays
25:01 : and you define it like this so this says
25:03 : i define
25:05 : this object as id 1 and so forth and
25:08 : later on you can refer back to one by
25:10 : using star one
25:12 : star one is a reference and this and
25:15 : sign
25:16 : is a declaration of this id
25:19 : so that's what json r is and
25:24 : and the objects stored in this object
25:27 : table
25:28 : are in json are format so it can have
25:31 : references to other objects in this
25:33 : table and
25:34 : you can see we made a lot of objects
25:38 : and i'm actually hoping i can find a way
25:41 : to
25:42 : reduce the data usage but at
25:46 : current moment we actually have 152k
25:51 : close to 153k objects
25:54 : created as a result of running
25:57 : running this little tic-tac-toe game
25:59 : which seems excessive
26:01 : and i'm sure there's ways to optimize it
26:05 : but yeah but that's what it is um
26:09 : i have not updated the zoom debugger to
26:12 : be able to read from this database
26:15 : and provide the visual experience that
26:18 : it does
26:19 : that's one of the next steps in my
26:22 : project um
26:27 : oh yeah yeah yeah one thing i want to
26:29 : mention is that
26:30 : uh as i was working with sequel light
26:33 : and was doing some performance
26:35 : tuning um on npm
26:39 : there's
26:42 : there's a couple of packages for using
26:44 : for working with sequel light there's
26:47 : just the thing called sequel light
26:49 : there's sqlite three
26:50 : and there's better sequel light 3.
26:54 : sequel light is just a very small
26:56 : wrapper around
26:58 : the sequel light 3 package
27:01 : and sequel light 3
27:04 : is the most current version of sequel
27:06 : light by the way
27:07 : um but uh the the author of sequel light
27:11 : he actually started an effort to create
27:14 : sqlite four
27:16 : um trying to implement uh the
27:20 : the structured log merge tree
27:23 : concept which is in google's bigtable
27:26 : but he he uh he abandoned that project
27:30 : and so sqlite4 is no more and now the
27:33 : current
27:34 : version of sqlite is still sqlite 3 and
27:37 : that's what these
27:38 : node.js packages are going to be talking
27:40 : to however
27:42 : when i when i did some performance
27:44 : testing with
27:45 : these packages i wrote some scripts
27:49 : uh to load tests inserting
27:53 : a very very large file into sqlite
27:57 : sequentially
27:59 : using well this one uses sqlite
28:03 : better sequel light 3 but i had another
28:06 : one that was using
28:07 : just sqlite where was it
28:11 : just yeah these this one that's just
28:13 : using sqlite
28:14 : and it it was
28:18 : yeah i had some performance problem
28:21 : related to
28:23 : my own libraries uh in particular the
28:25 : json r library
28:27 : being slow um after solving some of
28:31 : those
28:31 : [Music]
28:33 : i did run into that the sequel light
28:37 : the sqlite package itself being slow
28:40 : and after switching to the better sqlite
28:44 : 3 library the performance did get
28:47 : a lot better so in terms of
28:50 : performance the better sql like 3
28:54 : npm package is definitely better i did
28:57 : also consider
28:58 : instead of using one of these nvm
29:00 : packages
29:01 : to go down to the c level and write the
29:03 : code in c
29:04 : which i might still explore in the
29:06 : future to get even better
29:08 : performance but to give you an idea of
29:11 : the performance
29:12 : i i took a profile of
29:15 : uh one of these program one of these
29:18 : tic-tac-toe games that i played
29:21 : and this is the flame graph for
29:24 : the execution that oh
29:27 : by the way if you generate a program
29:31 : [Music]
29:33 : if you compile program in the play
29:36 : language
29:37 : it also right now i should make this
29:41 : an option but currently it always does
29:42 : it it
29:44 : it uses the node.js inspector the chrome
29:48 : actually the chrome inspector to take a
29:51 : profile
29:51 : take a cpu profile of the program as
29:53 : it's running
29:54 : so that's another reason it might be
29:56 : slower but
29:58 : what happens when this happens is you
30:01 : can actually load that profile
30:02 : into chrome like this you just click on
30:06 : this button
30:06 : it's actually let's just do that
30:10 : i'm gonna find that profile
30:14 : file that i just just created
30:18 : by by playing that game and load it in
30:21 : here
30:23 : and now you can kind of ignore those
30:25 : warnings and now this is
30:26 : the profile flame graph that was taken
30:29 : by the chrome inspector
30:31 : uh as a result of running that game and
30:34 : and now i can look in detail
30:41 : into what the code is doing and what
30:44 : what part of the execution is taken most
30:48 : of the time
30:49 : and currently it's two things uh
30:52 : the yellow dots and the blue dots or the
30:55 : parts that are not yellow dots uh
30:57 : the yellow dots are actually the writing
31:00 : of the data to the to the database
31:03 : that's the um
31:06 : this exact function is actually
31:09 : the the sqlite driver the better sqlite3
31:14 : driver
31:14 : doing its job but other than that i got
31:18 : this
31:18 : dollar stringify function and that's my
31:21 : code
31:22 : and that's what i can optimize
31:25 : and and i'll show you my code
31:33 : so this function is my code to stringify
31:38 : take an object and stringify it into
31:40 : this json r format
31:42 : and i already rewrote this function once
31:44 : to improve the performance
31:46 : but even after that performance
31:49 : optimization it's still one of the
31:54 : biggest bottlenecks currently and you
31:56 : can compare
31:58 : the performance of this stringify which
32:01 : is taking like
32:02 : 57 of the total
32:05 : uh runtime and then this run is taking
32:08 : 27.7
32:11 : and then i also have registered new
32:13 : objects
32:15 : and imagine move imagine move is the
32:18 : actual code of the program itself
32:20 : right um so if i can
32:23 : improve the performance of this
32:25 : stringify substantially
32:26 : that will also help with the performance
32:29 : and just to give you an idea
32:31 : of in terms of what the performance
32:35 : i'm targeting obviously i would like the
32:37 : performance to be
32:38 : negligible but um
32:42 : currently if i run that same
32:45 : uh tic-tac-toe game without this logging
32:49 : going on versus with with logging is
32:53 : about 33 times
32:56 : slower i believe i can i can run that
32:59 : comparison
33:01 : again so i just ran it right
33:05 : um and i got like about
33:08 : 5.6 seconds
33:12 : of making that first move if i turned it
33:15 : off completely
33:19 : [Music]
33:23 : all i have to do is put a rd return in
33:26 : this function
33:28 : and this function i believe and then
33:31 : it will not do any database logging
33:34 : now let me play that tic tac toe game
33:36 : again
33:46 : this doesn't seem right
33:51 : oh i changed this in the wrong place
33:54 : i changed it in the file that got that
33:57 : was going to get overwritten
33:59 : i should change it in the runtime file
34:04 : instead
34:07 : and again things are much slower
34:11 : with with me running the video recording
34:15 : software
34:16 : at the same time so the
34:20 : data may not be very accurate here
34:23 : but i'm still going to do it just to
34:25 : show you
34:27 : so this only took 429 milliseconds to
34:31 : make the
34:31 : for the computer to make the first move
34:34 : and that
34:34 : means
34:39 : um it's actually about only
34:43 : 13 times slower with
34:46 : with the saving saving the state
34:49 : versus not saving the state um
34:53 : and that's pretty bad although you know
34:56 : given the benefit
34:57 : that they give you i think it's probably
35:00 : still worth it
35:01 : but i basically want to improve the
35:03 : performance
35:04 : as much as possible so that um
35:09 : so that's viable for for use right
35:12 : um so that's what i'm working on uh the
35:15 : next steps
35:16 : of what i'm targeting is first of all
35:21 : update the deep zoom debugger and also
35:24 : the
35:24 : step debugger to be able to read from
35:27 : this database use the data from the
35:30 : database to drive the ui
35:32 : instead of using the in-memory objects
35:35 : to drive the ui
35:36 : and then number two is i want to further
35:39 : optimize the stringify function
35:41 : so that the overhead of logging the
35:45 : state
35:47 : is as negligible as it can possibly be
35:51 : one thing i might do is try to
35:55 : implement that code in c instead of in
35:58 : javascript
35:59 : and hopefully that helps um yeah
36:02 : so that's where i'm heading uh thanks
36:06 : for uh watching if you have been
36:08 : watching this far
36:09 : thank you very much feel free to give me
36:11 : feedback about this project as
36:13 : i would love to hear from you