Time Machine Update and Design Discussion

I give Huiqi an update on the debugger project and we have a discussion about different approaches.

Transcript

The following transcript was automatically generated by an algorithm.

00:00 : okay i'm trying to add this feature
00:03 : but i am not done
00:06 : yet
00:07 : um so
00:11 : if i debug
00:13 : let me clear the screen
00:18 : okay i added this show hits button here
00:24 : it's
00:25 : it's not great ux but uh
00:28 : but basically if you highlight a line in
00:30 : the debugger you click on show hits
00:34 : um
00:35 : you get
00:37 : you get all the hits of that line
00:40 : throughout throughout history
00:42 : okay um but
00:45 : you just see
00:47 : and you can click around like if you
00:49 : look at the timeline
00:51 : you can you can jump to
00:53 : oh i guess i broke it
00:56 : but if it worked then you click on the
00:58 : line
00:59 : and then you would jump to that point in
01:01 : time so each it's each selection is a
01:05 : point in time
01:08 : like each line here is a point in time
01:11 : um if it weren't for the bug
01:14 : then uh you can click on
01:16 : any of these
01:18 : numbers and it it
01:20 : like the step number would
01:22 : would change to that one it would jump
01:25 : to that point in time okay yeah that
01:29 : makes sense
01:30 : um
01:32 : so
01:34 : but the problem with this ui is
01:37 : you see these numbers which doesn't
01:39 : really mean anything to you
01:42 : so
01:44 : um
01:47 : so i wanted
01:48 : to
01:49 : show you some context information
01:52 : so
01:53 : um so i did a separate prototype because
01:56 : it's it's easier to implement something
01:59 : small
02:00 : okay
02:02 : so i think it's c2
02:12 : and you need to provide a code file
02:14 : number so
02:17 : you would um
02:20 : let me see
02:23 : yep let me open this
02:26 : file up
02:28 : uh okay so
02:30 : so you find a file i'll go
02:34 : oui core
02:40 : and let's we go for the same line which
02:44 : is
02:45 : i went for here 370.
02:48 : so on the command line and i say
02:52 : uh 12 oui core is 12
02:56 : and then line 370
02:59 : and then
03:00 : it'll it'll print out that same uh
03:04 : snapshot number but also show you
03:07 : some context information which in this
03:10 : case is
03:11 : some attributes of the event object
03:16 : that was uh that was on
03:18 : when you were basically when you were on
03:20 : this line
03:22 : it shows you a little bit
03:24 : of what the event object was at that
03:27 : point so how do you decide what kind of
03:30 : context to show
03:32 : yeah that's something
03:34 : that's
03:35 : kind of interesting
03:38 : um
03:43 : i'll show you the the second feature
03:45 : that i want to show first and then i'll
03:47 : explain how this works because the
03:50 : second feature also uses this it also
03:52 : uses the same infrastructure
03:55 : um the second one is um
04:01 : uh the naming is really convoluted
04:04 : because
04:06 : because i'm uh really being sloppy right
04:09 : now that this is a quick and dirty
04:11 : prototype
04:12 : that i'm not gonna use anymore at some
04:15 : point
04:16 : um but
04:22 : in this one what you do is
04:24 : this one shows you uh all the times that
04:27 : a particular function has been called
04:31 : so i'm going to choose say the add child
04:35 : function
04:37 : oh no i want to go to the
04:44 : two so 242 is what i want
04:49 : and uh
04:52 : yeah so
04:53 : it's gonna print out every single time
04:55 : that the add child function has been
04:57 : called
04:58 : okay and um it will actually print out
05:03 : the line
05:04 : that called the function
05:08 : which is sort of like
05:11 : um not the first line inside the
05:13 : function but the the one step previous
05:17 : to that so you so you can see the line
05:19 : that actually caught the function
05:22 : and then also it again shows you some
05:25 : context information it shows you some
05:27 : attributes of the
05:30 : parent parameter which is the first
05:32 : parameter and then some attributes of
05:34 : the child parameter
05:38 : and then that way you can scroll through
05:41 : this list
05:43 : and
05:43 : [Music]
05:45 : you know you you actually get some
05:47 : useful information about what
05:50 : what uh
05:52 : what things are getting into the
05:54 : function
05:56 : maybe find what you're looking for just
05:58 : by scrolling through
05:59 : yeah
06:01 : yeah i like
06:03 : yeah so and uh it's it's not as good as
06:06 : i would like it to be yet
06:08 : um
06:10 : this this the algorithm that decides
06:13 : what information to show so let me
06:16 : explain that algorithm and maybe you can
06:18 : even
06:19 : maybe you can brainstorm possible ways
06:22 : of making this algorithm better
06:26 : um okay so
06:28 : uh maybe i'm i'm gonna
06:30 : sketch out the idea first
06:33 : without before showing you any code
06:38 : okay
06:39 : so
06:42 : okay
06:43 : so let me see
06:46 : um
06:48 : okay the idea is that
06:52 : um
06:54 : like at any point in time
06:58 : let me go back into the
07:00 : debugger okay i go in here
07:04 : at any point in time there are
07:08 : there's a context that like look like
07:11 : all the state at that point in time
07:13 : there's a context and in addition to the
07:16 : state there's also the context
07:19 : of the code execution as in
07:24 : um
07:25 : as in like
07:26 : who is your parent function that called
07:29 : into you right
07:31 : so so that that's called the
07:33 : back trace or the other stack the stack
07:36 : trace
07:38 : um so
07:41 : um so i guess two pieces of information
07:44 : is like one is the variables
07:47 : or maybe the state of the variables
07:55 : and then another is the um
07:59 : the context
08:01 : execution context which is like
08:04 : the
08:06 : basically the stack
08:09 : the state of the stack
08:10 : frame
08:11 : [Music]
08:14 : um
08:14 : [Music]
08:17 : and
08:19 : actually when when i was first thinking
08:21 : about this solution
08:24 : it was not
08:26 : um
08:28 : it was not
08:30 : applied to this problem
08:32 : um
08:33 : and i
08:34 : the this
08:35 : initially when i was thinking a lot
08:37 : about this i was more thinking about
08:42 : um if if i wanted to display
08:46 : um
08:48 : like like that call
08:52 : you know that call the c the first c
08:55 : code
09:03 : this one
09:08 : i don't know if this is even gonna
09:11 : this might take too long
09:13 : let me try
09:21 : yeah we'll go with this one
09:23 : um i i was thinking actually
09:27 : um i want to
09:30 : i want to make this more useful by
09:34 : showing you the actual values
09:36 : of the of like maybe
09:40 : like this is a recursive call and this
09:44 : is gonna end up being fib of eight right
09:47 : so i might wanna show that and then this
09:50 : this will end up being fib of seven like
09:54 : having these
09:56 : be
09:57 : replaced with or supplemented with the
10:00 : actual values at the time
10:03 : it will be useful for you reading
10:05 : through this and understanding it
10:07 : um
10:08 : but the problem is what if this was not
10:11 : just a number what if it's a composite
10:14 : object that has multiple attributes in
10:16 : it right
10:19 : it's very difficult to inline a large
10:21 : number of information a large amount of
10:24 : information right
10:28 : but i still want this feature
10:30 : so how can we do it um i thought about
10:34 : showing the unique identifying
10:37 : attributes of the object like like maybe
10:40 : if the object was a person
10:42 : uh-huh like if it's like i don't know
10:47 : uh add
10:49 : person
10:52 : and then you pass in a person
10:55 : this is the code and then i'm gonna i'm
10:58 : gonna show
10:59 : person
11:00 : [Music]
11:04 : id equals five
11:08 : name
11:09 : equals toby or something right
11:13 : but it the person might have other
11:15 : attributes but i'm not going to show
11:16 : that i'm i'm going to show the most
11:19 : distinctive features of person
11:22 : how do you know that's the most
11:24 : distinctive feature
11:26 : yeah so
11:27 : exactly so i thought about how can i
11:29 : find the most distinctive feature
11:32 : uh
11:34 : well i could do it if i can look through
11:36 : all of the persons in my database
11:40 : and compare the attributes
11:46 : well
11:47 : what
11:48 : but
11:49 : i mean
11:51 : would that like make it slower
11:53 : if you have to do that yeah it will make
11:56 : it slow um so
11:59 : so
12:00 : if there's a large number of per
12:03 : is it's actually not not all persons
12:06 : it's all historical persons because
12:08 : of versions of the persons
12:11 : um we'll look at uh but
12:14 : but yeah it'll be slow if there's a lot
12:17 : of them to look through so what we could
12:19 : do instead
12:21 : is a random sampling
12:24 : we randomly pick
12:26 : some of the persons
12:28 : from the entire set of historical
12:30 : persons
12:32 : and out of the sample
12:34 : we're gonna compare them
12:36 : in order to find the most distinguishing
12:39 : features
12:40 : um
12:42 : well true
12:43 : to me
12:45 : if
12:46 : we could
12:49 : if
12:50 : if we could like
12:52 : uh
12:53 : well if if it's like oh you just show me
12:56 : a equals to fib n minus one
13:00 : and then i can like click on n and then
13:04 : you will show me the value
13:07 : but that will make it
13:10 : less like
13:11 : direct
13:13 : because like haven't have an interactive
13:15 : feature yeah to let you choose what
13:18 : attribute yeah but the thing is if you
13:21 : have to click on n in order to see what
13:24 : the value of n is
13:26 : then i cannot just browse
13:29 : stuff to find
13:32 : what i need to find but
13:34 : um you can have a search functionality
13:38 : you can have a search functionality yep
13:40 : um
13:41 : yes
13:42 : those are all
13:45 : possible that yeah i'm planning to have
13:47 : like a
13:48 : conditional
13:50 : kind of
13:51 : let you type in a conditional and only
13:54 : show you those
13:56 : but
13:57 : i think
13:58 : showing the values will still be very
14:01 : helpful
14:03 : if you can manage to pull it off
14:05 : so so anyway so this is the prototype
14:08 : that
14:09 : uses that concept
14:11 : so
14:12 : um
14:13 : indicate so go back to
14:20 : the first example
14:22 : where it did this
14:24 : um
14:24 : [Music]
14:26 : i
14:28 : in this case what i actually did was
14:32 : i did a heuristic
14:34 : which may or may not be good
14:36 : but um
14:39 : the the heuristic is i use the line of
14:42 : code which is this
14:44 : okay and i parse out the variables that
14:48 : are referenced by this line
14:50 : okay
14:51 : which um
14:53 : and i i'm not i'm i decided to ignore
14:56 : the attributes so basically i just
14:58 : picked out the variable event from here
15:02 : and i
15:03 : i show even there's also a context
15:06 : which is the who's
15:08 : who's the parent call
15:10 : into the into whatever function i'm in
15:13 : who's the parent's call
15:15 : i i put that context as a potential
15:18 : candidate for being displayed here
15:21 : but it turns out that
15:25 : that was not as good
15:27 : as these attributes of the event
15:31 : um so it this it decided to pick the
15:34 : event type
15:35 : the and the event uh positions x and y
15:42 : and let me show you
15:44 : the code so i have this get
15:47 : distinguishing attributes function
15:50 : which
15:52 : it it picks 10 samples
15:55 : okay so so that's the random
15:58 : function to generate an index
16:00 : into the array of snapshots
16:03 : [Music]
16:06 : and then there's a bunch of stuff but
16:09 : essentially
16:11 : what it does is for each
16:14 : uh i'll do some
16:16 : actually
16:19 : actually i'm going to
16:24 : let me try let me see if i can put this
16:26 : in the debugger
16:28 : [Music]
16:34 : this is
16:51 : actually i can just go to c code too now
16:55 : using the shortcut
16:57 : the quick
16:58 : launch
16:59 : um
17:02 : okay so let's go to this
17:04 : get distinguishing features
17:07 : function oh there it is i think
17:10 : yep right here
17:11 : all right
17:12 : uh so
17:14 : so get a random number 18.
17:18 : um
17:18 : and we're gonna get a snapshot
17:22 : so this is one of the snapshots and it
17:25 : and uh but that's
17:27 : uh we're gonna grab some
17:30 : variables though
17:31 : oh first we're going to get the context
17:35 : the attributes is the attributes is the
17:39 : thing
17:40 : that is going to have the things to be
17:44 : compared to find which which ones are
17:46 : the distinguishing attributes so these
17:49 : are like all the attributes
17:51 : uh i first put the context here which is
17:54 : like hey i was called by the start
17:56 : function
17:57 : in in this gui
17:59 : file
18:02 : and then and then here i we collect the
18:04 : variables
18:06 : into this attribute
18:07 : so
18:12 : so at the end we have we'll just have
18:14 : one variable which is the event
18:17 : and we have all of these
18:19 : attributes within the event put in here
18:23 : um
18:24 : but then i scored the attribute
18:27 : uniqueness
18:28 : um
18:31 : which is which um
18:34 : let's see
18:35 : which i accumulate that into this scores
18:39 : dictionary which was um
18:44 : which was initialized here so we start
18:47 : with a scores dictionary
18:49 : and then we go through each
18:52 : sort of snapshot
18:53 : and each snapshot we get this attribute
18:57 : object that has these things in it
18:59 : and then we
19:01 : sort of accumulate it into this scores
19:03 : dictionary and at the end
19:06 : when we have everything accumulated
19:09 : uh we have these scores
19:14 : uh so basically each of these um
19:18 : each of these
19:19 : i i sort of expand the path or not
19:23 : yeah i i
19:26 : i make the nested paths sort of this
19:29 : long lengthy
19:30 : path string
19:32 : okay and then so for each of these
19:35 : attribute paths
19:36 : i have a set
19:38 : uh of all the different values that i
19:42 : have seen
19:44 : throughout those 10 samples
19:48 : so like some sometimes i get mouse down
19:51 : sometimes i get key press sometimes i
19:53 : get mouse up and so forth right
19:56 : so that's it and then the context but
19:57 : the context is always the same the kind
20:00 : because
20:00 : i only get called from the start
20:02 : function so the context didn't change so
20:05 : that's not going to get a high score
20:08 : but the ones that have a lot of distinct
20:11 : values
20:12 : uh i basically pick those
20:16 : oh this is oh the key this is the key
20:19 : press the key presses right press i p
20:22 : and h
20:24 : and so forth so as you can see like this
20:26 : is the best one right the event type is
20:28 : the best one
20:29 : and the x and the y are probably the
20:31 : next best this is good too but it didn't
20:34 : get picked
20:35 : so
20:36 : so yeah so that's how it works and at
20:39 : the end i uh
20:41 : let's see
20:43 : i picked the attributes to use
20:46 : and those are the attributes to use and
20:49 : i do that by
20:51 : i just pick that i sort them and then
20:53 : pick the top three basically
20:56 : so what if this line has like five
20:59 : different objects then what
21:03 : are are we going to show like
21:06 : uh one attribute for each one or is
21:09 : there a score for that two
21:12 : which line has five different objects
21:15 : attributes to use well if like say the
21:18 : line that you're
21:19 : uh
21:20 : showing in the timeline because this guy
21:23 : only has one
21:25 : object which is event right oh yeah
21:27 : there could be more and in which case
21:31 : it will go
21:32 : as in a separate variable under
21:35 : variables
21:36 : okay as another variable
21:40 : and then and then what happens is um it
21:44 : gets scored
21:45 : the same way
21:47 : it's not the variables that are getting
21:50 : scored but the attribute that's getting
21:52 : scored so good because at the end you
21:55 : get
21:58 : you get these
22:00 : oh okay you always go down to a leave
22:04 : attribute which is
22:06 : and probably going to end up being a
22:08 : number or a string
22:11 : because because if the if you walk all
22:14 : the way down and that's not
22:17 : that's still a composite object
22:20 : i actually those are not gonna get a
22:23 : high score because i don't know how to
22:25 : compare
22:27 : like like i have a
22:29 : i have a max depth
22:31 : of how
22:32 : how deep i want to fetch
22:35 : which is just one or just two at the
22:38 : moment okay okay so it doesn't go very
22:41 : deep and when once it gets to the max
22:44 : depth
22:46 : if it's another object it's not going to
22:48 : fetch the values of the object it's just
22:50 : going to say this is a mystery object
22:52 : and
22:53 : and and then the the problem with the
22:55 : mystery object is
22:57 : it's just gonna when you compare two
22:59 : mystery objects they're usually gonna be
23:03 : the same
23:04 : okay yeah
23:07 : so so the only ones that will be
23:10 : different will usually be like the
23:12 : strings the numbers and the booleans
23:16 : that make sense so yeah so that's
23:19 : how it works um
23:23 : yeah and then and then once you get the
23:26 : attributes to use
23:28 : um now you go through all of the
23:31 : snapshots not just a randomly sampled
23:34 : one and use those attributes
23:37 : to select
23:38 : the values from
23:40 : every single snapshot and display them
23:45 : okay gosh so you have to make a
23:47 : sql
23:49 : query
23:51 : in both cases i
23:53 : like even to get the distinguishing
23:55 : attributes i had to make sql queries
23:57 : there also
24:00 : yeah
24:02 : um
24:03 : yeah so that's how that works
24:05 : um
24:07 : the
24:08 : one thing that um
24:10 : sometimes it
24:13 : a little weird
24:16 : is um
24:18 : well this case is not showing up as much
24:20 : but but sometimes it's a little weird if
24:23 : it picks
24:24 : y but it doesn't pick x
24:27 : as a distinguishing feature
24:29 : and they're like oh okay i can see the y
24:32 : if i can't see the x
24:34 : um
24:35 : okay
24:36 : and also here
24:39 : the keypress events don't have x and y
24:42 : and they just show up as none
24:45 : um
24:48 : that's a little weird
24:50 : um they don't actually have x and y
24:53 : they actually don't don't have those
24:55 : property at all
24:57 : um
24:58 : i can't i can probably just get them to
25:01 : not show i can probably figure out that
25:03 : case and just not display them
25:06 : but it's there because x and y got
25:10 : higher score score because of other
25:14 : events but in this case
25:16 : it doesn't matter okay
25:20 : oh actually i should have included none
25:24 : or non-existent
25:26 : as one of the values in the set and and
25:29 : then it would have had even
25:31 : bigger score
25:33 : um
25:34 : yeah
25:36 : but yeah sometimes it um
25:40 : sometimes uh
25:43 : well i don't know
25:46 : i don't know
25:47 : like it probably can be improved like
25:50 : those like sometimes it's just weird
25:52 : like if you see
25:55 : she's just a why attribute of an event
25:58 : it like it
26:00 : like um like maybe it deserves
26:03 : i've seen before that it decides not to
26:05 : display the type
26:08 : because
26:09 : the y attribute
26:11 : was more distinguishing than
26:13 : the type
26:15 : for some reason
26:17 : well i mean
26:18 : in this case it's like a combination i
26:21 : mean if you're a human you look at this
26:24 : you know
26:26 : how to describe an event
26:28 : you you have to have a type and x and y
26:31 : because that's what makes sense for an
26:33 : event but when it's an algorithm
26:36 : you don't really know it's like a
26:37 : combination oh you have
26:40 : if all the events have the same x but y
26:42 : is different okay y is more
26:44 : distinguishing
26:45 : but x is all the it all the same so it's
26:48 : not distinguished but it would be nice
26:50 : to have x even though they are all the
26:52 : same
26:54 : yeah
26:54 : yeah that's a
26:56 : human knowledge
26:57 : yeah has to be factored into it
27:01 : uh
27:04 : there's there's in python there's a
27:06 : thing called wrapper
27:08 : uh
27:09 : i think you might have seen it like like
27:11 : in in a class
27:14 : let me see
27:16 : so it could potentially use
27:19 : like wrapper
27:21 : you
27:22 : you return you implement the wrapper
27:25 : method the thunder wrapper method and
27:27 : then you just return some string
27:30 : which you deem is the representation of
27:33 : that object as a string so when you when
27:36 : you do print the object
27:39 : then python knows to call this method to
27:41 : to
27:42 : to get the representation of the string
27:46 : um
27:49 : if we um
27:52 : i don't have
27:54 : the
27:56 : maybe we can use to either use that
27:59 : directly or use a
28:01 : representation or use
28:04 : that idea
28:06 : so allow developers to write a method
28:10 : that tells me what are the attributes
28:13 : that
28:15 : are a good representation of your object
28:18 : and and then i have the debugger display
28:21 : that if the debugger could display the
28:23 : wrapper
28:25 : and just
28:26 : yeah
28:27 : maybe using the wrapper as an idea
28:31 : and then i just print the wrapper here
28:35 : um
28:39 : that's possible
28:40 : that is an idea because that's sort of
28:42 : what wrapper is meant to do it's for
28:44 : when you're debugging and you just want
28:46 : to print out the object
28:49 : that's what wrapper is
28:51 : designed to do
28:53 : do python developers use this
28:57 : functionality a lot for the wrapper yeah
28:59 : yeah they use it enough it's it's a
29:02 : well-known thing
29:03 : probably not everybody does it
29:06 : um
29:07 : but it's
29:09 : but if it's
29:10 : like it's well known enough that
29:13 : you tell a python developer
29:16 : implement wrapper
29:18 : they will be comfortable with it why do
29:20 : they implement it uh if it's not for
29:23 : debugging purpose for what what is the
29:26 : reason that they use this in normal
29:29 : basis
29:30 : it is for debugging purpose oh
29:34 : yeah it's it's
29:36 : mainly for debugging purpose like it's
29:38 : like my
29:39 : person
29:40 : i make a class person
29:45 : named age
29:56 : then you might write a wrapper like
30:02 : ah dang it
30:06 : okay
30:10 : i'll do it here
30:12 : then you write a wrapper like
30:16 : return
30:19 : person
30:24 : [Music]
30:34 : something like this
30:36 : and then that's a string that represents
30:39 : what a person is
30:40 : but um
30:43 : yeah
30:45 : that's a possibility i i will consider
30:48 : that but let me see
30:50 : it might not be super easy to
30:53 : implement this into the debugger because
30:57 : that means i'm going to have to load the
30:59 : code
31:02 : um for which uh currently i'm not doing
31:05 : that i have to load the
31:08 : this person class
31:10 : uh
31:11 : and load the code of this wrapper and
31:15 : call it
31:17 : um
31:18 : from from their source code
31:20 : uh and currently i'm not doing that
31:23 : currently i'm just reading stuff from
31:24 : the database uh even though i have the
31:27 : code here
31:29 : uh
31:30 : i have all the of the code
31:33 : as source code inside the database
31:37 : i'm not uh
31:42 : so so figuring how how to load the code
31:44 : might be a challenge
31:46 : okay so basically you have to
31:49 : execute part of their code
31:54 : but you don't do it right now okay yeah
31:57 : yeah and yes i i have also considered
32:04 : yeah in order for them to customize some
32:07 : aspect of the debugger
32:10 : which is what we're talking about
32:12 : um i'll
32:14 : no matter what i will need to
32:17 : have a way to load their code
32:20 : like like i even thought about
32:22 : um
32:25 : like if they were
32:27 : programming a
32:28 : chess chess game or a tic-tac-toe game
32:32 : um
32:33 : their board might be represented as
32:36 : an array of values or a list of values
32:41 : they might
32:42 : plug in
32:44 : a ui component
32:46 : instead
32:48 : and and then they can display the board
32:53 : as
32:54 : as a game board inside my debugger
32:57 : oh that's cool
32:59 : okay
33:00 : so you have to write a ui just to do
33:03 : that
33:05 : they would they would have to write the
33:07 : ui and plug in the ui module into the
33:11 : debugger
33:12 : uh
33:15 : how to make the repro maybe maybe that's
33:18 : something i should think more about like
33:20 : along this path of
33:23 : yeah well
33:26 : yeah i think that that's a
33:29 : that's a good that's a good path to
33:32 : consider
33:33 : uh
33:34 : yeah let me think about that
33:37 : you think it will be a security concern
33:40 : if you execute their code
33:44 : or not really
33:46 : like you execute code in a way that
33:49 : they didn't execute because now they
33:52 : execute the code okay we have the trace
33:54 : of
33:55 : what the path of the code that they
33:57 : executed but if we
34:00 : get the handle of their code then we can
34:02 : run
34:03 : their code
34:05 : however way that we want to
34:08 : would that be an issue or not really
34:14 : i guess
34:18 : this is a development tool so
34:23 : we are already
34:25 : kind of deep in their stuff
34:29 : this
34:30 : [Music]
34:33 : could this be used
34:38 : as an exploit by an attacker
34:41 : maybe
34:42 : maybe that that's the
34:44 : that's more of the question like like if
34:46 : even if an attacker
34:49 : is trying to attack somebody
34:53 : can they use this
34:56 : as an exploit
34:58 : um
35:02 : they can use it as an exploit by
35:05 : updating the source code of the people
35:09 : that they're trying to attack
35:12 : but if they can already do that
35:15 : there's very little they
35:17 : can't do anyway right
35:19 : that's true so
35:22 : yeah
35:25 : it's not any worse than it already is
35:29 : maybe
35:36 : yeah but yeah well that's a good idea
35:39 : yeah maybe maybe i do need to think more
35:41 : deeply about
35:44 : about just
35:46 : executing
35:48 : the code inside loading the
35:52 : source code inside the debugger
35:54 : that's how that can be
35:56 : done um
35:59 : it might not be that easy actually
36:04 : maybe maybe i
36:07 : maybe i go find sections of
36:10 : code and just load that section but but
36:14 : the code might have dependencies though
36:17 : yeah how would you do that
36:20 : if the code has dependency
36:23 : yeah this might be difficult
36:27 : because a normal debugger
36:29 : a normal debugger has the actual code
36:32 : running live
36:34 : and so the objects
36:36 : are already live
36:38 : you can already call
36:40 : methods on the objects
36:42 : because they're already live objects but
36:45 : my debugger is not that way
36:47 : my debugger is
36:49 : nothing is live it's it's all like uh
36:54 : uh
36:54 : it's it's all a fabrication it it just
36:57 : shows you a
37:00 : the previous thing
37:03 : and that that is actually a
37:05 : very real weakness of this
37:07 : this
37:08 : this scheme
37:09 : because
37:14 : well you can implement it but it's not
37:18 : directly
37:20 : you cannot directly execute
37:24 : an expression like
37:26 : it's like you can't do like even that
37:28 : type
37:29 : plus
37:31 : plus equal something
37:34 : you can't do an expression like that in
37:36 : the debugger
37:38 : because that would be
37:40 : executing code
37:44 : right i don't have a way to execute code
37:46 : right now
37:47 : so does that mean if you do want to
37:50 : execute code you have to execute it
37:54 : again
37:56 : simultaneously
37:58 : yeah
38:00 : not not simultaneously just at the point
38:04 : at the point that you want
38:06 : to like like if if i wanted to give the
38:09 : user a
38:11 : console that they can type in code
38:14 : hit enter
38:16 : um i would need to have the like the
38:20 : python interpreter
38:22 : running inside the debugger
38:25 : uh
38:27 : and i also need to
38:30 : somehow because there aren't real
38:33 : objects
38:36 : that are loaded i'm just showing you a
38:38 : historical representation of the object
38:42 : so in order for me to execute code
38:46 : i have to like
38:48 : fabricate the object i have to create
38:50 : like a clone of the object
38:53 : at
38:54 : the previous point in time
38:59 : yeah well i guess this is different from
39:01 : the
39:02 : wrapper case right
39:05 : because in this case if
39:07 : what you want is a console and they can
39:09 : type in event dot whatever equals
39:13 : equals
39:14 : like whatever and then return a value
39:17 : so that you do have the value of the
39:20 : event
39:21 : so
39:22 : you just need to
39:25 : yeah i i might write an interpreter i
39:28 : might have to write an interpreter
39:31 : that
39:32 : you know parses their statement
39:35 : and then go into
39:37 : my database and
39:39 : actually interprets their statement
39:41 : and and gives them the answer
39:43 : um right but i feel like this is still a
39:46 : different problem of the wrapper because
39:48 : the wrapper will never be in your
39:50 : database if the
39:52 : execution pass never
39:55 : called a rapper right yep if it if yeah
39:58 : i'm gonna need to
40:00 : i'm gonna need to implement the wrapper
40:04 : or execute the wrapper
40:06 : at a later point in time
40:09 : yeah um
40:11 : and
40:12 : i guess one way to do it might be
40:15 : well
40:17 : do you
40:18 : like the obvious way that you would go
40:20 : about it is you would actually load the
40:23 : code
40:24 : uh
40:25 : the way it needs to be loaded into
40:28 : python
40:29 : and and actually have the python object
40:32 : there and then called wrapper on it
40:36 : or can you change the python interpreter
40:40 : to look for a wrapper when it's like
40:43 : instantiate each class
40:46 : and then so that you always have the
40:48 : wrapper of each class
40:51 : there our hand if what you want is just
40:54 : a wrapper
40:55 : if it's
40:57 : you mean
40:58 : but you have to call the wrapper method
41:00 : though in order to get it right you do
41:02 : that in the interpreter or not really
41:07 : that would be very expensive because
41:09 : every time the state changes
41:11 : you potentially it can change the output
41:14 : of wrapper
41:15 : so
41:16 : you have to call rapper again every time
41:18 : any state changes
41:20 : unless you have some smarts that knows
41:22 : what attributes they're repre dependent
41:25 : on
41:26 : but that's
41:28 : hard also
41:30 : um
41:31 : so another way might be i
41:34 : i implement my own
41:36 : little python interpreter
41:39 : that uh
41:40 : that tries to execute the code inside of
41:43 : wrapper
41:45 : uh-huh
41:46 : but maybe it's not a full python
41:48 : interpreter or maybe it is maybe i just
41:50 : use the python interpreter
41:53 : but i just pick out the code inside of
41:56 : wrapper
41:58 : or maybe i just use the yeah maybe i
42:00 : just
42:02 : implement an interpreter
42:03 : implement my own interpreter
42:07 : i use the python parser
42:09 : to parse the code inside of wrapper or
42:13 : just pick that code out of wrapper and
42:15 : then i walk the ast myself
42:19 : too but then the problem is the wrapper
42:21 : might
42:23 : be dependent on another helper function
42:25 : maybe that comes from the outside oh
42:28 : yeah what are you gonna do
42:33 : uh that then that's yeah that's hard
42:35 : again
42:36 : so
42:37 : it's definitely not an easy problem to
42:39 : solve
42:43 : yeah and maybe that's why i have stayed
42:45 : away from it
42:47 : but uh but that doesn't mean i shouldn't
42:49 : try though
42:51 : i'll keep thinking about it