►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
This
will
be
a
multi-part
tutorial,
and
this
is
just
a
first
session
menus
only
I'm
going
to
be
introducing
the
virtual
machine.
We
will
be
using
as
a
tutorial
to
teach
you
how
to
different
components.
Word
man
how
they
fit
together,
then
I'm
going
to
I'm,
also
going
to
do
a
somewhat
brief,
a
thorough
overview
of
virtual
machines
in
general
and
I'm,
going
to
see
how
a
lot
of
the
concepts
on
virtual
machines
are
actually
very
generalizable,
and
you
will.
A
They
will
come
up
in
virtual
machine
for
almost
any
language
towards
the
end
I'm
gonna
talk
ago,
just
a
little
bit
of
setup
you'll
have
to
do
before
the
tutorial,
it's
not
as
bad
as
for
the
other
things
you
had
to
do.
This
is
just
making
sure
you
have
some
great
pieces.
You
need
an
arch
build
to
code
and
right
at
the
end,
I'm
going
to
talk
about
just
some
tips
for
reading
source
code.
B
A
So
if
you've
been
working
already
on
open,
j9
or
omr
for
a
while,
you're,
probably
starting
now,
to
get
a
sense
of
how
the
different
pieces
work
in,
like
very
small
amounts-
and
you
might
understand
one
performance
specifically,
and
you
might
understand
another
component
somewhat
well,
and
you
have
some
idea
of
how
that
you
work
together.
But
maybe
you
don't
yet
understand
how
it
complete
the
N
word
and
how
you
go
from
just
the
source
code
into
something
that
can
actually
execute
code.
A
B
B
A
So
the
this
tutorial,
as
it
says,
is
this
is
the
first
session
of
many.
We
will
be
using
a
very
simple,
almost
toy
language,
VM
ware.
The
idea
is,
we
want
to
make
things
as
simple
as
possible
so
that
you
can
understand
all
of
the
pieces
from
start
to
finish
and
there's
no
kind
of
black
magic.
That's
going
on
that
just
makes
things
work
without
really
understanding
why
it
works
this
way.
So
there
will
be
alternating
session
where
we
were
going
to
start
with
Erie,
which
is
what
this
session
is
about.
A
A
So
the
schedule
very
roughly
is
first
of
all
this
tutorial.
Where
I'm
going
to
introduce
virtual
machine
and
the
TPM
virtual
machine
that
we
will
be
using
then
in
the
second
session,
you
will
actually
get
to
write
code
for
the
virtual
machine
and
add
in
a
few
pieces
so
that
you'll
be
able
to
run
useful
code.
Then
we
will
go
back
to
the
theory
and
start
talking
about
code
generation
and
how
we
can
implement
a
very,
very
simple,
JIT
compiler.
A
Then
we
will
actually
get
to
implement
part
of
the
JIT
compiler
and
we're
going
to
iterate
eventually
on
this
style,
so
that
over
time
we'll
build
up
a
very
sophisticated
virtual
machine.
And
hopefully
you
will
be
able
to
understand
how
every
component
of
it
works
so
starting
right
away
with
the
bulk
of
what
this
presentation
is
going
to
be
about
what
our
virtual
machine,
so
the
most
basic
definition
I
can
come
up
with.
A
So
a
virtual
machine
can
do
things
like
managing
memory
and
is
managing
file,
handles
managing
lots
and
mutexes,
which
are
things
that
otherwise
program
would
have
to
do
by
itself,
whereas
with
the
virtual
machine,
some
of
that
effort
can
be
delegated
and
it
simplifies
writing
applications.
So
that's
why
things
like
garbage
collectors
come
in
that
we
may
get
to
a
some
point
in
the
tutorials.
For
this
reason,
virtual
machines
are
also
often
called
managed.
A
A
So
this
tutorial
we're
going
to
be
focusing
on
staff
based
virtual
machine
that
this
is
just
something
I
want
to
make
you
aware
of.
There
are
different
kinds
of
virtual
machine
that
is,
it
is
the
most
common
kind,
is
a
stack
based
virtual
machine,
and
that
just
means
that,
when
the
virtual
machine
is
executing
code
is
taking
the
are
arguments
from
the
stack
from
a
static
set,
doing
the
computation
and
pushing
the
results
back
on
the
stack.
There's
other
kinds
of
things
that
you
will
see
out
there,
for
example,
luuv
is
a
register
based
machine.
B
A
Instead
of
a
stack
accuses
virtual
registers,
but
we
won't
cover
these
in
the
tutorial.
Hopefully,
once
we're
done
once
we're
through
this
tutorial,
we
can.
You
will
be
able
to
understand
how
these
other
kinds
of
PM's
work,
but
we
really
just
want
to
focus
for
now
on
stack
based
virtual
machines,
because
it
it
most
common
kind
and
open
j9
as
it
turns
out,
is
back
base,
so
typically
virtual
machines.
A
They
don't
execute
the
source
code,
they
execute
what
are
called
bytecode
and
a
bytecode
is
really
just
an
instruction
for
a
virtual
machine,
so
the
same
way
that
physical
computers
have
assembly
instructions.
Virtual
machines
have
bytecode
instructions,
but
because
they're
specific
to
the
virtual
machine,
they
can
actually
be
processor
independent.
So
you
can
have
one
byte
code,
language
that
is
specific
to
your
virtual
machine,
but
that
same
byte
code.
A
You
can
use
on
any
platform,
so
it's
not
type
of
a
specific
DQ
architecture
which
is
useful
because
it
fulfills
this
prominent
that
people
have
been
going
after,
for
a
long
time
of
being
able
to
compile
your
code
one
and
running
it
anywhere
when
it's
applications
written
in
c
and
c++.
Usually,
you
can
compile
your
code
for
one
kind
of
machine,
but
then
you
can't
take
that
compiled
code
and
move
it
to
another
machine.
You
have
to
recompile
it.
A
This
is
not
true
with
bytecode,
so
if
I
could
provide
portability
to
application,
my
codes
are
also
often
designed
to
be
efficiently
decoded
and
interviewed
by
another
program
right.
So,
as
I
said,
virtual
machines
execute
other
programs
and
the
same
way
that
CPU
doesn't
execute
assembly
directly.
It
executes
a
binary
representation
of
assembly,
language
or
machine
language.
Virtual
machines
also
will
typically
execute
a
binary
representation
of
bytecode.
So
these
are
not
necessarily
human
readable.
A
A
So
this
is
an
example
set
of
bytecode
for
a
virtual
machine
called
base.
Naina
is
service
more
complicated
than
the
virtual
machine
we
will
be
using.
So
I
won't
go
through
all
of
the
bytecode
in
detail,
but
this
just
gives
you
a
taste
of
what
byte
codes
and
look
like.
So
in
base
nine,
all
byte
codes
are
32
bits.
The
first
8
bits
are
an
opcode
that
identifies
what
the
instruction
is
similar
to
CPU
opcode
and
then
the
remaining
24
bits
are
just
an
immediate
al-awwal
codes.
A
So,
for
example,
if
you
have
an
instruction
like
push
from
bar
or
pop
into
bars,
which
are
for
moving
values
from
variables
onto
the
stack
and
back
in
this
case,
for
example,
course
from
bar
will
take
the
value
from
some
variable
at
an
index
and
push
it
onto
the
stack.
Now
the
variable
isn't
identified
by
a
name,
it's
just
an
index
into
some
table,
so
you
can
kind
of
pretend,
like
all
your
variables,
just
have
a
unique
number
and
the
number
and
immediate
represents
the
variable
we
want
to
access.
B
A
Okay,
now,
normally,
when
we
write
code,
we
don't
write
assembly
code
directly
right,
that's
very
rare
sometimes,
but
in
general
we
don't
write
a
township
directly.
Similarly,
we
don't
generally
write
bytecode
directly.
Instead,
what
we've
righted
source
code
in
some
sort
of
ways
like
Java,
Python
or
Lua,
and
then
that
gets
translated
to
bytecode
before
we
execute
the
program.
A
A
A
Javascript
is
a
common
example,
the
language
that
says
with
there's
also
some
languages
that
will
let
you
do
both
like
Python
and
Lua,
where
you
can
either
have
their
source
code
fed
directly
to
the
virtual
machine,
or
you
can
specifically
compile
it
to
byte
code
first
and
then
give
the
byte
code
to
the
virtual
machine
and
there's
more
than
comfortable.
So
a
lot
of
modern
languages
are
actually
switching
to
a
model
like
page
where
they
can
support
both
modes
of
translation,
all
right.
So
what
is
an
interpreter
so
far?
A
It's
kind
of
talked
about
virtual
machines
and
it
said
that
they
can
actually
do
a
lot
of
things
right,
because
they're,
not
just
executing
codes,
are
managing
the
execution
of
a
program.
The
part
of
a
virtual
machine
that
is
responsible
for
actually
executing
instructions
or
opcode
or
bytecode
is
the
interpreter.
It's
kind
of
like
the
CPU
of
the
program,
sorry,
the
CPU
of
a
machine.
A
It's
really
the
part
that
is
like
doing
execution.
Everything
else
is
just
helping
the
CPU
provide
resources
like
memory
or
files
or
network
I/o,
like
cetera
a
interpreter,
is
really
actually
quite
simple.
Conceptually,
it's
just
a
loop
around
a
giant
switch
statement
and
the
basic
algorithm
for
an
interpreter
is
just
for
each
byte
code
in
a
sequence,
execute
some
C++
code
that
implements
the
functionality
of
sighs
ice
cream.
Now
here,
I
say
C++
code,
but
it
doesn't
necessarily
have
to
be
plus
plus
whatever
the
language
you're
using
to
write
your
interpreter.
A
For
you
here,
an
interpreter
will
usually
have
some
sort
of
instruction
filter,
which
is
similar
to
an
instruction
pointer
in
a
CPU
or
what's
sometimes
called
the
program
caster
and
all
it
does
is
keep
track
of
which
and
we're
executing
or
which
Piper
were
executing
and
very
commonly.
The
instruction
pointer
will
not
points
again
current
instruction.
A
So
now
we're
going
to
go
through
an
example
that
I
think
many
of
you
will
have
always.
But
if
you
went
through
it
rather
quickly,
this
time
I'm
going
to
go
through
it
a
bit
slower,
so
we're
going
to
start
with
just
a
simple
function
that
just
returned
by
plus
6
as
integer
constants,
and
it
does
constant
arithmetic
very
simple.
A
The
bytecode
I'm
in
showing
you
them
on
the
slide
are
very
straightforward
and
our
instruction
pointer
that
we
initialize
right
away
to
the
very
first
byte
code,
we're
going
to
execute
and
we
have
our
stack
pointer.
That
is
pointing
through
the
first
available
slot
on
the
stack.
Ok,
any
questions,
good,
all
right!
So
when
we
start
execution,
the
very
first
thing
we're
going
to
do
is
actually
bug
the
instruction
pointer,
because
remember
is
always
going
to
the
next
instructions
we're
going
to
execute.
A
Is
we
pop
the
605?
We
had
previously
added
them
together
and
then
push
the
result
11
onto
the
stack
right?
That's
how
we
get
that
value
on
the
stack.
We
then
bug
the
instruction
pointer,
execute
the
return,
and
then
it's
whatever
else
happens
when
the
function
returns
and
that
value
can
go
into
a
variable.
It
can
go
to
memory.
Maybe
the
program
terminates
at
this
point
and
it
gets
printed
to
the
screen
that
doesn't
really
matter
again.
A
Yes,
conceptually
that
gets
done
atomically
in
practice.
You
have
to
it's
up
to
you
to
decide
whether
you
want
to
like
keep
the
two
values
on
the
stack
first
and
then
per
pop
them
off
and
push
the
result
or,
if
you
want
to
push
so
we
pop
the
results.
First
do
the
calculation
and
then
push
the
result.
It's
up
to
you
how
you
implement
that,
but
conceptually
all
of
that
happens
atomically
does
that
make
sense,
but
by
atomically
I
need
it
happens
instantly.
A
It's
very
much
designed
to
be
easy
to
understand,
but
at
the
same
time
it
doesn't
hide
any
details.
So
a
lot
of
times,
if
you
look
at
so-called
real
virtual
machines,
they'd
have
a
lot
of
complexity
in
them.
That
may
be
difficult
to
understand
when
you're,
first
starting
out,
which
means
that
the
kind
of
has
to
ignore
parts
of
it
CVM
tries
to
expose
as
much
of
it
and
to
you
in
a
simple
way
so
with
intentionally
doesn't
use
OMR
so
that
you
really
get
to
learn
how
the
internals
work.
A
A
So
that's
where
the
name
comes
from
sources,
the
source
code
for
T,
V
M,
we
actually,
it
actually
originated
from
base
9.
So
you
remember
back
towards
the
beginning.
I
was
just
a
few
examples
from
base.
9
baseline
is
awkward
educational
VM
that
we
created
for
teaching
how
to
use
om
R.
So
what
we
did
with
this
tutorial
is,
we
took
the
same
basic
idea
is
based.
A
Nine
took
the
code,
but
we
stripped
out
of
all
of
the
complexity
of
it,
except
for
the
very
essential
pieces
you
need
to
execute
code
and
we
also
removed
all
of
people
in
our
parts.
So
all
that's
left
now
is
a
very,
very
minimal
virtual
machine.
That's
if
we
will
be
able
to
understand
easily
enough
now,
as
it
has
the
language
is
very
minimal.
So
the
initial
version
of
the
language
you
will
be
working
with
is
basically
just
a
calculator.
A
A
A
The
base
implementation
is
also
not
complete.
So
if
you
go
to
the
TVM
repo
right
now,
what
you
will
get
and
execute
all
of
the
code
that
supported
by
the
language-
and
that
is
intentional,
because
the
goal
of
the
tutorial
is
for
you
to
complete
the
implementation
of
TVM
so
that
it
will
be
able
to
execute
somewhat
initially.
You
will
start
by
just
completing
the
interpreter,
because
that's
kind
of
the
base
you
need
to
get
started
in
a
later
session.
A
You
will
be
also
completing
the
JIT
compilers
for
it
and
it's
a
very,
very
simple,
JIT
compiler,
but
it
shows
you
can
go
from
start
to
finish.
What's
the
job
with
the
JIT
compilers
really
doing
internally
and
eventually,
you
will
also
add
more
bytecode,
so
that
it's
not
just
a
simple
calculator,
it
will
be
able
to
do
things
like
control
flow
and
Harrison's
as
well.
A
So
if
you
were
to
start
writing
TVM
from
scratch,
you
didn't
start
off
with
the
code.
We
gave
you
if
you
just
started
completely
from
a
fresh
page.
How
would
you
go
about
doing
that?
Well,
the
first
thing
you
would
probably
want
is
an
instruction
file,
just
a
class
that
represents
an
instruction
core
bytecode
that
you're
going
to
execute
inside
it.
You
will
want
to
know
the
opcode
of
that
instruction
right,
which
designates
which
then
you're
actually
executed,
and
then
the
immediate
value
and
those
are
really
the
only
pieces
you
care
about
for
an
instruction.
A
So,
for
example,
in
this
case,
the
very
first
state
that
has
is
for
integer,
add
and
then
what
I'm
doing
here
is
I'm
just
calling
a
function.
I,
don't
want
to
complicate
things
at
this
point,
so
just
call
assumption
that
is
going
to
do
the
addition
and
we'll
worry
about
how
to
do
that
later
and
then
to
push
a
constant
again.
A
I
just
call
a
function
that
is
going
to
worry
about
how
you
actually
do
that
later
on
and
I
get
the
immediate
from
that
instruction
right
away
and
pass
it
as
an
argument
to
the
Jewish
push
constant
function.
If
you
had
more
byte
code,
obviously
you're
going
to
have
one
case
work
each
opcode,
but
this
thing
hopefully
this
gets
the
idea
across
of
how
the
shape
of
the
code
looks
like.
A
Then,
when
you
go
to
actually
implement
those
helpers
again,
it's
actually
relatively
simple.
You're
do
add
it
pops
the
value
from
the
stack
off
the
second
value,
from
the
stack
as
then
and
pushes
the
result,
your
integer
push
direction.
It
takes
that
any
good
value
that
comes
in
as
an
argument
and
just
pushes
it
onto
the
stack
and
that's
really
all
you
need
to
implement
an
interpreter,
and
this
is
not
a
very
easy
to
use
interpreter,
though
it
kind
of
bit
annoying
to
work
with.
A
So
in
these
basic
stains,
GTMO
also
provide
additional
utilities
for
you
to
use.
So,
for
example,
there
will
be
all
the
native
structures
already
implemented
for
you
for
things
like
representing
opcodes,
immediate,
representing
the
stack
etcetera
that
is
done
for
you.
The
definition
of
the
different
byte
code
is
also
provided
for
you
and
an
incomplete
interpreter.
Loop
is
already
there
so
that
you
don't
have
to
worry
too
much
about
where
to
put
that.
A
This
also
avoids
you
having
to
worry
about
compiling
some
high
level
language
to
bytecode,
because
that
introduces
a
host
of
other
problems.
We
don't
really
want
to
think
about
at
this
early
stage
with
that.
I
do
want
to
take
a
moment
to
give
credit
to
the
people
that
made
this
GBM
happen.
I
think
will
be
familiar
with
most
of
the
names
on
this
slide.
A
B
A
A
A
When
I
did
this
I
did
it
in
a
virtual
machine
on
the
Virtual
Box
just
is
that
was
easier
for
a
notice.
There's
really
not
a
lot
to
to
set
outfit.
If
you
have
them
fairly
modern
system,
you
should
be
able
to
get
it
working.
I
think
everyone
with
math
should
be
able
to
get
this
working
fairly
quickly
and,
if
not
ask
questions,
and
so
once
you
have,
your
dependency
set
up,
can
just
clone
the
repository.
A
C
A
A
So
what
people
have
done
is
they've
created,
build
systems
that
take
care
of
configuring
and
configurating
your
bill.
The
ischaemic
is
actually
a
tool
that
will
emit
mate
files
for
you,
so
that
then
have
your
teammates
consideration
and
it
figures
out
how
to
actually
build
what
the
compiler
needs
to
use
is
what
the
compiler
flags
have
to
be,
how
to
enable
optimization.
All
of
that
is
taken
care
of
for
you
by
teammate
and
that's
all.
It
is
really.
A
B
A
B
C
B
A
Okay,
so
I'm
going
to
move
on.
There's
people
want
you
to
go
back
to
this
time.
They
can
ask
me
afterwards,
so
you
do
kind
of
have
a
little
bit
of
homework
for
this
first
session.
It's
got
a
lot.
What
you
should
be
trying
to
do
first
is
just
reading
through
the
code
to
become
familiar
with
it
and
there's
not
a
lot
of
code
again.
A
Tdm
is
designed
to
be
very
small
and
very
simple,
so
hopefully
it
will
be
fairly
easy
for
you
to
just
read
through
parts
of
the
code
and
generally
figure
out
what
the
code
is
doing
and
to
get
you
started
visit.
These
are
the
three
directories
on
the
slides
that
are
important,
convenient
TV
on
itself.
Is
this:
the
TVM
directory
contains
the
core
implementation
of
the
virtual
machine,
that's
where
the
interpreter
and
bytecode
serializer,
and
all
of
that
is
TV
and
run
I.
A
Think
it
just
contains
one
file
main
dog
PPP,
probably
also
see
make
file
to
build
it,
and
all
that
is,
is
it's
just
a
little
bit
of
codes
that
you
can
generate
that
executable
and
from
the
previous
slide
that
run
TVM
batch
run?
That's
all
that's
in
that
directory
and
then
there's
a
test
directory
that
just
contains
some
sample
byte
code
file,
which
is
very,
very,
very
simple
program.
You
can
use
to
test
things
and
make
sure
that
this
virtual
machine
is
working.
A
Okay
now,
for
the
last
part
of
the
presentation,
yes,
this
has
been
a
footlong
better.
Okay.
This
is
a
very
end
of
it.
Just
I'm
going
to
give
you
some
tips
for
reading
code,
since
I
gave
you
the
task
of
reading
the
code
for
TDM
I'm,
going
to
try
to
help
you
out
and
give
you
some
tips
generally
for
reading
first
code.
So
why
I'm
doing
this?
Well,
good
programmers
read
code.
You've
been
working
here
long
enough
now
that
I
think
you
will
have
realized
most
developers
don't
spend
most
of
their
time
writing
code.
A
You
spend
most
of
your
time.
Reading
code
so
being
able
to
read
code
effectively
is
important
and
it
might
be
surprising,
but
it
does
take
practice
to
get
good
at
reading
code.
What
do
we
mean
by
reading
code?
I
mean
not
just
being
able
to
like
read:
was
it
serve?
What
the
language
is
saying,
but
it's
really
understanding
what
the
code
is
trying
to
do
right.
B
A
Okay,
you
don't
need
to
understand
everything
right
away
when
you're
reading
code
again,
if
you're
reading
of
code
base,
that
is
millions
of
lines
of
code,
it
will
take
a
very
long
time
for
you
to
read
everything.
So
you
generally
don't
understand
you
don't
need
to
understand
everything
right
away,
so
Kay
just
start
learning
or
understanding
one
section
at
a
time.
A
So
programming
languages
often
require
a
lot
of
same
text
to
explain
simple
things:
don't
get
lost
in
those
details,
really
try
to
focus
on
what
the
code
is
intending
to
do
what
it
is
decoded
intending
the
program
to
do
you
don't
need
to
understand
like
all
of
the
details
or
what
every
single
function
does
you
just
really
need
to
understand
what
it
does
at
a
high
level?
And
you
can
let
somebody
else
worry
about
the
details
a
lot
of
times.
You
don't
need
to
follow
every
single
function
that
gets
called
right.
A
If
you
try
to
do
that
again
in
a
code
base
that
has
a
million
lines
of
code
that
will
take
forever
to
read
through
every
single
function
and
a
lot
of
times,
not
always,
but
a
lot
of
time
you
can
figure
out
what
a
function
probably
does
without
looking
at
its
code
and
just
look
at
what
its
name
is.
What
are
the
name
of
the
parameters?
What
are
what
is
the
return
type?
What
are
the
types
of
the
arguments,
etc?
A
The
typical
example
for
this
is
STD
storage.
You
don't
need
to
know
how
a
CD
sort
is
implemented.
You
don't
need
to
know
if
they
do
this
quick
sort
or
merge,
sort
or
bubble
sort
or
whatever
other
than
you
must
watch.
You
just
need
to
know
that
it
sort
and
that's
it
so,
when
you're
reading
code
try
to
kind
of
keep
this
in
mind
that
you're
just
trying
to
figure
out
at
a
high
level
what
things
do.
B
A
Number
three
use
a
rubber
jump
so
over
here,
I
have
a
tiny,
rubber
duck.
I
really
like
this
point,
because
it's
small
and
it
can
fit
in
your
pocket.
So
if
you're
ever
in
an
emergency
and
need
to
read
code
really
quickly,
and
you
can
just
pull
the
rubber
duck
out
of
your
pocket
and
it
will
help
you.
This
is
a
very
common
technique
for
debugging
code
that
basically
the
way
it
works.
Is
you
take
your
rubber
duck
and
you
explain
to
it
what
your
cause
code
does.
A
A
You'd
be
surprised,
the
things
that
can
use
for
rubber
duck.
Sometimes
you
can
also
try
using
a
real
person
like
getting
your
body
to
been
treating
them
as
a
rubber
duck.
The
problem
with
using
people
is
people
have
opinions,
and
the
opinions
can
sometimes
getting
the
way
and
a
rubber
duck.
I
can
tell
you
right
now
does
not
have
a
pain,
so
it's
actually
easier.
A
This
is
I
highly
recommend.
This
approach
for
reading
so
fabulous
tip.
Number
four
is
experiment
right.
If
you
have
the
code
and
if
you
can
build
it,
try
building
it
try
running
the
code.
If
you
can
sometimes
you
can't,
because
the
singer
debugging
happens
to
be
that
it's
still
to
compile,
but
still
send
still
try
if
something
isn't
working.
The
way
you
expect
is
to
try
changing
the
code
to
see
what
happens
a
lot
of
times.
A
It's
actually
useful
to
try
to
break
the
code,
to
get
it
to
to
fail
somehow
or
to
crash,
because
that
can
tell
you
that
okay,
at
least
I
understand
that
if
I
do
this
thing
wrong,
it
breaks
the
way
I
expect
it
to,
and
if
you
kind
of
go
through
the
code,
one
step
at
a
time,
you
can
find
that
you
can
actually
learn
quite
a
bit
about
how
the
code
works.
By
going
for
an
exercise
like
this,
you
can
also
try
running
the
code
in
a
debugger.
A
A
Don't
most
people
use
Google
I
think
most
people
would
have
put
Google
but
I
always
get
ticked
off
when
people
put
Google
because
I
don't
use
Google
I
use,
DuckDuckGo
I
have
a
thing
with
Doc's,
apparently
so
I
just
use
a
search
engine,
whichever
one
you
like
and
search
for
things.
If
you
don't
know
what
they
are,
there's
syntax
you're
not
familiar
way.
Try
searching
for
that
online.
A
You
can
look
for
answers
on
Stack
Overflow.
There
are
tons
of
stuff
you
can
find
on
Stack,
Overflow
I'm
sure
most
people
here
are
familiar
with
Stack
Overflow,
even
if
you
can't
find
specifically
answers
about
like
gvm,
because
we
literally
just
created
it.
So
it's
unlikely
someone
who's
already
asking
question
on
stackoverflow.
If
they
are
I'm
impressed
with
ourselves,
you
can
find
information
about
general
virtual
machine.
Like
I
said
at
the
very
beginning,
a
lot
of
virtual
machines
share
the
same
basic
structure.
A
And
finally,
if
all
else
fails
try
asking
for
help,
hopefully
you
know
people
that
are
willing
to
help
you
and
better.
You
haven't
annoying
them
too
much
and
that
they
won't
be
willing
to
provide
help,
try
relaxing
them
on
slack
again
on
stackoverflow.
You
can
try
asking
for
question
if
you're
working
on
a
specific
project,
you
can
open
issues
on
github
to
ask
a
question
and
if
you
happen
to
know
the
person
personally,
you
can
also
try
asking
them
in
person.
A
It
is,
and
you
said,
completely
lost
because
it's
too
much
information
so
when
you're
searching
for
stuff
online
research,
engine
or
Google
whatever,
but
the
tips
the
first
tip
I
gave
about
or
just
have
a
second,
the
second
tip
don't
get
lost
in
the
details.
Don't
try
to
understand
everything
right
away.
That's
it
still
hold
focus
on
the
pieces
that
you
can
understand
and
go
one
piece
at
a
time
and
kind
of
mentally,
simplify
things
you're
going
for
yourself
by
putting
them
in
mental
black
boxes.
A
So
are
there
any
questions
about
reading
code
now
excellent?
So
why
do
I
tell
people
to
read
code
and
boy
I
put
so
much
emphasis
on
is
because
I
did
say
that
I
think
it
an
important
way
of
becoming
a
better
developer.
Well,
in
my
opinion,
the
golden
rule
of
programming
is
write
code.
The
way
you
want
other
people
to
write
code
that
you
will
have
to
read.
A
So
when
you
see
code
that
is
really
hard
to
understand
and
you're
going
what
the
heck
is
going
on.
I
can't
figure
anything
out,
use
that
as
a
lesson
to
you
not
to
write
code
that
way
write
code.
The
way
it
was
when
it
was
easy
to
read
easy
to
understand
and
you
could
figure
out
easily
what
it
was
doing,
that's
the
kind
of
code
you
want
to
be
writing
and
with.
C
A
You
will
also
probably
understand
why
a
framework
like
OMR
exist
to
make
writing
virtual
machine
easier.
It
says
where
are
parts
that
gets
very
repetitive
and
that
are
fairly
complex,
so
that's
really
I
would
say
the
big
difference
between
TVM
and
base
9
of
GBM
is
very
much
intended
to
expose
all
of
the
internal
details
of
how
the
virtual
machine
works.
What
all?
Supposing
that
simple.
C
C
A
Yes,
that's
called
a
front-end,
depending
on
which
textbook
you're,
following
some
sexist,
both
use
different
terminology,
but
anyway,
that's
what's
called
the
front.
10
ppm
again
does
not
have
a
front
end
because
we
don't
want
to
deal
with
the
complexity
of
having
to
that
translation
from
a
high
level
language
to
a
low
level
language.
We
want
you
to
be
able
to
just
write
the
byte
code
directly
that
you
want
to
execute
and
have
exactly
that.
Dd
input
to
your
virtual
machine
without
going
through
intermediate
set
other
questions.