►
Description
Discussion for Chapter 7, “The Hash Table: The Workhorse of Ruby Internals” and Chapter 8, “How Ruby Borrowed a Decades-Old Idea from Lisp.”
A
All
right,
just
talking
about
ruby
under
a
microscope
chapters,
seven
and
eight
chapter-
seven-
is
all
about
the
hash
table.
Chapter
eight
is
all
about.
It's
called
how
ruby
borrowed
a
decades
old
idea
from
lisp,
and
it's
all
about
procs
lambdas
and
blocks
so
all
kinds
of
fun
stuff
there,
and
we
were
just
talking
about
how
these
chapters
are
short
but
quite
dense.
B
Yeah
I
mean,
while
I
was
reading
about,
I
kept
thinking.
How
is
this
going
to
provide
me
any
value
on
day
to
day,
and
I
don't
know
that
it
will
right
now.
I
think
it'll
be
later
on,
where
I'm
debugging
something,
and
I
think
it
back
to
this
book
and
think:
oh
yeah,
that's
how
that
works,
that's
how
hash
tables
work
or
that's
how
blocks
work
and
it
might
give.
A
B
A
A
A
So
if
two
or
more
elements
are
saved
into
the
same
bin
would
be
considered
a
hash
collision.
But
I
was
like
the
whole
point
of
the
bins
is
that
they
contained
multiple
items
like
up
to
five
or
six
items
in
a
bin,
and
it
says
that
means
ruby
is
no
longer
able
to
uniquely
identify
and
retrieve
a
key
based
solely
on
the
hash
function.
A
Now
that
was
interesting
too,
because
I
feel
like
unless
it's
the
exact
same
key,
it
seems
like,
even
if
it's
in
the
same
hash
bucket
of
like
five
or
six
items,
it
should
still
be
quite
unique.
So
my
only
comment
there
was
like:
why
not?
Why
can't
it?
Why
can't
it
find
it
and
consider
it
unique
anymore,
I'm
wondering
if
they
maybe
just
met
the
like
the
bin
number,
but
I
don't
yeah.
I
don't
know,
I
don't
know
how
that
works.
B
A
C
C
B
C
Just
you
know
making
it
a
superclass
like
inserting
it
as
a
super
class
that,
I
think,
will
help
me
understand
better
when
I'm
looking
at
you
know
a
class
full
of
modules
and
the
module
has
a
bunch
of
modules
and
like
following
that
line
and
understanding
like
well,
which
method
is
actually
going
to
read.
I
think
that'll
help
me
think
about
that
better
and
I
think
there's
one
other
aspect.
C
Oh
yeah,
the
message
calling
I
had
never
like
in
ruby,
I
never
thought
of
things
as
messages
like
sending
messages
to
to
an
object,
whereas,
like
this
helped
me
maybe
start
thinking
with
that
mindset
a
little
bit
more
and
it
helped
me
finally,
maybe
ingrain
the
idea
between
in
ruby,
there's
send
and
call,
and
I'm
always
I
used
to
always
be
like
well,
which
one
do
I
have
to
use
in
which
situation
and
now
it
totally
makes
sense.
Oh,
it's
send
when
you're
sending
a
message
to
an
object.
A
Yeah
I
was
wondering
like:
are
there
ever
cases
where
we
would
manually
create
a
hash
table
in
ruby
for
a
similar
type?
You
know,
storage
of
of
you
know
many
hundreds
or
thousands
or
millions
of
objects
like?
Is
that
something
like
we
would
ever
need
to
implement?
Or
would
we
just
say?
Oh
here's,
a
hash
ruby
under
the
hood
is
going
to
make
us
a
hash
table.
Yeah.
C
We
would
just
use
ruby's
hash,
okay,
yeah.
I
can't
imagine
a
reason
we
wouldn't
use
it.
If
we
got
to
the
scale
where
it
was
like
the
ruby
hash
isn't
performing
enough,
then
we're
looking
for
you
know.
That's
when
you
start
saying
well,
you
know:
do
we
need
to
look
at
other
languages
for
this
specific
problem.
A
B
Yeah,
I
was
looking
through
my
notes
again
and
back
to
the
previous
point,
steve
that
you
said
about
prior.
What
does
it
tell
us
about
prime
numbers,
the
note
in
there
that
ruby
does
use
an
algorithm
based
on
prime
numbers
to
determine
the
number
of
buckets
required
in
each
hash
table.
So
it
might
be
the
same
thing
from
converting
to
an
array
to
to
the
hash
table.
A
A
Prime,
so
did
they
pre-figure
that
out,
and
they
just
put
those
in
like?
Is
that
literally
like?
Is
he
just
showing
the
code
that's
literally
there,
or
is
he
kind
of
showing
what
that
code
does
like?
I'm,
I'm
just
really
curious
like
who
took
the
time
to
figure
out
these
nearest
primes
and
put
these
in
here,
and
how
far
does
it
go
since
it
does
that
snip
there
after
5
12
like
how
far
does
it
keep
going.
A
C
B
B
Whereas
now
it's
like
just
throw
some
more
memory
at
it's
cheap,
because
we
have
the
the
primary
key
overflow
issues
in
our
database,
where
the
events
table
in
the
ci
builds
table
were
written
with
the
ruby
default,
the
rails
defaults
of
integer,
and
we
have
used
up
half
of
the
available
ids
to
this
point
in
time.
And
now
we
need
to
go
through
a
painfully
massive.
C
Maybe
yeah
like
the
only
thing
I
can
think
of
that.
Well,
I
don't
the
one
thing
that
I
thought
was
interesting
is
that
it's
double
every
time.
So
if
you've
got
a
256
element
bucket,
when
you
get
to
257
or
whatever
the
prime
is
it
essentially
doubles?
It's
not
just
like
adding.
Oh
here's,
10
more
in
case
you
need
it.
It's
no
here's
another
256
more!
A
C
A
A
Often
yeah
because
it's
pretty
expensive,
I
can
imagine-
which
kind
of
gets
me
back
to
this
idea
of
you
know
if
we
use
like
a
million
item
hash
like
at
what
point
does
that
just
become
like
you
say
I
guess
unperformant
like
how
like
how
high
does
this
go
before
it's
like?
Okay,
the
next
time
you
put
in
an
element,
it's
gonna,
take
five
seconds
to
rehash
everything
and
then
insert
and
then
we'll
begin.
C
A
C
C
A
A
So
don't
let
your
hashes
get
too
big,
which
I
don't
know
if
I've
ever
had
a
problem
with,
but
it's
nice
to
keep
in
mind
and
the
second
one
is
the
idea
of
the
blocks
where
they
kind
of
compared
like
doing
a
while
block
versus
doing
like
the
dot
each
version
and
how
much
you
know
faster.
The
file
version
was
like
70
percent,
faster
or
whatever.
A
A
Yeah,
just
kind
of
thinking
like
you
know
like
they
said,
though,
in
rails,
there's,
probably
so
many
like
dot
each
type
blocks
and
it
won't
matter
by
the
time
it
gets
to
your
little
chunk
of
code,
but
just
in
general,
I
guess
in
ruby,
it's
nice
to
kind
of
think
about
that
idea
like
if
there's
some
bottleneck
somewhere.
That's
using
a
lot
of
you
know
each
type
blocks
or
loops
or
whatever
or
similar
blocks.
If
you
can
convert
them
into
non
closure
style
blocks,
you
could
maybe
save
some
milliseconds.
I
don't.
A
C
And
blocks
kind
of
look
like
that,
but
not
really,
and
so
it's
always
annoyed
me
that,
like
I
can't
just
like
say,
you
know,
def
my
method
and
then
take
my
method
and
just
pass
that
as
an
argument
to
another
method
or
function
somewhere
else
and
like
what
I
kind
of
got
out
of
this
is
like.
Maybe
I
can
kind
of
do
that.
It
just
looks
a
bit
different
and
it's
in
the
form
of
you,
know,
blocks
and
lambdas,
which
is
just
less
common
of
a
pattern
in
ruby.
C
B
A
B
C
A
C
A
A
B
That
seems
odd,
but
I
mean
as
long
as
we
know
about
it
now
we
know,
maybe
that's
something
you
can
apply
later
on,
if
you
have
unexpected
behavior
like
oh
okay,
because
I'm
calling
lambda
in
the
same
scope
more
than
once,
especially
with
the
local
variables
where
they
demonstrated.
You
know
the
increment
of
I
on
the
two
different
lambdas.
I
was
not
expecting
that,
but
of
course,
as
I
was
reading
it
and
they
were
saying
what
do
you
expect
like?
A
Is
I
was
kind
of
like
oh
okay,
I
sort
of
get
it
it's
like
a
built-in
type
or
whatever
it
just
happens,
to
wrap
a
block
which
then
points
to
you
know
that
sort
of
function.
Definition
in
that
environment
that
we
were
talking
about
that
makes
the
closure
and
then
everything
else
it
needs
is
just
copied
down
into
the
heap.
So
it's
there
and
doesn't
get
discarded
with
the
garbage
collector,
but
yeah.
It's
really.
A
C
A
Other
ways,
thank
goodness
there
are
other
ways.
Other
people
got
just
as
fed
up
and
they
did
something
about
it.
They're,
like
I'm,
writing
my
own
yeah,
that's
great,
that's
funny.
I
kind
of
took
like
graphic
design
courses
and
part
of
them
like
one
of
them
was
about.
You
know
just
basic
web
stuff
where
you
like
back
in
the
day
it
was
like.
B
B
I
don't
have
anything
else
in
my
notes
that
was
interesting,
how
they
explained
why
the
dot
each
was
different
than
the
while
loop
and
the
in-depth
explanation
they
had
about
a
scrape
new
stack
form
has
to
set
the
the
ep
for
the
new
block.
He
needs
to
create
the
new
structure.
He
needs
to
pass
the
call
the
vlog
call
into
each
and
whereas
the
while
it
just
needs
to
check
to
reset
the
program
counter.
That's
it.