►
Description
intermezzOS is a teaching operating system, specifically focused on introducing systems programming concepts to experienced developers from other areas of programming.
---
For more go to https://rustfest.eu or follow us on Twitter: https://twitter.com/rustfest
Help us caption & translate this video!
http://amara.org/v/2FiW/
A
B
Computers,
how
do
they
work
there?
We
go
hi.
My
name
is
Ashley.
Oh,
you
may
know
me
as
a
g-dubs
from
Twitter
and
I'm
coming
to
you
from
not
exactly
the
Ross
community,
but
I
work
at
this
little
company
called
NPM,
which
is
kind
of
like
the
cargo
for
nodejs,
which
is
a
runtime
for
this
language
that
everybody
loves
to
hate,
but
I,
really
love
JavaScript
I
do
quite
a
bit
of
it
and
node
I
used
to
originally
be
a
ruby
developer
and
I've,
even
dabbled
in
Erlang,
which
is
a
super
cool
language
as
well.
B
We
I'm
going
to
continue
to
say
we
because
it's
a
collaborative
project
but
is
a
teaching
operating
system,
so
Intermezzo
x'
is
a
teaching
operating
system
specifically
focused
on
introducing
systems
programming
concepts
to
experience
developers
from
other
areas
of
programming.
We
anticipate
that
you
probably
have
programmed
in
something,
but
it
really
doesn't
matter
what
and
in
particular
the
focus
of
Intermezzo
says
people
for
whom
systems
programming
is
generally
not
terribly
friendly.
So
probably
the
best
way
to
say
is:
do
you
know
JavaScript?
Why
don't
we
write
an
operating
system
together?
B
So
the
origin
of
this
project
was
because
somebody
who
will
go
unnamed
but
who
looks
exactly
like
their
Twitter
avatar
uh-huh
asked
me
this
one
night
they
said:
do
you
want
to
stay
in
and
put
on
some
comfy
pants
and
do
a
neat
kernel
tutorial
circle,
yes
or
no
and
I
was
like
oh
heck,
yes,
I
do
that
sounds
awesome
right,
but
then
I
was
like
yeah.
Let's
get
close
to
the
a
lot
like
the
real
programmers
do
right.
A
sidebar
real
programming
is
like
not
a
thing.
B
So
definitely
don't
say
that,
but
I
was
ready
to
get
close
to
the
min
I
was
like
alright.
This
is
interesting
and
then
I
had
this
like
immediately
like
I
thought:
oh
no
wait!
An
operating
system
like
can
I
write
an
operating
system
and
should
I
write
an
operating
system,
a
question.
We
don't
often
ask
ourselves
and
part
of
the
reason
I
had
this
feeling
I
think
is
best
demonstrated
by
this
amazing
website
called
OS
dev
org
in
the
crowd.
Has
anyone
been
to
this
website?
B
Alright,
full
disclosure
I
think
this
website
is
horrible.
This
is
the
worst
website,
one
of
the
worst
pieces
of
Internet
I've
ever
seen,
and
there
are
terrible
things
on
the
Internet
and
the
reason
I'm
so
mad
is.
This
is
the
required
knowledge
page
for
OS
dev?
Let's
take
a
look
at
some
of
the
things
that
they
stay
so
basic
computer
science.
You
need
to
be
intimately
familiar
with
hexadecimal,
who
here
is
intimately
familiar
with
Exodus
there's
going
to
be
some
proud
ones.
B
You
are
lying
I'm
going
to
test
you
later
and
we'll
see
how
much
hexadecimal
you
know
when
we
pair
so
know
what
intimately
now
hexadecimal
this
is
not
seem
terribly
important.
All
right,
five
programming
experience,
learning
about
programming
with
an
OS
project
is
considered
a
bad
idea.
I
feel
like
this
term,
considered
a
bad
idea
or
considered
harmful,
is
done
and
I'm
done
with
it
as
well.
But
last
but
not
least,
if
failure
to
comply
will
make
you
look
silly.
B
Okay,
now
I'm
really
taking
them
seriously.
Definitely
not
so
enter
this
tutorial.
That
happened.
We
happened
upon
on
the
internet
this
one
night
by
Philip
Opperman.
It's
called
writing
an
OS
and
rust,
and
it's
a
series
of
blog
posts
that
takes
you
from
absolutely
nothing
into
an
operating
system
that
you're
able
to
extend,
however
you'd,
like
in
rust,
which
is
super
cool
now.
B
What
was
important
about
this
tutorial
is
that
is
the
exact
opposite
of
OS
dev
org,
all
right
what
it
believes
that
hey
you're,
not
stupid,
because
you
don't
know
this,
we
are
not
going
to
continue
to
refer
you
to
read
books
that
we
don't
actually
list
on
the
website.
No
we're
just
going
to
be
like
hey.
This
is
what
this
thing
is.
Why
don't
you
do
it
alright?
So
the
real
title
of
this
talk
is
ICANN
operating
system,
and
so
can
you
all
right?
B
So
this
is
the
tweet
that
I
got
when
I
got
my
operating
system
working.
This
is
my
hello
world
from
rust
in
my
very,
very
small
operating
system,
and
this
obviously
begs
the
question,
of
course,
and
I
hope
I'm,
not
disappointing
people,
but
like
what
is
an
operating
system.
Are
you
telling
me
this
thing
with
this
tiny
little
blue
thing
here,
hello
world
is
an
operating
system
and
I'm
going
to
say
yes?
Yes,
actually,
this
is
an
operating
system
right
here.
It.
A
B
Extremely
small,
but
it
is
indeed
one
and
so
the
question
here
is
what
is
operating
system
and
it's
actually
kind
of
a
complicated
thing
potentially.
But
the
way
I
like
to
define
it
is
is
an
operating
system
is
a
program
that
provides
a
platform
for
other
programs.
It
provides
two
things
to
these
programs,
abstractions
and
isolation
all
right.
So
what
do
we
mean
by
abstractions?
B
B
Here,
and
so
we
can
see
that
operating
system
a
is
what
we
rate
the
program
for
and
then
operating
system
a
is
what's
able
to
allow
us
to
abstract
over
these
two
different
pieces
of
hardware.
Now
we
can
see
other
types
of
abstractions
like
this
when
we
bring
in
the
idea
of
a
VM.
So
let's
say
I
want
to
write
a
program,
but
I
don't
want
to
write
the
program
for
any
specific
operating
system.
Instead,
I
just
want
to
write
my
program
and
be
able
to
support
multiple
operating
systems.
B
Now
we
kind
of
have
a
pattern
here
and
it's
it's
abstractions
all
the
way
down,
but
we'll
stick
with
just
these
I
guess
and
the
pattern
is
this:
it's
I
have
a
a
is
written
explicitly
for
X,
but
I
want
to
support
x
and
y,
so
I
put
an
abstraction
B
in
the
middle.
Now
you
could
say
that
this
is
what
we're
doing
in
all
types
of
programming,
but
in
particular
this
is
what
we're
doing
in
operating
systems
programming.
B
So,
as
we
saw
before
with
abstractions,
inserting
something
in
between
allowed
us
to
be
able
to
generalize
over
a
lot
of
things.
But,
additionally,
what
it
allowed
us
to
do
was
allowed
us
to
separate
things,
and
so
these
abstractions
in
these
isolations
kind
of
come
hand
in
hand,
and
so
that's
what
we're
doing
when
we're
writing
an
operating
system.
So
then,
the
next
question
I
had
was
well
ok
operating
system,
but
everyone's
like
talking
about
like
a
kernel.
B
What
the
heck
is
a
kernel
and
it
turns
out
that
this
actually
comes
into
the
question
of
ok.
What
kind
of
operating
system
are
we
talking
about?
So
the
definition
I'm
going
to
use
for
now
is
kernel.
It's
just
the
core
component
of
an
OS
and
we
can
bike
shed
that
forever.
If
you
want,
but
again,
it
is
out
of
the
scope
of
this
talk.
But,
as
I
said
there
is
this
question:
ok,
let's
write
an
operating
system.
B
In
fact,
this
question
is
kind
of
irrelevant,
and
this
is
why
all
right,
so
we
we
could
waste
a
lot
of
time
trying
to
design
our
perfect
OS
as
people
who
all
use
operating
systems
I'm
sure
we
have
things
that
would
really
like
it
to
have
so
we
could
sit
down
and
dream
in
the
clouds
about
whatever
type
of
operating
system
we'd
want.
But
if
we
did
this,
the
chances
are,
we
would
never
actually
build
it
and
so
particularly
with,
inter
mazes,
I
think
also
in
coding
in
general.
B
The
goal
here
is
to
learn
not
to
make
the
best
OS
that
ever
existed
so
again,
the
type
of
operating
system
we're
making
right
now
does
not
super
matter
all
right.
So
let's
talk
about
inter
bezos
and
we're
actually
going
to
dig
into
a
little
bit
of
the
code.
So
for
starters,
there's
a
few
prerequisites,
though
not
too
many
for
doing
this,
and
that's
going
to
be
some
virtualization
so
long
as
you're,
basically
not
using
Linux.
B
You
can
also
use
that,
but
what
I
use
for
doing
the
virtualization
is
a
vagrant
which
is
a
development
environment
manager
which
uses
VirtualBox
to
virtualize
machine
and
then
exports
which
allows
me
to
forward
graphics,
which
is
one
of
the
biggest
problems,
particularly
what
I
was
dealing
with
trying
to
do
this
on
the
Chromebook
pixel.
So
this
is
neat,
something
that
I
thought
was
really
amazing.
Is
that
original
Philip
Opperman
tutorial
he
had
written
it
exclusively
for
Linux?
B
A
B
Oh
my
gosh
I'm
in
the
big
leagues.
It's
so
neat,
alright,
but
what
you
finally
have
an
environment,
that's
virtualized
you're
going
to
need
some
of
the
Knicks
dependencies
and
so
I.
Don't
know
these
were
very
new
for
me.
But
NASM
is
what
we
used
as
the
assembler,
which
I
took
the
assembly
and
put
it
into
binary,
then
LD,
which
was
a
linker
which
made
by
hurry
out
of
the
other
files.
Then
we
had
grub,
which
we'll
talk
a
little
bit
more
later,
but
that's
the
bootable,
ISO
and
I.
B
Not
right,
that's
something
all
right,
but
I'm
gonna
call
it
that
now
anyways
that
one's
required
by
grub
and
it
helps
manipulate
the
filesystem
and
then
finally,
we
have
key
mu,
which
I
dunno,
how
to
pronounce,
which
is
pretty
neat
name,
which
is
I,
call
it
a
fake
computer
emulator,
which
is
pretty
much
exactly
what
it
does
alright
and
then.
Finally,
we
had
a
couple
of
utilities.
You
don't
need
these,
but
they
are
super
nice
for
viewing
the
generated
code.
B
As
I
said,
it's
really
difficult
to
peer
into
some
of
these
things,
especially
after
assembled
and
compiled,
and
so
I
was
actually
kind
of
excited
that
I'm,
not
the
first
person
to
men
mentioned
abducted,
a
that
was
cool,
did
not
anticipate
that
will
come
up
in
another
talk,
so
very
cool.
We
have
hex
dump
and
Bob's,
both
both
fun
things
to
say
there,
which
will
allow
you
to
view
some
of
the
code
that
you're
generating
all
right.
So
what
are
the
things
that
I
found
the
most
tricky
when
even
thinking
about
developing
an
operating
system?
B
B
That's
that's
grub
for
me
and
then
finally,
grub
is
going
to
be
what
loads
our
kernel
alright.
So
one
of
the
big
things
that
became
very
important
in
doing
this
was
linking,
and
that
was
that
LD
utility
that
I
had
mentioned
earlier
and
fundamentally
what
the
linker
does.
Is
it's
going
to
figure
out
how
the
sections
in
the
input
file
it
should
be
mapped
in
the
output
file
and
it
should
control
the
memory
layout
of
the
output
file.
B
That
being
said
in
Intermezzo
right
now,
the
only
thing
you
need
to
understand
with
linking
is
that
you
have
two
things
and
you
really
need
to
make
sure
that
one
comes
first,
so
linking
just
make
sure
that
the
header
info
is
up
at
the
top,
well
show
that
code
and
quit
in
a
second,
so
speaking,
of
showing
the
code
now
it's
time
to
do
some
demo,
and
this
is
when
I
really
hope.
You
all
show
me
your
hexadecimal
skills,
so
I'm
ready
and
excited
for
that
all
right.
B
B
So
here
are
the
files
that
we
have
so
just
to
talk
quickly
about
what
we
have
in
here.
One
of
the
the
first
files
to
note
is
this:
multi
header,
Azzam,
multi-headed,
Azam,
is
basically
going
to
say:
hey
I
am
something
that
you
can
load
with
multi
boot,
and
so
this
is
the
thing
that
grub
needs
to
see
to
know
that
it
knows
how
to
load
it.
B
The
second
thing
that's
important:
is
this
boot
dot
Azzam,
because
this
is
going
to
say:
okay
grub,
you
know
that
I'm
a
thing
that
can
be
used
with
multi
boot
you're
going
to
boot
me.
What
do
I
do
once
I
get
booted,
and
then
here
we
have
that
linker
LD
file
and
what
that's
saying
in
there
is
just
make
sure
the
hitter
comes
first,
because
if
grub
doesn't
know
what
I
am
then
we're
already
in
trouble.
So
what
I
want
to
point
out
here
is:
let's
take
a
look
at
the
boot
file.
B
So
here
is
some
very
lovely
assembly
here,
and
so
what
we
can
see
is
we
have
all
of
these
move
words,
statements,
and
so,
let's
break
down
what
these
mean.
So
move
is
going
to
be.
The
instruction
word
is
the
size
and
then
the
next
thing
that
comes
is
the
pointer
to
where
we're
going
to
put
it
in
memory.
B
Then
we
have
this
little
concoction
right
here
and
what
happens
here
is
the
first
two
characters
are
going
to
describe
the
foreground
and
background
color
that
we
would
like
to
display
on
our
screen
and
then
the
next
is
going
to
be
the
character
that
we're
showing
so
just
to
show
you
exactly
what
this
ends
up.
Looking
like
turn
that
off
I'm,
so
sorry,
it
says
off
can't
account
for
it
anyways.
B
So
what
we
can
do
here
is,
you
can
take,
we
can
say,
make
run,
and
this
is
going
to
pop
this
up
and
here
in
the
corner.
We
can
see
that
it
says
hello
world.
This
is
an
operating
system
yay.
This
is
really
cool.
Now,
let's
clap,
though,
when
we
can
get
it
to
say
hello,
rust,
fest,
alright.
So
if
we
take
a
look
here,
the
things
that
we're
going
to
need
to
edit
are
going
to
be
the
characters
that
we
want
here.
So
does
anybody
know
off
the
top
of
their
head?
B
What
capital
R
is
in
ASCII?
Oh,
that's,
boring,
Wow,
tough
crowd,
okay,
well,
I
would
just
like
to
point
out
that
nobody
is
jumping
to
say
what
this
character
is.
So
your
deep
knowledge
of
hexadecimal
is
to
make
me
sad.
It
turns
out
that
I
have
this
pre-baked
and
my
very
super
important
speaker
notes.
So
what
we
can
do
in
here
is
we'll
just
hop
in
it's
52.
B
B
All
right,
so
these
letters
have
changed.
I
have
not
put
all
of
them
in
there
yet,
but
let's
just
take
a
look
and
see
what
this
ends
up
saying,
so
we
can
say
make
run
so
it
says
hello,
rust,
fie
ion,
which
is
almost
close,
but
you
know
it
turns
out
that
writing
all
of
this
assembly,
like
isn't
I,
mean
it's
cool
because
you
can
walk
around
and
be
like
I'm
right
in
assembly
and
if
it's
gonna
be
like
I,
don't
know
what
that
is.
B
So
I
bet
it's
awesome,
but
nobody
really
wants
the
program
like
this
and
here's
the
deal
that
the
level
of
failure
that
I
could
have
here
like
I,
have
this
little
cheat
sheet.
If
I
type
out
some
numbers,
it
would
be
a
mess
and
it
turns
out
that
the
error
messages
I
would
get,
aren't
aramis.
It
would
just
not
work
or
would
print
something
random
and
it
would
be
really
hard
to
debug
so
to
hop
back
in
here
for
a
second
all
right.
B
So
what
just
happened
with
this
was
actually
relatively
complicated
and
we
had
a
pretty
fine-grained
control
over
what
we
were
doing
so
again.
There
we
had
the
bios
low
that
bootloader
grub
alright
from
the
virtual
hard
drive
that
we're
running,
then
the
bootloader
read
the
kernel
executable
and
it
found
that
multi
boot
headers.
B
So
then
I
was
like
alright
I
can
do
this,
and
then
it
copied
the
boot
and
text
sections
which
are
inside
of
that
to
some
specific
memory
addresses,
and
then
it
just
jumps
to
this
entry
point
and
that's
when
our
kernel
prints
the
message
and
then
stops
the
CPU.
Now
this
is
pretty
cool
now,
in
order
to
go
from
this
to
rust,
you
have
to
do
this
kind
of
tricky
thing
which
is
called
jumping
into
long
mode.
So
with
what
we
were
just
writing.
B
We
were
in
32-bit,
but
in
order
to
really
be
using
rust
without
having
to
do
quite
a
bit
of
hoop
jumping
you're
going
to
want
to
be
in
64-bit
mode
now,
unfortunately,
to
talk
to
you
about
how
to
jump
into
long
mode
would
be
way
too
long
to
show
right.
Now,
though,
potentially
rust
fest
next
year,
someone
wants
to
do
how
to
jump
into
long
mode.
That
could
probably
be
a
30
minute
talk,
and
it's
not
even
that
it's
hard,
it's
just
really
tedious.
It's
just.
B
You
have
to
create
this
table
and
just
shifting
a
bunch
of
things
over
it's
like
reorganizing
stuff.
It's
it's
really
I,
don't
think
terribly
interesting,
but
I
do
think
that
what
could
be
interesting,
alright
is
to
take
that
assembly
and
then
refactor
it
using
rust,
so
that
we
can
now
have
a
hello
world
from
our
rust
program,
and
so
we
can
jump
back
in
here
and
I'll
click
this
and
now
we'll
go
into
hello,
rust.
B
So
sorry,
alright,
and
so
similarly,
we
have
like
well
all
clear
this
here
we
have
something
that
looks
relatively
similar
to
what
we
had
before.
We
do
have
a
bunch
of
stuff
that
jumps
us
into
long
mode,
which
luckily
we
have
abstracted
away,
but
what
we
can
see
is
if
we
hop
into
our
libbed
RS.
This
is
actually
now
printing
hello
world
for
us,
and
so,
let's
walk
through
what
this
code
is
actually
doing.
I
should
put
some
numbers
in
there
for
us
uh-huh,
so
I
have
my
K
main
and
then
inside.
B
What
I'm
able
to
do
is
I'm
able
to
grab
the
characters
as
bytes
by
putting
that
B
before
that
static
string,
hello
world.
So
this
is
the
message
that
I
am
going
to
be
printing
right
here
and
then
I
define
the
color
that
I
want
to
use
here
using
one
and
F,
there's
actually
a
whole
bunch
of
different
colors
that
you
can
use
that
I
can
quickly
show.
These
are
the
color
options
that
we
have
actually
a
pretty
good
set.
B
That
array
I
replace
the
color
code
with
the
character
code.
That
I
would
like
and
then
finally
I
create
a
buffer,
pointer
and
then
I
set
that
to
the
message,
and
that
message
is
just
that
array
with
alternating
color
and
character
codes
and
that's
unsafe,
because
we're
just
writing
to
something
in
memory
and
that's
extremely
dangerous.
I,
don't
recommend
doing
it
or
the
computer
doesn't
even
really
know
how
to
break
at
this
point.
But
it's
definitely
not
something
that
it
would.
Let
you
do
if
it
knew
it
would
be,
it
would
seg
fault.
B
It
would
tell
you.
Definitely
don't
do
this,
but
then,
finally,
at
the
end,
we
have
this
loop
here
because
we
don't
want
it
to
just
immediately
shut
off.
We
want
it
to
stay
up,
and
so,
if
we
take
a
look
here,
I'm
so
sorry
we
can
say
make
run
and
we
can
see
that
it
says
hello
world
here
now
we
can
change
this
significantly
easier
in
the
RUS
code
than
we
could
in
the
assembly.
I
don't
need
a
cheat
sheet
to
be
able
to
know
like
what
the
characters
are.
B
Instead,
I
can
just
go
to
my
message
and
change
it
to
say
hello,
rust
fast,
give
me
a
little
padding
there.
Whoever
thought
I
would
be
doing
something
like
I
feel,
like
I'm
doing
a
little
CSS
in
rust,
which
is
pretty
strange,
and
then
you
know
I'm.
Actually,
a
big
fan
of
the
bright
blue,
color
I
think
it
looks
a
little
bit
more
like
the
logo,
so
I
am
going
to
set
that
instead,
we'll
put
this
here
as
9f,
and
so
then
I
can
save.
That
we
can
hop
in
here
say
make
run.
Oh
no.
B
B
It's
like
pairing
with
200
people,
because
that's
always
fun,
so
the
characters
it
so
what's
interesting
is
that
if
you
make
the
array
too
big,
it
just
prints
like
these
little
cute
triangles,
but
it
turns
out
if
you
make
the
array
too
small,
it
prints
a
lot
of
horrible
text
in
your
editor
when
you're
giving
a
talk
in
front
of
a
bunch
of
people,
so
so
since
you're
all
paying
so
much
attention.
What
should
the
length
of
our
array
be.
B
B
B
All
right,
so
what
just
happened
in
this?
A
lot
of
things
just
happened,
including
some
hilarious
code
mistakes,
but
fundamentally
what
I
was
doing
was
I
was
creating
this
big
array
and
I
was
filling
it
up
with
colors
and
then
alternatingly
I
would
put
letters
in
there
and
then
I
just
took
that
as
a
piece
of
data
and
I
pointed
it
assigned
it
to
the
pointer
and
that's
what
made
it
print
to
the
screen
now.
Something
I
would
love
to
do.
B
Is
that
in
that
loop,
where
I'm,
just
keeping
everything
open,
there's
no
reason
you
can't
just
print
tons
of
different
things
to
different
parts
of
the
screen,
so
you
could
have
kind
of
like
an
explosion
of
the
words
rust
fest
like
all
over
the
screen.
I
know
you
potentially
could
crash
your
computer
doing
that,
but
it
might
be
really
fun.
B
Anyways
I
was
told
that
this
was
way
too
complicated
of
a
way
to
be
trying
to
do
this,
that,
if
I
really
wanted
to
demonstrate
it
instead
of
doing
this
whole
loop,
shenanigans
I
should
just
have
just
written
it
out
one-by-one.
The
way
I
did
it
in
the
assembly,
but
you
know
I,
don't
I,
don't
really
care.
B
It
was
like
super
fun
to
write
and
the
joy
that
I
felt
when
I
could
actually
get
this
in
incredibly
at
least
what
I
believed
complicated
set
of
build
tools
to
like
finally
print
some
like
tiny
little
word
to
the
screen.
I
was
like
okay,
this
is
really
fun.
This
is
really
really
fun
and
so
I
kind
of
want
to
leave
you
all
with
this
message,
which
is
that
this
is
from
Leslie
Lamport.
B
A
teacher
teachers
in
the
room,
not
enough,
alright,
let
that
be
the
lesson
if
anything,
all
right,
if
you
ever
want
to
know
how
little
you
know
about
something,
try
and
explain
it
to
somebody
and
you'll,
be
surprised.
Beginners,
ask
extremely
difficult
questions
that
are
very
hard
to
answer
sometimes,
and
so
what
I
want
to
say
is
go
write.
Some
irresponsible
code
write
a
tiny
operating
system
that
does
something
little
and
goofy
and
then
go
teach
somebody
else
to
do
the
same
thing.
You're,
probably
going
to
end
up
learning.
So
much
more.
B
Just
from
that
exploration
and
teaching
experience
alone,
then,
following
any
sort
of
like
terribly
structured
tutorial,
and
even
though
the
you
know,
the
RUS
tutorial
and
book
are
extremely
good.
You
should
stray
from
that
and
do
some
super
goofy
things,
and
one
of
the
things
that
I
want
to
encourage
you
to
do
is
enter
mazes.
Has
gotten
you
out
of
this
kind
of
how
to
get
started
part,
and
so
Intermezzo
s--
is
ready
for
people
to
take
a
look
at
this
and
extend
it
with
rust.
B
It's
already
set
up
for
you
to
have
rust,
to
connect
to
it
it's
only
nine
months
old,
which
is
like
an
awkward
amount
of
time,
but
anyways
it's
interesting.
But
if
we
look
at
the
kernel
we
have
twelve
contributors,
233
commits
and
444
github
stars
for
people
who
care
about
github
stars
and
so
there's
only
12
contributors.
But
there
definitely
should
be
more.
It's
a
very
extensible
thing,
and
so
you
can
build
out
your
own
little
things
on
it
and
they
can
all
work
together.
B
But
I
also
want
to
stress
the
fact
that
you
don't
have
to
contribute
code
to
contribute
to
injure
mezzos.
If
you
take
a
look
at
the
book,
which
is
what
could
is
the
companion
to
the
kernels
codebase,
we
have
47
contributors
there
with
around
the
same
number
of
commits,
not
as
many
github
stars,
but
that's
because
github
fanboys
aren't
really
into
books.
B
Alright,
but
again
like
we
really
want
you
to
contribute
to
Intermezzo
s--
Wow,
and
it
doesn't
matter
who
you
are.
We
think
you're
really
great
and
there's
a
very
good
chance
that
you
have
something
to
contribute
and
if
you
fail
to
comply
with
what
the
general
people
think
a
real
developer
should
be
yeah.
You
will
look
silly,
but
that's
like
a
super
good
thing.
I
think
so
I
can
operating
system.
And
so
can
you
thanks
so
much.