►
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).
C
I've
actually,
while
we're
waiting
everyone,
so
I've
just
got
yesterday
my
paper
copy
of
the
book.
I've
ordered
it.
I
don't
know
in
the
beginning
of
september
like
even
before,
and
it
just
arrived
like
a
day
before
the
book
club.
C
B
C
I
don't
know
maybe
it's
like,
because
this
is
like
a
quite
detectable
book.
Maybe
we
can
start
if
somebody
have
like
something
not
if
somebody
doesn't
understand
something
from
the
book
we
can
explain
together.
I
don't.
D
Yeah
know
had
a
hard
time
understanding
the
some
of
the
code
snippets
and
see,
especially
yeah,
I
think,
can
can
relate
that
decent
password
past
j
plus
y
pretty
overwhelming,
but
maybe
it's
more
about
the
overall
picture
of
of
how
it
works,
and
I
think
that
was
yeah.
D
I
think
it
got
pretty
clear,
at
least
for
me
in
the
first
chapter,
this
steps
of
yeah
of
going
through
every
character
and
then
like
splitting
up
and
and
tokenize
it
yeah,
but
I
think
yeah
understanding
the
culture
was
pretty.
B
B
Has
someone
worked
with
like
parcels
before
or
like
has
someone
like?
I
skipped
in
university,
the
compiler
lecture
lecture
so
has
someone
done
this
before
writing
their
own
compiler
or
something
like
that.
B
E
When
I
I
was
in
university,
I
had
a
teacher
that
was
like
continuously
telling
us
that
we
should
learn
how
to
write
the
language
and
how
to
how
and
to
understand
these
things.
But
I
haven't
done
it.
I
haven't
write
the
compiler
by
myself.
No,
but
that
teacher
just
it
was
something
that
I
reminded
when
going
through
the
this
first
chapter.
F
Yeah,
I
wrote
a
comment
here
in
the
book
made
a
point
that
they
don't
use
lex
for
tokenization,
and
I
was
just
wondering
okay
is
that
something
that
is
typical
for
a
language
like
ruby
or
not,
and
then
I
started
googling
around
to
see
what
other
languages
do
and
I
couldn't
find
anything
definitive.
So
I'm
curious
if
anyone
is
more
familiar
with
the
stuff
knows.
It's
like
that's
like
something
that,
like
a
lot
of
languages,
do
or
do
most
often
like
the
languages
use
lex.
B
Is
lex
now
something
that
comes
with
bison
or
beeson
bison,
or
it's
something
completely
different.
Actually.
F
Oh
bison,
oh
bison
yeah.
I
I
think
I
actually
don't
even
know
how
it's
pronounced
properly
yeah.
I
don't
know
I
I
don't
know
if
it's
specific
it
just
the
book
called
it
out,
I'm
I
definitely
don't
have
any
experience
with
this
stuff.
So
I
was
hoping
someone
here
might
have
taken
a
university
course
or
something,
but
it
sounds
like
most
of
us
are
kind
of
in
the
same
place.
C
F
Yeah,
I
think
like
once
they
parse
it
to
yaml,
then
what
do
they,
because
they
have
to?
There
must
be
like
a
specific
parser
for
the
rules
and
also
just
like
for
all
the
include
except
stanzas,
like
I
assume
it's
something
custom
that
we
wrote
but
be
curious.
What
that
rules
engine
looks.
F
D
I
just
found
an
interesting
article.
This
morning
somebody
wrote
another
ruby,
parser
in
rust
and
yeah.
I
thought
that
was
interesting.
After
after
reading
the
first
chapter
and
understanding
a
little
bit
more
on
how
how
languages
are
parsed,
and
so
I
can
share
it
in
the
agenda.
D
C
I
also
like
when
I
was
reading.
I
got
the
question
so
like
in
in
this
chapter.
We
are
talking
about
mri,
which
is
an
interpreter
of
language
and
just
like
make
me
a
bit
confused.
What
is
the
difference
between
the
language
itself
like
how
we
can
define
and
interpreter
because,
like
usually
when
we
talk
about
some
problem
like
like
ruby's
slow,
but
it's
not
ruby,
so
it's
like
interpreter
is
slow.
C
B
So,
as
far
as
I
understood
it,
please
correct
me:
we
it's
still
all
written
in
in
c
then
like
it
all,
gets
then
transferred
to
c
right.
C
I
don't
know
like
it's
like
from
what
I
understand
so
when
it's
when
it
transformed
to
this
like
tree,
it's
actually,
the
next
step
is
transform
to
bytecode,
which,
which
is
like,
I
don't
know,
maybe
on
some
platform
like
it's,
not
in
fact,
directly
c,
but
basically,
like
looks
like
the
language.
Is
a
this
big
parse
like
the
file
with
all
the
sparse
rules
and
like
which
defined
like
what
we
can
do
or
not
and
how
we
can,
how
we
implement
it.
B
B
Well,
what
I'm,
what
I
don't
get
so
far
like
when
you
write
this
pass
wi-fi
or
like
this
grammar
rules?
Actually
it's?
How
can
you
make
sure
that
this
this
makes
sense
in
the
end
like
I,
I
was
looking
at
these
this
example
here,
like
this
example
from
this,
this
computer
science
course
where
they
defined
the
lexical
file
and
they
also
had
like
a
the
y
and
then
they
exp
like
do
that.
B
Basically,
like
you,
have
an
expression
and
if
the
expression
is
an
integer,
then
it's
the
value
and
if
it's
expression
is
an
expression
plus
the
expression,
you
do
an
addition
that
makes
sense
here.
But
what
I'm
thinking
like
this
is
like
super
simple
and
now
we
have
like
a
complex
language
like
ruby.
B
But
even
if
there's
is
like
a
test
behind
it,
how
can
you
like,
when
I
want
to
start
writing
like
adding
something
to
ruby
now,
and
I
modify
this
past
wi-fi
there's
like
13
000
lines
of
code?
How
can
I
make
sure
that
what
I'm
doing
here
is
like
that
will
make
sense
with
every
everything
else
like?
Let's,
for
example,
I
want
to
have
yeah
okay
unless
it's
already
implemented,
but
something
that
is
not
implemented
yet,
like
tatiana
said,
like
with
console
and
prints
out
a
control
statement,
a
police.
B
How
do
I
make
sure
that
this
works?
This
is
something
I'm
I'm
curious
about.
B
F
I
thought
it
was
really
good,
but
also
maybe
a
bit
short
like.
I
think
I
could
have
done
two
chapters
if
we
want
to
for
the
next
one,
maybe
do
a
bachelor.
I
didn't.
I
didn't
look
ahead,
so
I
didn't
I
don't
know,
but
maybe
the
next
two
chapters
could
combine.
B
Sure
iterative
approach
to
this.
I
also
made
a
meeting
like
one
hour
but
like
a
50
minutes
meeting,
but
we
don't
need
to
it's
just
like
a
proposal
and
we
can
change
and
adapted
it.
D
I
actually
liked
like
that
is
a
bit
short
because
yeah,
usually
I
I
read
just
I
like-
have
maybe
half
an
hour
to
read
in
the
evenings
or
so
and
so
yeah.
That
was
that
was
nice,
that
that
chapter
wasn't
too
long
but
yeah.
I
guess
it
depends.
Everyone
manages
time
differently
and
yeah.
For
me,
it
was
nice
that
there
was
no
pressure
and
it
was
easy
to
finish
the
chapter.
F
D
Cool,
but
I
I
I
really
liked
it
like
in
the
beginning
of
the
chapter,
I
thought:
okay
where's,
this
going
and
I
thought
gonna
be
a
little
bit
confusing,
but
in
the
end
it
was
yeah
like
it
was
a
round
thing
like
you
could
really
summarize
it
easy
easily,
and
I
think
I
I
really
understood
the
the
concept
and
that
was
really
cool.
D
And
I'm
also
curious
about
the
next
one,
like
after
understanding
how
how
ruby
interprets
or
how
ruby
is
interpreted,
it
would
be
nice
to
see
how
it
is
actually
run.
Like
I
think,
in
the
book
it
was
mentioned
that
it
runs
in
a
virtual
machine.
Somehow
again,
I
was
so
curious
how
that
works.
D
Maybe
this
is
even
the
part:
what's
what
makes
it
slow,
sometimes
or
slower
than
other
languages,
maybe
just
because
of
the
virtual
machine
and
or
maybe
this
combination
of
that
doesn't
need
to
compile,
but
like
it
compiles
on
the
fly
and
then
runs
on
this
virtual
machine.
Maybe
this
is
what
makes
makes
it
slower.
C
But
they
are
like
static.
I'm
not
like
I'm
just
like
get
this
idea,
I'm
not
sure.
If
I
write,
maybe
it's
like
totally
wrong
but
java.
It's
like
statically,
typed
and
probably
like
the
rules
are
simpler,
like
when
you
have
type,
but
because
when
you
have
like
nothing
like
when
it's
dynamic,
you
have
to
like,
like
it's
harder
to
understand
what
exactly
like
when
you
have
like
one
interpreter.
Had
this
code
it's
harder
to
understand,
but
maybe
I'm
wrong
a
bit.
Maybe
it's
not.
Maybe
there
is
different
reason.
D
Yeah,
but
I
think
you're
probably
right,
because
if
I
imagine
that
maybe
there's
there's
a
ruby
season,
number
like
let's
say,
there's
a
one
and
then
ruby
has
to
guess:
okay,
it
looks
like
an
integer
and
then
there
comes
a
point
and
oh
no,
it's
not
intense
integer
anymore.
No,
it's
a
different,
a
different
one
and
in
typed
languages,
then
they
just
if
they
just
know
upfront
which,
which
type
it
is
so
I
guess
that
makes
it
a
bit
faster.
At.
D
C
So
like
I'll,
I
can
share
my
like
experience
about
reading
these
chapters,
so
I'm
actually
like.
I
have
to
confess
that
I'm
reading
it
the
second
time
and
because
I've
once
I
started
to
read
this
book,
but
I
didn't
finish
it,
but
I
have
like
a
lot
of
fate
in
this
book
club
that
I
can
finish
this
book
with
all
of
you
but
yeah
it's
for
me.
C
It
was
really
interesting
because,
once
I
tried
like
I
have
this
idea
that
I
I
want
to
create
my
own
language,
but
after
reading
this
book
I
really
understand
it's
quite
like
boring,
because
you
have
to
like
set
up
all
this
rule
first
and
write
your
like
technizer
and
parser
and
see
like
we
have
the
like
the
stools
like
legs
and
bison.
That
can
help
us,
but
still
it's
like
a
lot
of
like
boring
work.
I'd,
say.
D
Yeah,
I
think
I
had
the
same
feeling
like
when
I
when
I
was
reading
it.
It
was
like
I
really
got
excited
because
I
was
like
I
thought.
Okay
now,
I'm
gonna
understand
how
this
language
work
and
just
gonna
create
my
own
language,
and
then
I
found
that
this
grammar
rules
are
so
well,
I
wouldn't
say,
maybe
not
complicated,
but
it's
just
so
many
of
them,
and
I
thought:
okay,
that's
actually
a
lot
of
work
to
create
a
language.
F
F
B
It's
not
up
to
date,
I'm
not
sure
how
it
how
much
it
impacts
it,
although
I
like,
if
you
think
like
ruby,
is
30
years
old,
something
like
that,
then
these
seven
years
are
probably
not
that
big
of
a
deal
I
at
least
I
guess
so.
B
On
the
website
of
the
auto,
there
is
some
comment
about
that.
I
think
he
says
like
it's
not
that
much
of
a
change
but.
A
B
E
B
F
B
G
G
G
So
in
terms
of
like
book
relevancy,
I
think
for
the
most
part
it's
still
relevant
because
it
is,
you
know,
a
bit
of
an
older
book.
I
think
at
this
point,
but
much
of
what
has
changed
in
ruby
hasn't
really
affected
the
the
way
it
parses
syntax.
For
example,
they
still
use
the
same
approach.
G
And
that's
that
project's
basically
dead
or
it's
it's
a
very
different
project
nowadays
put
it
that
way,
but
so
from
the
dock.
A
couple
of
things.
So
this
giraffe
posed
a
question.
I'm
a
bit
later
here.
So
sorry
for
that,
but
jeff
post,
a
question:
is
it
typical
not
to
use
lex?
It
kind
of
differs
so
some
languages
use
parser
generators,
whether
that's
bison,
antler
or
something
else,
but
also
quite
a
bunch
of
them
use
what
is
known
as
recursive
descent.
G
It
is
very
straightforward
once
you
actually
see
it,
but
you
essentially
rely
on
recursion
to
do
parsing
and
the
benefit
there
is
because
you
write
all
the
code.
You
can
handle
errors
much
more
nicely,
so
you
could
in
three.
Instead
of
having
this
arrow,
you
get
some
sort
of
cryptic
saying
like.
Oh,
I
expected
the
t
underscore
toke
blah
blah.
Whatever
you
can
say
hey,
I
expected
a
curly
brace
here
and
they
they're
also
just
generally
a
little
easier
to
write,
sorry
work
with
for
really
complex
languages.
G
I
think
classic
example
c
plus
plus
as
a
syntax,
it's
ambiguous
and
I
believe,
what's
the
other
one
there's
another
term
for
it,
but
basically
there's
a
lot
of
context
free.
So
it's
not
context-free,
which
means
that
if
you
look
at
a
certain
part
of
the
syntax,
just
looking
at
the
syntax
may
not
be
enough
to
determine
what
it
actually
means.
G
So
you
have
to
do
some
degree
of
looking
back.
Maybe
looking
ahead.
That
sort
of
thing
yeah
parsley
with
bison
is
overwhelming
ruby's
parcel-wise
universally,
at
least
within
the
people
that
have
worked
with
it.
It's
kind
of
known
as
being
a
yeah,
let's
say
scary,
it's
not
something
where
you'd
go
in
and
be
like.
Oh
boy,
I
can't
wait
to
make
changes
here.
G
I
helped
out
with
a
library
called
parser,
very
creatively
by
a
person
called
white
quark,
at
least
that's
their
username,
and
they
quite
extensively
wrote
and
ranted
about
how
parcel-wise,
basically
just
a
mess
to
work
with
in
the
ruby
syntax
in
general,
because
they
ended
up
re-implementing
that
in
a
combination
of
regal,
which
is
a
they
call,
it
a
state
machine
generator.
G
It
generates
a
tokenizer
and
for
the
parser
I
believe,
I'm
not
sure
what
they
used
again
for
the
actual
parser,
but
basically
they
had
to
do
that
sort
of
they
call
it
like
a
clean
slate
implementation
of
the
entire
parser
and
this
person
that
someone
basically
flip
tables
was
like
yeah,
I'm
done
with
it
so
now.
Somebody
else
maintains
it
yeah.
G
So
there's
generally
to
summarize
bison
lex
flax
yak,
whatever
it's
kind
of
like
a
5050s,
but
some
of
those
are
used
by
languages,
some
of
them
not
there's
a
third
particle
pack,
peg,
it's
kind
of
same
concept,
you
write
a
grammar
and
it
will
generate
code
for
you.
Just
the
the
actual
parsing
algorithm
is
different
and
you
can
parse
more
complex
languages
with
it,
but
it
comes
with
its
own.
B
Do
you
write
in
by
the
way
know
how
ruby,
for
example,
validates
its
parser
like?
If
I
go
into
this
file
and
add
something,
how
can
I
make
sure
that
this
is
actually
working
not
just
by
unit
tests
but
yeah?
Is
there
something.
G
Right
so
generally,
with
these
parasite
generators
there
isn't
really
a
sort
of
a,
I
would
say,
a
proof.
You
can
write
or
some
sort
of
static
analysis
to
determine
if
the
input
that
it
parses
will
be
correct,
and
so,
if
you
write
it
in
the
grammar,
obviously
that
has
a
certain
syntax
and
that
needs
to
be
correct,
but
typically
the
the
way
these
parser
generators
work.
You
say,
for
example,
hey
you
know,
a
float
exists
out
of
a
bunch
of
digits,
a
dalton
and
a
bunch
of
more
digits.
G
What
happens?
Is
it
will
sort
of
enter
that
first
state
where
it
expects
a
bunch
of
digits
and
it
will
sort
of
keep
reading
those
and
then
at
some
point
it
will
hit
something
that
isn't
so.
It
says.
Oh,
if
this
is
not
great,
you
know,
let's,
let's
move
on.
If
it's
something
else,
it
will
probably
spit
out
some
sort
of
cryptic
error.
Saying
oh,
I
expected
you
know
a
t
underscore
dot,
but
I
got
a
t
on
the
score.
G
Whatever
some
parser
generators
offer
ways
that
you
can
produce
more
meaningful
errors,
but
they
are
often
fairly
fairly
basic,
fairly
brief
and
that
that's
where
recruiter
comes
in,
because
you
write
all
the
code
instead
of
it
being
generated,
you
have
full
control
over.
You
know
what
to
expect
how
to
handle
that,
and
it
also
lets
you
do
things
like
error
recovery
a
bit
more
easily.
G
G
A
B
That's
cool
so
one
other
question
we
had.
This
is
very
specific.
It
might
be
know
that,
so
how
do
we
pass
ci
rules
like
get
lab,
ci
yamo
and
make
something
that
is
logical
like
an
ast
or
something
like
that?
Do
we
do
that,
or
is
this
just.
G
The
rules,
do
you
mean,
like
the
rules
block,
that
we
recently
added
or
just
a
ci
config
in
general,
you
see
a
config
in
general
right
so
with
the
ci
config.
We
that's
where
I
understand
it.
Just
use
a
standard,
yellow
parser
that
comes
with
ruby,
and
then
I
would
say
that
we
don't
really
do
like
parsing
at
that
level,
as
in
like,
obviously,
we
parse
the
yaml
into
ruby
data
structure.
But
after
that
I
think
it
mostly
comes
down
to
you
know
if
this
section
exists
with
this
value.
G
Do
that
the
rules
section
that
we
recently
added
as
a
replacement
for
only
and
except
that
one
does
have
some
parsing
logic.
I
recall
I
mean
you
added
a
while
ago
and
I
looked-
I
was
sort
of
reviewing
it
at
that
time.
It
was
a
little
bit
of
an
a
bit
of
an
old
setup.
I
don't
remember
exactly
why,
but
it
put
it
it's
very
different
from
how
you
normally
parse.
G
B
Sounds
good
thanks
a
lot
everyone
for
joining
and
thanks
jorick
for
jumping
in
and
answering
all
our
questions
we
had.