00:00:10.080
20 years ago one message is was sent to the Ruby Dev Ming list Luby the Ming
00:00:18.000
list is uh Luby Community uh Luby interpret developer community in
00:00:23.760
Japanese langage the message proposer one b she
00:00:30.920
written by uh him so he he has a time uh because this
00:00:39.960
that was a uh New Year's holidays so in Japan there is no Christmas holidays but
00:00:46.760
there is a there are some uh New Year's holidays and he has a
00:00:51.840
time uh he had he had a he was a PhD
00:00:57.879
student and uh he has experience to to implement the Java B Machine l in
00:01:06.640
C++ and uh in Ruby so the Ruby uh Java B
00:01:14.119
Machine in Ruby was his first Ruby
00:01:20.079
application so he studied she Ruby internals and so reading the book and he
00:01:27.400
thought so he can make more better uh he can make uh better uh Ruby
00:01:35.600
interpreter by uh using the B Machine
00:01:41.799
techniques so after that
00:01:47.399
the Ruby 1 190 was released after the development of the first version very
00:01:55.159
first version of lby uh yope uh at the 2007
00:02:00.399
and the two uh Ruby 191 was released as the uh in 2008 as a
00:02:09.399
production uh release quality release after that
00:02:16.440
the if you you uh uh maybe on your laptop when you Lear the Luby command
00:02:25.239
then the Y will be long so it means that
00:02:30.560
so the his software landun on your
00:02:36.640
computer so his name is of course you know so
00:02:43.319
me so I'm a uh uh liby interpreter Europa employed by stor Inc so Japanese
00:02:51.959
Japan domestic company so the stor uh stores uh Inc uh allow me to
00:03:00.400
work the to make a Luby interpreter uh to improve the
00:03:05.959
performance improve the quality and so on so I I never uh work for on the
00:03:15.840
stores production but uh I join I so
00:03:21.400
stores uh support me to make liby interpreter so after you have developed
00:03:27.920
so uh I created some other low layer softwares like a garbage collector so
00:03:35.799
threating system deers and so
00:03:41.840
on and uh I believe that I'm a shortest
00:03:46.879
description for this uh this site so anyway uh so this
00:03:54.280
is not related but so last uh yesterday so we disc
00:04:00.439
we discussed about the open so sustainable open source software development so fortunately uh
00:04:09.000
St so my company supports me enough so uh I don't need to this kind of
00:04:16.079
sponsorship better uh this uh this sponsorship will become a my cup
00:04:24.880
of coffee anyway so the
00:04:35.639
after so after the uh the the first very
00:04:40.759
first version of the excuse me the first version of the uh the Y
00:04:52.400
then I changed my job here
00:04:57.800
here here here here so the this uh the Stars was
00:05:06.800
the uh fource company fourth position but the
00:05:12.880
my Development Career only on the Ruby B Machine developing the Ruby
00:05:20.880
interpreter and also I was uh I I went
00:05:26.479
to uh several EUR conference here here here and here this is a false
00:05:35.319
eural so I'm I'm very happy to have such a many uh opportunity to show the
00:05:42.960
presentation on the European uh European liby
00:05:48.199
conference and I'm I'm very happy to visit very wonderful places like
00:05:55.440
salable so today I want to introduce there are 20 20 years of the year of
00:06:13.560
y v machine and so I have a good achievements and also I have some legs
00:06:22.120
so this presentation I want to share the idea about
00:06:27.599
that so first of all so maybe most of people most of people
00:06:33.319
in this uh Hall making a luan L application so maybe uh make a luan L
00:06:41.720
application on many a huge number of libr is like
00:06:49.120
that and the uh the r interpret is here
00:06:56.560
so so L interpreter is lower layer of the your uh application
00:07:04.599
stack so this is maybe uh uh original view from the Ruby
00:07:12.199
programmers uh from M shuby developer so we see that all of Luis
00:07:19.280
script is same so Luis script will be interpret as a ruby program and run it
00:07:29.919
so Ruby interpreter uh pass the uh luuis script to the abstract syntax 3 here and
00:07:37.840
translate to the Lu bite code here and uh evaluate by the the evaluator
00:07:48.720
here so this is a very simple uh uh diagram over the Ruby execu R
00:07:57.840
execution
00:08:02.879
so the part so rby interpreter is separated to the two parts so leading
00:08:09.759
parts and the evaluation parts
00:08:16.560
so so in this so we can say that
00:08:22.159
the Ruby interpreter do only two things reading and evaluate
00:08:31.880
l so you understand most of things of
00:08:37.479
Ruby implementation just now anyway so Y is
00:08:44.839
here so making the bite code and uh evaluate the this bite code of course
00:08:52.519
without any other uh systems like the garbage cror or threading system or
00:08:58.760
embedding uh classes or methods like uh string
00:09:04.399
array but so we say y then the the uh this
00:09:13.200
part and this part is y so today I want to show the some uh
00:09:19.720
something about the this area this
00:09:28.040
part um for the detail of the technology talk I want to show some uh topics so
00:09:37.480
why there yet another Ruby B machine so the answer is that there were several
00:09:44.240
rubies B machines in 20 2004 20 years ago and only y complet the
00:09:53.360
implementation to run the all of Rubik program so all of Rubik program means that there's no
00:10:01.079
exception no so yeah do the exception Hing so I so this it means that so all
00:10:09.240
of the specification will be uh will be covered by the Y and also
00:10:16.959
computer science uh people like yet another terminology like Yak
00:10:27.079
system okay so the introducing the basic ideas about the
00:10:39.760
uh be beginner for the in the how to make a interpreter so we introduced a stack
00:10:47.120
Machine model so all oper operations using the using a stock so for example
00:10:56.200
uh all of the calculated result to be to push to the stack and the all needed uh
00:11:05.959
parameter will be uh popped with from the stacks so actual computer uh so
00:11:15.160
CPU using the legist machine so it because it is faster on the physical
00:11:20.600
model better on the software vir machine so the stock machine is used there are
00:11:27.600
many many advantages and disadvantages but uh so mainly the stock machine is
00:11:33.959
easy to implement Java vir machine do v machine small v machine and the Pascal v machine
00:11:41.279
and many other B uh language interpreter uses the stack stack Machine
00:11:50.160
model so before Lou 1.8 we evaluate the the STD abstrct synx
00:11:58.040
3 uh Direct like that so the Ruby program AAL B plus
00:12:04.040
C so very simple Ruby program will be uh pass other with with this
00:12:11.800
St and evaluates the node and evaluate
00:12:17.279
the next note recursively like that and the the method to the result
00:12:26.120
will be assigned to the local variable a and after
00:12:33.600
yellow we comp we translate we compile the this ASD to the uh stock
00:12:41.399
machine like that so running this one and the uh
00:12:48.800
using the stock the calculation will be proceeded like that
00:13:04.639
we can see the actual assem code with uh this assembly feature uh and the this
00:13:13.959
website is the uh show the the luik code to the
00:13:29.600
so actual assem uh compiled code is this
00:13:34.880
one better uh so the compiled code we can evaluate on the v
00:13:46.880
machine anyway so another basic idea of Y is
00:13:55.000
automatic Generations so we Define each vir
00:14:01.880
machine instruction in one file and the this file generates all of
00:14:10.839
the v machine system like the execution code and the v machine metadata like how
00:14:18.480
many instructions are there or something like that and also the disassem or cizer
00:14:24.920
and also documents so we don't need to
00:14:31.480
make uh we don't need to write uh boring
00:14:36.639
code like uh getting the value from the stack and so on and
00:14:44.199
also this abstraction uh helps us to optimize more and
00:14:50.240
more so this is an example of the how to light the
00:14:58.040
instruction in this case so this uh this text defines a get local uh instruction
00:15:06.839
and is there are other three metadata so
00:15:11.959
one thing is opodee operand instruction operand and how many uh bares should be
00:15:19.560
popped from the stack here and the which value should be
00:15:24.720
pushed to the stack after this instruction here and the with this in uh
00:15:32.000
information uh the instruction body is written in C code like that and the uh
00:15:40.279
this instruction definition uh translated to the to the actual execution code for the
00:15:49.759
B machine so this part is fetching the uh
00:15:55.880
values from the instructions and uh stack and this is a copy of the uh
00:16:03.800
instruction body and after that we need to put uh push the value to the stack so
00:16:11.920
this kind of uh uh code we need to maintain but we we
00:16:19.199
can uh this this kind uh this kind of code will
00:16:24.680
be uh automatically generated so we need to we we we don't need to do anything
00:16:30.279
about that
00:16:37.160
so this is repeating the the message about the automatic Generations so easy
00:16:43.680
to modify and introduce the instruction so we don't need to anymore uh uh we
00:16:48.759
only need to write a method instruction definition and we don't need to do light
00:16:56.360
anymore for for example for the dis assembly or something like that and also
00:17:02.759
it will uh it makes more uh
00:17:09.720
optimizations uh for example if we find that the the this instuction with this
00:17:18.240
operant then we can make a special uh uh instuction this one so this kind of
00:17:26.360
specialization uh improve the performance and this uh
00:17:32.200
so without the automatic generation we need to write each each instructions by
00:17:38.480
hand but we can we can uh ask the system to combine this kind of uh instruction
00:17:47.080
and uh operant then we can make a one in uh instruction another instruction
00:17:54.679
easily and also we can un unify the two instru ruction to the one instruction by
00:18:01.440
the uh by automatic system and also we can use another techniques like the
00:18:06.640
stack caching and uh as a uh we can emplo another dispatch method
00:18:13.640
instruction dispatch method I I don't show detail about the
00:18:21.120
uh the techniques but we can Cho so the
00:18:26.320
important thing is we can choose easily for the such a
00:18:32.039
uh which Technique we should use on this
00:18:37.280
this platform or this platform another idea is
00:18:46.640
optimizations so the motivation of the uh viral
00:18:52.240
machine is to improve the performance of Ruby execution so we can deoy many uh known
00:19:02.000
techniques for the vir machine to the Ruby so we need to know the what is a
00:19:09.440
ruby is so Luby has many many features
00:19:14.760
and so characteristics so we can uh we need to know the
00:19:21.960
characteristic and choose which optimization is effective or uh ACC
00:19:28.720
acceptable or uh uh so we can make we
00:19:33.840
can make it or not so the first one is uh the nature of
00:19:42.240
dynamic so Ruby is very Dynamic language so it will be a limitation for the uh
00:19:49.320
interpreter optimizations
00:19:55.400
so for example when you like a class
00:20:01.200
syntax method definition syntax with def all of the uh the exec so definition
00:20:10.440
will be done in Dynamic so it means that you can so
00:20:17.360
usually you we use if syntax condition syntax so which me method definition
00:20:24.679
should be applied on this code so it's means that the the method
00:20:30.679
definition is very Dynamic feature so and also we have a ebal or some other uh
00:20:39.799
meta program features like class new or something like
00:20:45.280
that and we can also load any Rubik code
00:20:50.480
with require outload or some uh or something like that
00:20:57.080
so we can not know which code will be learn before
00:21:03.880
learning so it is very Dynamic uh aspect of lby so for example so please see the 1 +
00:21:14.600
2 so very very very simple rby code so other uh so as language like C so this
00:21:24.440
1+ two code will be converted to the uh
00:21:29.960
three before running the program so it is very easy to know so 1+ two should be
00:21:39.320
three but on Ruby it is not true so we can redefine integer plus
00:21:48.200
with your code so we can't uh expect this is three so Ruby
00:21:58.400
has this kind of limitation for optimiz
00:22:05.360
optimization another aspect of Luby is there are many many method definitions H
00:22:11.960
sorry method invocations so most of operations such
00:22:17.159
as array accessing to the array like that
00:22:22.679
or in accessing to the instance variable like that they are all they are method
00:22:28.679
method invocation so Ruby so Ruby program uh
00:22:34.840
makes many many method invocation so we need to optimize this meth this kind of
00:22:40.880
meth uh dispatch uh to overcome this uh
00:22:48.039
ccum this situation we introduce uh some
00:22:53.120
technique like method caching or specialized instruction
00:23:00.200
so with such a uh non optimization we can uh we can improve the performance of
00:23:09.360
Ruby interpreter at Ruby 1
00:23:18.080
n and the other optimization is the method invocation with a
00:23:24.440
block so for example so This is complicated program make a PL and the
00:23:32.960
local variable I should be uh has uh uh
00:23:40.360
lifetime as so longer than the method definition method call of this call G so
00:23:48.400
it means that we need to store the local variable I for the this
00:23:57.440
block so it means that the block calling the block mean means we need to make a
00:24:04.960
closure so encaps the local variable for the uh block and use it for the uh
00:24:13.679
calling the block however the making the closure so
00:24:19.400
encaps the local variables take a take a time so this is what the Ruby 18 the
00:24:28.720
reason why the ruby8 was SL and so we y delayed that the uh this
00:24:39.919
escaping this encaps on the making the the closure if it is needed so Remains
00:24:47.880
the all of local variable when uh it is not needed so this technique improves the
00:24:56.279
Ruby Ruby execution very fast
00:25:02.000
faster but this technique introdu a huge
00:25:07.799
complexity so to implement this feature I realized many many times in vir
00:25:15.320
machine code and we I need one months two months three months to debel this
00:25:23.520
feature so it was very difficult feature for me
00:25:28.640
we introduce other optimization like that I don't uh explain everything but
00:25:34.159
maybe many many uh optimization will be uh was applied because we can we can
00:25:42.159
make a bu machine so this uh that that was a
00:25:49.840
overview of what is a y and what's the Y did
00:25:55.520
so next I want to show the good goodies and bad points for the uh
00:26:09.520
achievement is Def Define definition of the Ruby v machine
00:26:15.880
itself so defining Luby with stock machine instruction is not uh it's not
00:26:23.480
trival things so because duby has many specifications
00:26:29.480
such as complex method parameters and block parameters and complex control
00:26:35.480
flow like exception handling or the uh the
00:26:43.399
the break next redo anything about the uh control the block operation and also
00:26:51.880
the special cases for E of use so I mean that the uh
00:27:01.159
we say Ruby is a programmer's best friends so because Ruby support many
00:27:07.159
many syntax many many specification to use easily by the Ruby programmer but
00:27:14.080
uh Ruby is not best friend for The Interpreter
00:27:22.559
developers thanks for doing the job anyway so yeah
00:27:31.240
uh sprits all of the specification and reimplements
00:27:37.520
them and then we can apply the manyu optimization with the virtual machine
00:27:43.720
instructions and also we the some tools like G compar or type analyze system or
00:27:52.320
the deer rely on this instructions
00:27:58.240
so anyway I show that I say that uh method definition is complex method
00:28:05.159
parameter is complex so I show the some example why Ruby the M parameter is
00:28:12.919
complex can you explain everything about that Ruby has many many type of the uh
00:28:20.279
meth parameters and many other exceptional
00:28:25.679
cases and also block parameter has more and more meaning so for
00:28:33.200
example this code and this code has different meaning so we we need
00:28:40.640
to understand the what's the specification and uh how to implement
00:28:50.200
them so this is another topic of the Y so we if when we Define the instructions
00:28:57.399
so I CH the human Leal uh uh instruction like that so for
00:29:05.600
example the CPU instructions like the
00:29:11.000
very small name like the Two Two Letters like that but I frustrated to read the
00:29:17.440
magical assembly code so I choose human readable
00:29:23.120
code anyway so we after that we Define the uh
00:29:30.760
the B machine instructions on for y and the B point is not well defined
00:29:39.760
instructions it means that so there is a
00:29:45.720
concrete uh specification for jbm and aset vir machine or or as vir
00:29:52.880
machines and it is compatible so they can rely on the specification of the B
00:29:58.600
machine instructions however
00:30:04.600
uh as I said that Y is designed too easy to change so it conflicts the ideas so
00:30:13.720
so I think that if we have any problem we can change the instructions we can
00:30:19.039
introduce new instructions however the to AU from the
00:30:24.640
to auers the specification of instruction should be conrete so it should be it should be
00:30:31.880
compatible with the any versions so this is a conflict of the
00:30:48.399
so uh from one Ruby 3.1 so why it was
00:30:54.159
introduced and why it rely on the uh the current Implement current uh instruction
00:31:01.960
set so nowaday it is hard to change uh the instructions so it is easy
00:31:10.639
to introduce the new instruction but it is difficult to change the the current
00:31:19.559
instructions so this is another topic about the Y so jit compil is wellknown
00:31:26.080
technique to improve the performance and I didn't uh release any uh just in time
00:31:34.600
compiler so this is uh the one reason is I don't like the writing the assembl
00:31:40.320
code for directly for each uh CPU architecture like uh
00:31:46.799
arm uh Intel CPU and so on and also I
00:31:53.320
had thought that just in time compiler was not viable to pay effort more be
00:32:00.120
because so it takes uh so there are some some
00:32:06.840
reasons for example the garbage collector before the generational garage
00:32:13.000
garbage collector the overhead of garbage collector occupies the the execution cost so if we introduce the
00:32:22.120
just in time comper but the GC is too slow so we the performance gain is not
00:32:29.480
enough and also uh so we need to uh pay many many effort to maintain
00:32:37.039
the just in compiler uh to support multiple CP architectures continuous maintenance and catch up the recent uh
00:32:45.679
Ruby syntax changes and so on so because we have a limited
00:32:51.679
developer resources so I think it is hard I Su but the Shopify people uh
00:32:59.760
organize a team and pay uh uh much effort and they realize the
00:33:09.279
wet so I respect their achievement of the
00:33:16.240
wet and also uh when we uh introduce adjusting time
00:33:22.880
compar why virtual machine is needed more so this this page is quoted from
00:33:31.639
this another presentation and this so that presentation shows that there are
00:33:38.200
many many releases in a day so maybe one hour or half hour uh they release a new
00:33:46.679
version and they need to re reload the application uh as you know the just in
00:33:53.120
time compiler we need to take some warm up time
00:33:58.519
like that so after the minutes so the performance is better but uh the result
00:34:08.520
the warm up time the performance is not better here so if we improve the
00:34:14.679
performance of with the virtual machine without Justus in time compiler then the
00:34:19.839
uh the the performance of application become better and better like here
00:34:31.159
so uh so I think that the improve improve the buer machine performance is
00:34:46.359
too anyway another good achievement is optimization for method disch so I
00:34:52.560
introduced the uh uh method call optimizing the meth is
00:34:59.320
important for the vir machine or for Ruby and we we pay huge effort to
00:35:06.760
optimize the uh method definition so to
00:35:12.200
so in at EUR 2015 I introduced some techniques to
00:35:17.839
improve the performance of method definition and also this uh part of the
00:35:24.119
implementation was reiting many times
00:35:31.520
but there is no no inlining method inlining technique so to eliminates the
00:35:36.800
method dispatch overhead so eliminates all of the method dispatch but embeding
00:35:44.320
the the the Cod code to the Coler code so it is known as the inlining
00:35:52.960
technique but uh the inlining technique is not uh employed by the virtual
00:35:58.960
machine I heard that YG team uh do do to uh does uh some some case of Luby code
00:36:08.760
so in future I think that it is valuable to support the method in lining on the
00:36:15.359
virtual machine ler too uh another optimization technique is
00:36:22.800
specialized instructions so introduce a specialized instruction for some method
00:36:28.200
so lightweight and frequent ability method like uh the integer plus so
00:36:34.640
string empty question string string size
00:36:39.760
methods so they are frequently used and it is enough small INR small methods so
00:36:47.760
the overhead of uh method dispatch is uh
00:36:57.880
uh method dispat consumes the time for these methods so this technique so introdu the
00:37:07.280
in instruction for each method is easy to implement and easy to improve the
00:37:12.640
performance for example so the 2004 so five days
00:37:20.440
later uh after the first report of the year so I can report the three time
00:37:27.760
faster on the fibon example with this
00:37:35.119
technique so this technique like that so checking the receiver and the parameter
00:37:41.839
and the both we check the B is fixed now and the the integer plus is not defining
00:37:49.680
then we can use the special uh additional meth additional function for
00:37:56.920
the fix and also so we check after that we check
00:38:03.000
if it is not a fixed now then we check the uh the floating this is floating
00:38:09.839
number or not and if it is there floating number then also we can use the
00:38:16.359
special code like that and this technique is for the all of the
00:38:23.359
plus method implication then so if the the object is not a string floating
00:38:33.680
integer or some specialized one then call the the normal method
00:38:40.160
dispatch so this is a overview of the example of the how specialized
00:38:45.920
instruction does but the regret of this technique
00:38:53.680
is it has poor extensibility it means that so this technique is for the lightweight
00:39:01.960
and frequenty uh building methods so but it
00:39:07.040
is difficult to determine which is the right weight and which is the frequent
00:39:13.400
so of course it depends on the application so some application call the
00:39:18.920
the string size but some application doesn't so it is difficult to uh
00:39:25.400
determine how and uh so for L user so there are some
00:39:33.520
method is some method which is called frequently and as other sides other
00:39:41.520
application it doesn't call so it is difficult to
00:39:47.640
determine and also it show it slow down the user definition code for example
00:39:53.720
user defined class the plus method so we need to check all of the uh the
00:39:58.960
specialized codes so for example checking the integer checking the floting and then the calling the the the
00:40:06.720
actual method so it has some overhead for that so it means that there uh there
00:40:13.200
is no extensibility so it means that we need to register this kind of specialized
00:40:20.839
instruction by application I think so there is a room to improve the
00:40:26.319
performance with this
00:40:33.119
technique and so another topic so block management so as I say it's optimizing
00:40:41.319
the the method method with a block we introduce a lazy proc creation
00:40:49.240
technique so it was very nice achievement I think but it it's not uh
00:40:56.960
there there is not enough optimization for Block dispatch
00:41:03.560
so as I say that method dispatch I make many effort I make many
00:41:11.440
optimization and it it was very fast faster than all the uh all the
00:41:18.280
rubies however the co calling the block is not
00:41:24.440
optimized because the specification of block parameter is very very
00:41:30.319
complicated and I think it is it seems very difficult so I didn't touch this
00:41:37.760
optimization so maybe uh the it is a uh
00:41:43.920
good room to optimize more and more for Ruby implementation uh Ruby program with P
00:42:00.079
introduced some way to access to the uh
00:42:05.359
instructions for example so as I show the the uh human lead disassemble code I
00:42:12.599
introduce one method and we can uh translate to the instruction SE to the
00:42:19.559
an aray and the Ruby program can use them and also the I user uh two binary
00:42:28.760
methods to represent the packed binary representation and this method is used
00:42:37.119
by the boot snap maybe you use you are using on the your
00:42:43.440
application and also I support the prud RB maybe uh normal Ruby programmer
00:42:51.920
doesn't don't know about that but before play so
00:42:57.960
before pr. RB we need to write all of Ruby method in C
00:43:05.520
code for the buing method however so after that after we
00:43:13.000
introduce the pr. RB we can write any rubby code to the this
00:43:19.160
file and the Ruby interpreter raise the this code
00:43:28.520
before learning your application so it makes more readable and easy to
00:43:34.200
implement more more uh method for the building
00:43:43.119
classes this was this this presentation is quoted from the my 2008 talk at Ruby
00:43:51.800
conference so it means that the shuby is implemented to and a has a good uh
00:44:02.119
performance however little so Linus was l in
00:44:07.839
Ruby so Linus will overcome the
00:44:13.720
shuby because all of the uh most of the code l in Ruby and it is easy to uh
00:44:20.680
optimize more and more with uh by uh compare with the c implementation
00:44:27.160
so I think so this Prospect is correct I think so now
00:44:37.280
some some code is implemented in Ruby and it is faster than Ruby faster than
00:44:43.520
the implementation by
00:44:49.920
C so I achieved some good things better uh uh so there are
00:44:59.400
some rooms to improve more so we need to load at boot time so if we increase the
00:45:08.240
many many uh increase the uh the implementation in Ruby so it takes a
00:45:15.520
time to load it is a problem so we need to eliminate this loading time more and
00:45:21.440
more so we have some uh optimization technique like la
00:45:27.520
thing so for example if we require a file for
00:45:35.119
example uh file util is very uh common library and maybe only one or two method
00:45:42.520
are used on your application because
00:45:48.200
so so file util has thousands of lines but only few lines are needed for for
00:45:55.720
your application then so we only need to uh load the the this few lines only few
00:46:04.599
lines for the application it is it should be enough so this kind of lazy loading technique is implemented but not
00:46:11.880
activated now so I want to uh I want to uh activate enable it for
00:46:21.680
more uh loading Time Performance
00:46:32.000
my leag rates for the Y development in 20 years and I want to have uh sorry I
00:46:38.000
have some uh Future Works I want to do some more and more tasks for example
00:46:45.599
more optimization for the method in learning optimizing the A and the uh
00:46:52.000
lazy loading for the the faster boots boot STP
00:46:58.240
for for example for your L applications and also uh I I want to do
00:47:06.119
some more research project like a flexible git compiler
00:47:12.839
so so I I talked about that Y is
00:47:19.200
designed for easy to modify modification so I want to inherit this idea for the
00:47:25.960
jit compiler so this is only a uh research project and I don't think it is
00:47:32.960
uh it can it can be uh practical more for the U compare with
00:47:41.079
the wet but I think some uh Sor sorry I have some ideas
00:47:47.559
to uh to make a faster L Time Performance and faster warmup
00:47:54.880
time so I want and so I want to
00:48:00.040
try maybe in in few
00:48:06.720
years so and uh maybe it so doing such a
00:48:12.000
thing so it it's uh I can't do it alone so I
00:48:20.200
want to organize some research team so I want to ask someone who can help me so I
00:48:26.920
asked my company to hire more people better they uh so just now so it is
00:48:35.280
difficult so I need to uh I need to find out how to organize the the research
00:48:42.119
team for that anyway this is a last slide so look
00:48:48.800
back 20 years so I have U I got happy chance to uh
00:48:58.799
contribute uh practical Luby development so I can do main interesting
00:49:06.280
top hacking topics like viral machine garbage corlection threating concurrent
00:49:12.160
uh concr uh execution so I know that the lower layer
00:49:20.400
of the Luby interpreter so I can try I could try so
00:49:26.079
that was very great chance for me and also the this
00:49:33.000
contribution give me many great experience like uh many conferences I
00:49:40.079
can me meet many uh Ruby friends and uh I can go many many
00:49:47.040
countries and I got a job so four
00:49:52.440
positions in past and I got married and got children and they are healthy right
00:49:59.839
now so that was very nice so I can only have gratitude to happy 20 years
00:50:25.319
using the Ruby and have on your computer thank you very much
