►
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
To
I
don't
know,
I
guess
we
should
start.
I
see
that
nicholas
is
out
of
office
today.
So
probably
he
won't
be
joining
and
I'm
not
sure
where,
like
where
is,
should
we
start.
A
A
I
guess
we
should
start
right,
so
we
are
talking
today
about
second
chapter
called
compilation,
and
maybe
we
can.
You
know
like
just
like
three
of
us
right
now,
so
we
can
maybe
share
our
experience
of
reading
this.
This
paragraph,
I
don't
know
for
me,
it
was
a
bit
more
difficult
than
the
first
one,
because
there
were
more
good
examples
and
they
are
all
in
this
really
assembler.
A
Looking
language,
I
don't
know
like
this
jar
of
tokens,
and
but
it
was
quite
interesting,
and
I
actually
one
interesting
thing
that
I've
googled
after
reading
this
chapter,
that
there
is
this
option-
supports
joke
into.
A
Jarv,
apparently,
and
when
you
actually
saw
it,
allow
you
to
get
this
go
to
blocks
in
ruby,
but
as
well.
It
also
have
like
two
jokes,
so
if
it
adds
the
variable
codes
like
answer
to
everything
and
it's
just
like
the
variable
will
be
42
like
the
meaning
of
it,
and
there
is
another
one
which
actually
produce
like
the
some
some
sandwich
with
le
juice
and
bacon
like
the
jokes
into
their
interpreter.
A
But
I
still
kind
of
didn't
understand.
Is
it
actually
so
with
this
new
compiler
edited
into
ruby,
1.9
like
and
and
up
like,
but
ruby
still
is
an
interpreter
interpreted
language
right
or
am
I
mistaken.
A
I
just
feel
that,
like
this
compilation,
it's
like
the
name
is
a
bit
misleading,
because
even
in
in
the
book
the
author
says
that
even
when,
after
like
translating
everything
into
your
directives,
it's
still
not.
A
A
We
are
discussing
the
second
chapter
of
the
of
the
book
and
we
are
discussing
if
adding
yarf
into
ruby
in
1.9
does
it
makes
ruby
compilot
language
looks
like
not,
but
it's
a
bit.
C
Confusing
it
will
be
both
it's
a
little
confusing
so
typically
when
it
uses
a
bytecode
compiler,
it's
both
because
it
uses
oh
in
case
of
ruby,
it's
a
little
confusing
because
it
doesn't
save
the
byte
code.
But
if
you
take
python,
for
example,
which
does
it
is
it's
interpreted
in
the
sense
that
as
it
runs,
it
will
translate
that
bytecode
to
machine
code
basically,
but
it's
compiled
because
it
has
this
distinct
compilation
and
execution
step
yeah.
It's
it's
a
bit
up
to
personal
interpretation.
I
think.
A
C
C
Yeah,
it's
kind
of
in
a
similar
area.
It's,
I
think,
even
more
confusing
because
it
has
a
just-in-time
compiler.
So
as
it
runs,
it
will
translate
your
java
code
into
machine
code
and
then
just
use
that
sometimes
people
use
like
combinations
of
terms.
So
they
say
like
oh,
it's
a
bytecode
interpreter
or
you
know
a
just-in-time
compiler,
but
it's
actually
an
interpreter
things
like
that.
D
I
had
a
question
here
about
because
I'm
a
little
bit
more
familiar
with
python
at
this
layer
and
wondering
you
know
why
ruby
doesn't
have
rbc
files,
like
python,
has
pyc
files,
which
is
the
compiled
by
cone
by
code
cache
to
disk
yeah.
I
mean,
like
I
think,
from
what
I
understood
it's
like
it.
It
compiles
and
holds
it
in
memory.
D
I
guess
for
most
ruby
applications,
it
doesn't
really
matter,
but
maybe
for
a
script
that
you're
invoking
many
times.
Then
it
has
to
do
this
recompile
every
time,
whereas
python,
maybe
there's
a
small
performance
benefit
by
having
the
you
know,
bytecode
pre-compiled,
on
disk,
and
if
the
script
hasn't
changed,
it
will
just
use
that
bytecode.
D
So
I
thought
that
was
kind
of
interesting
and
I've
wondered
like
whether
this
was
some.
This
is
something
that
will
ever
change
or
whether
there
aren't
like
that
many
performance
benefits
for
doing
it.
C
The
thing,
though
there
is
with
ruby
there
isn't
really
a
clear
distinction
of
startup
time
because,
as
it
runs,
it
may
load
additional
files
and
such
and
it
as
such
is
really
hard
to
define.
When
is
the
application
started
versus
sort
of?
I
guess
you
could
measure
like
sort
of
time
to
first
buy
it
on
a
web
page
like
time
to
first
ruby
line.
Essentially,
I
think
it
would
help
it
kind
of
depends
on
how
fast
the
compiler
is
already.
C
So,
as
far
as
I
know,
for
example,
the
ruby
bytecode
compiler
doesn't
really
do
many
optimizations.
It
has
a.
It
has
a
few
basic
ones,
but
it
certainly
doesn't
have
any
optimizations
that
take
a
certain
amount
of
time
to
process,
and
so
it's
entirely
possible
that,
because
of
that
using
a
byte
foot,
cache
wouldn't
give
that
big
of
a
speed
up.
C
Certainly,
I
wouldn't
expect
like
a
rails
app
to
suddenly
be.
You
know,
x
percent
faster
or
something
like
that.
C
There
is
the
added
benefit.
If
you
compile
the
bytecode,
you
can
theoretically
get
rid
of
the
source
code
and
just
ship
the
bytecode,
which
may
or
may
not
take
less
space,
but
I
think
again,
for
most
people
using
ruby
disk
space
is
not
really
a
concern.
C
These
bytecode
files
certainly
don't
get
gigabytes
in
size.
It's
you
know
five
megabytes,
maybe
for
like
a
rails,
app,
for
example,
real
estate
might
be
a
bit
more,
but
not
a
whole
lot.
D
D
I
was
at
a
talk
where,
at
a
python
conference
for
a
developer
of
someone
who
wrote
a
a
disassembler
for
python
by
code,
basically
converting
python
byte
code
into
something
you
can
read.
He
said
the
number
one
application
for
this
was
someone
who
accidentally
deleted
their
python
script
and
all
they
had
was
this
pyc
file
and
it's
been
through
like
generations
of
employees
and
they
have
like.
D
You
know
it's
like
some
critical
component
and
they
said
like
what
they
use
is
the
you
know
the
disassembler
to
make
changes
to
it
because,
like
you
know-
and
I
think
that's
a
common
thing
actually
in
python,
where
you
accidentally
delete
your
python
script
and
you're
left
with
a
bytecode
file,
and
you
know
that's
all
you
have
so
it's
funny.
C
Yeah,
I
think,
for
ruby.
At
the
end
of
the
day,
this
probably
makes
that
compiler
probably
is
fast
enough,
probably
because
it
does
very
little
and
I
think
the
sort
of
heritage
from
ruby18
when
it
was
an
80
well
asd
interpreter
different
set
is
basically
it
will
parse
the
code
into
a
syntax
tree
and
just
interpret
that
directly
without
any
bytecode
in
the
middle,
and
that's
probably
why
they.
They
don't
have
it.
C
C
I
think
just
out
there
does,
I
think
jruby
is
in
a
similar
sense,
where
they
they
don't
store
their
own
bytecode
and
that's
mostly
because
they
compile
directly
to
java.
I
do
think
jruby
has
the
ability
to
spit
out
some
form
of
java
output.
Sure
if
it's
like
a
java
class
file
or
like
a
jar
that
you
can
then
run
and
rubinius
has
and
still
does
similar
to
python,
where
it
produces
bytecode,
and
I
think
basically,
any
any
new
interpreted
language
with
pico
will
do
it
separately,
similar
like
erlang
and
elixir.
A
A
But
like
if
we're
like
talk
about
mri
so
like
this
bytecode,
which
is
compiled,
it's
like
as
far
as
understanding
stores
somewhere
like
in
the
cache
and
when,
like
the
program,
is
like
killed
it
just
deleted,
because
when
you
like
change
the
program
you'll
have
to
like.
Do
all
this
technologies
parsing
and
compiling
again.
So
we'll
need
like
new
files
for
white
code
right.
C
Yes,
so
the
the
best
way
to
certification
that
is,
I
would
imagine
like
how
most
do
it
is.
You
basically
have
like
a
giant
hash
map
which
says
you
know
for
this
file.
This
is
all
the
you
know,
the
methods,
the
classes
whatever
defined
inside
of
it
and
then
for
every
one
of
those
it
contains
the
main
phobia,
the
location,
the
number
of
arguments
etc
and
the
instructions
to
run
or
with
the
byte
code.
C
And
then,
when
it
wants
to
run
a
method,
it
will
look
it
up
through
this
database,
basically
get
the
chunk
of
bytecode
to
run
and
then
we'll
typically
sort
of
push
that,
on
its
own
stack.
It's
basically
just
an
array
that
will
start
running
over
those
instructions,
sort
of
innovation
that
typically,
what
a
interpreter
does
it's,
basically
a
huge
loop
with
a
big
switch
in
the
middle
and
that
switch
handles
every
instruction
and
then
to
run
the
code.
C
So
it's
it's
not
so
much
a
cache
in
the
sense
of
I
don't
know.
What's
like
red
is
basically
I
mean
they
don't
use
winners,
but
things
where
things
have
like
an
expiration
time.
Things
like
that,
it's
more
like,
essentially
a
hashmap
saying
this
method
has
this
list
of
instructions
to
run
and
then,
when
it
exits
it
just
deallocates
all
the
memory.
A
But
is
it
store
somewhere
on
this
call
just
like
like?
I
assume
it
should
be
huge
like,
for
example,
if
you
start
a
gitlab
application,
so
it's
like
this
bytecode
like
all
these
files,
it
should
be
like
a
lot
of
them
like
it
should
be
like
usually
the
base,
so
it
should
be
stored
somewhere
on
the
disk
right.
It's
not
in
memory.
C
No,
it
it
stays
in
memory
and
the
size
is
typically
not
that
big.
It
is
all,
of
course,
very
bit
pro
language
but
like
if
you
take,
for
example,
gitlab's
source
code.
It
is
I'm
probably
never
gonna
get
like
other
stuff.
But
if
you
just
just
the
app
directories,
you
know
90
megabytes,
but
that's
also
javascript,
let's
say
lib
50
megabytes.
So
let's
say
the
whole
source
code
of
gitlab.
Just
ruby
code
is
100
megabytes.
C
The
bytecode
is
not
necessarily
a
one-on-one
representation,
so,
for
example,
in
a
ruby
source
file.
If
you
refer
to
the
number
10,
you
know
100
times,
let's
say
100
lines,
that's
100
lines,
and
so
your
10
needs
two
bytes.
At
the
very
least,
you
know
if
you
100
lines
to
process
100,
new
lines
etc,
but
within
the
actual
byte
code
it
might
see
hey.
You
know
we
refer
to
the
same
thing
100
times,
let's
put
that
number
10
somewhere
once
and
then
just
refer
to
that.
C
C
But
things
like
comments
are
not
there
they're
thrown
away,
you
don't
have
white
space
things
like
that,
so
the
the
bytecode
usually
will
be
smaller,
depending
a
bit
on
how
much
debugging
information
you
include,
for
example,
so
a
method
might
need
to
store
the
path
to
the
file
in
which
it
was
defined,
and
if
a
compiler
is
smart,
it
will
say:
hey.
C
We
refer
multiple
times
to
the
same
file,
so
we
only
store
this
once,
but
they
may
also
not
be,
and
then
you
end
up
with
potentially
this
big
file
path
being
repeated
a
whole
bunch
of
times,
but
so
to
give
you
a
quick
illustration,
if
so,
for
example,.
C
C
Let
me
see
how
do
I
do
that
again,
it's
a
bit
more
difficult.
Maybe
I
still
have
it
cache,
because
that
might
be
a
bit
faster.
Sorry
about
a
second.
C
Code
release:
oh
that's,
the
old
stuff,
either
way.
Source
code
is
like
two
megabytes,
but
I
believe
the
the
bytecode
is
usually
like
half
a
megabyte
or
something
like
that.
So
it's
a
fairly
substantial
reduction
and
that's
because
things
that
are
duplicate
it
will
try
to
reuse
as
much
as
possible,
so
file
paths
and
integers.
C
A
C
Not
eddie
wants
to
do
directly.
I
think
there
have
been
some
attempts
in
the
past,
but
ruby
as
the
language
is
just
too
dynamic.
Like
often
when
you
look
at
the
source
code,
this
I
mean
you
can
compile
it
to
machine
code,
but
it's
probably
not
going
to
be
any
particularly
more
efficient
than
just
using
an
interpreter.
C
That's
what
jruby
does
and
what
rubinius
did
before
they
removed
the
jit.
Is
they
use
a
jit
compiler
and
the
way
they
work?
They
typically
sort
of
watch
your
you
know,
a
method,
for
example
as
it
runs,
and
it
will
record
perhaps
what
types
of
arguments
are
given
to
it,
and
anybody
at
some
point
say:
hey.
C
You
know
the
last
10
000
times
this
method
got
called
all
the
arguments
were
integers,
the
output
was
an
integer,
so
let's
compile
it
under
the
assumption
that
that's
what
it
takes
as
input
and
output,
and
then
it
can
sort
of
try
to
optimize
that
and
then
it
usually
has
some
sort
of
clause
at
the
beginning
of
it
says
hey.
If
the
input
is
not
an
integer,
your
bailout
go
back
to
the
interpreted
code
and
throw
away
the
compiled
code
because
we
made
the
wrong
assumption.
Basically,.
C
But
that's
specifically
meant
for
writing
python
extensions.
It's
as
far
as
I
know,
not
really
something
you
could
use
without
a
python
runtime,
for
example,
I
think
the
closest
today
to
compiling
ruby
to
machine
code
will
be
crystal,
but
really
the
only
similarity
crystal
has
with
ruby
is
that
they
share
similar
syntax
but
sort
of
semantics-wise
they're
completely
different.
A
I
guess
like
in
the
future,
when
ruby
will
get
even
more
new
features,
it
will
be
even
more
difficult
to
create
something
like
implementation
that
will
be
compiled
into
machine
code
because,
like
what
we
saw
in
this
chapter
chapter
that
this
keyboard
arguments
when,
when
it's
compiled
into
your
instructions,
it
took
like
even
more
lines
to
address
it.
It's
even
have
like
this,
if
condition
and
so
on
so
probably
like
when
we'll
add,
even
more
dynamic
features,
it
will
be
even
difficult
to
do
it
in
the
future
so
yeah.
C
Oh
yeah,
absolutely
like
the
ruby
27
does
have
a
jit,
but
it's
by
from
what
I
remember
very
experimental
and
in
the
case
or
in
a
state
where
it
gives
some
benefits
to
some
numerical
benchmarks,
but
I
believe
rails
was
even
slower
with
it.
C
I
think,
for
the
long
term,
yeah
ruby
definitely
needs
it.
I
think
language
is
like
sorry,
implementations
like
j
ruby
have
shown
that
you
basically
need
that
to
make
things
go
faster
and
it's
a
bit
of
a
recurring
thing
with
any
interpreted
language.
This
is
only
so
fast.
C
An
interpreter
can
go,
and
it's
usually
not
fast
enough,
at
least
for
the
case
that
people
want
to
use
it,
for
I
think
lua
is
probably
the
odd
exception
with
the
base
interpreter
is
actually
pretty
fast,
but
then
lua
jit,
for
example,
they
have
a
jit
compiler
and
they
managed,
or
they
managed
to
be
able
to
produce
luba
code
that
can
outperform
the
equivalent
c
code
and
that's
because
when
they
jit
compile,
they
can
compile
it
specifically
for
your
machine,
so
you
can
use
whatever
functionality
that
might
have
available.
C
Basically,
all
the
the
work
they
normally
that
you
normally
have
to
do
to
figure
or
to
support
code
running
on
different
architectures.
You
can
just
throw
all
of
that
away
because
you
know,
oh,
we
are
running
on
this,
so
yeah.
We
only
have
to
be
concerned
with
that,
but
the
the
lure
jet
compiler
is
basically
written
by
a
compiler
jesus,
so
to
speak.
C
You
know
the
identity
of
the
person
is
unknown.
The
person
goes
by
the
name
mike
mike
paul,
but
it's
a
it's
a
fake
name
and
people
don't
really
know
who
he
is,
but
it's
a
really
impressive
piece
of
software
like
it's,
it's
insane
how
fast
luagit
can
be.
C
So
I
think
egypt
would
be
a
little
less
painful,
but
ruby
also
has
the
problem
that
as
a
language,
it's
much
more
dynamic
compared
to
lua
and
not
just
that
people
actually
use
it.
So
you
pull
in
a
jab
and
chances
are
able
to
find
a
bunch
of
methods
dynamically
and
that
sort
of
stuff
is
surprisingly
difficult
to
optimize.
C
For
jruby
people
wrote
about
this
quite
a
bit
over
the
last
decade
or
so,
and
they
go
through
extensive
trouble
to
make
sure
that
if
you
redefine
say
the
plus
method
on
an
integer
j
ruby
supports
that,
even
if
it
means
that
performance
will
suffer
as
a
result.
C
But
there's
some
stuff
where
they
say.
Look
we're
just
not
going
to
support
this.
In
particular,
there's
the
object
space
module
in
ruby
that
you
can
use
to
traverse
all
live
objects
and
do
a
bunch
of
other
stuff,
and
I
think
jruby
does
support
that.
But
you
have
to
start
it
with
a
certain
flag
and
even
then
it
will
only
support,
I
believe,
a
subset,
and
that
flag
has
a
pretty
big
performance
impact.
C
Yeah.
Ruby
absolutely
will
need
a
jit
for
the
the
next
decade.
C
To
a
certain
extent,
yes,
so
it
helps
in
the
sense
that
you
know,
let's
for
a
moment
assume
ruby
was
a
statically
typed
language
at
runtime.
You
don't
have
to
figure
out
what
the
input
and
output
is,
because
you
know
that,
assuming
that
this
information
is
exposed
to
the
runtime
because
a
lot
of
languages
they
don't
they
throw
their
types
away
after
compilation.
C
A
you
know,
let's
say
you
have
a
loop
over
an
array
of
integers
and
the
inside.
You
do
another
loop
over
an
array
of
integers.
You
could
turn
that
into
a
what's
called
a
vectorized
loop,
where
certain
operations
can
be
done
in
parallel
at
the
cpu
and
for
ruby.
C
That's
probably
not
what
people
use
ruby
for
might
not
be
the
best
example,
but
that's
the
case
where,
because
you
have
type
information,
you
could
perhaps
even
optimize
that
before
your
program
runs
so
as
you
compile
the
bytecode,
you
might
say:
oh
hey,
you
know
we
recognize
this
pattern.
We
know
these
are
the
types.
So,
let's
generate
some
sort
of
bytecode,
that's
a
bit
more
optimized
and
so
yeah.
It
can
definitely
help
the
tricky
bit
there.
C
Is
that
because
ruby's
dynamically
typed,
any
type
signatures
you
add
on
top
are
either
going
to
be
inaccurate
because
people
might
forget
to
update
them
or
they're
not
going
to
be
used
everywhere.
So
you
still
need
a
runtime.
They
can
dynamically
figure
out
what
it's
dealing
with,
and
I
I
do
think
you
know
if,
if
these
type
signatures,
if
they
catch
on,
then,
if
they
stick
around,
then
we
might
see
ruby
implementations
perhaps
use
that
as
sort
of
a
hint
for
the
optimization
process,
but
I
am
personally
a
little
skeptical
about
signatures
sticking
around.
C
I
I'm
fairly
certain
they
will
fade
away
and
that's
because
they've
been
tried
in
the
past
by
different
static
analysis
projects,
mostly
research
projects
and
sort
of
the
recurrent
consensus,
was
that
unless
it's
part
of
the
language,
the
language
sort
of
enforces
it
people
just
forget
about
it.