►
From YouTube: Rust & Tell - 2021 Kickoff
Description
Details: https://berline.rs/2021/03/23/rust-and-tell.html
00:00 Introduction
04:40 Ashley Williams: Rust Foundation
30:32 Paul Butler: Building a multiplayer WebAssembly game with Aper
55:16 Mario García: Introduction to CI/CD for Rust with GitLab
A
A
So
we
volunteered
lately
to
keep
running
the
meet
up
scott
and
me,
but
we
have
a
huge
support
from
brian
jan
eric
and
ryan
levick,
who
kind
of
are
currently
busy
on
other
other
things.
So
we
kind
of
volunteered
to
take
to
keep
running
this
meetup
and
the
ros
meetup
is
basically
a
place
for
everyone
to
share.
A
We
don't
expect
necessarily
an
expert
level
from
all
angles.
We
we
take.
We
are
ready
to
consume
content
because
we
also
want
to
know
the
struggles,
and
these
are
the
things
that
can
help
russ
grow
as
a
community
also
improve
things
that
are
lacking,
although
rust
has
had
a
fragrant
affiliate
needs
in
terms
of
how
how
the
the
language
has
grown
into
mainstream
for
in
a
short
in
so
much
short
amount
of
time,
but
we
still
have
feel
like.
A
And
for
we
follow
the
berlin
code
of
conduct
and
which
is
accessible
at
berlin
code
of
conduct.org,
if
you
notice
anything
inappropriate
or
things
that
you
might
not
like,
please
report
privately
or
directly
to
us,
we
will
make
sure
to
to
fix
that
and
improve
things.
So
it's
such
that
we
can
create
a
community
that
is
enjoyable
for
everyone.
A
And
ros
intel
meetup
is
available
online
here
on
this
zoom
and
we
also
have
breakout
rooms
regarding
the
breakout
rooms.
When
you
feel
like
you
are
alone
on
a
breakout
room,
you
can
always
move
out
from
that
room
and
then
we
as
the
admin,
especially
and
eric,
will
us
make
sure
to
assign
you
to
another
room
where
there
are
people,
because
sometimes
people
might
leave
your
breakout
room
and
you
you
find
yourself
alone
there.
A
A
Today
we
will
have
three
talks.
The
first
talk
is
by
ashley
williams
and
she
will
be
talking
about
ross
foundation
and
the
second
talk
will
be
from
paul
butler.
She.
He
will
be
talking
about
building
a
multiplayer
web
assembly
game
with
upper
and
then
the
last
talk
we
have
introduction
to
ci
cd
for
ross
with
jitlab
and
that
talk
will
be
given
by
mario
garcia.
A
A
B
B
But
I'm
speaking
to
you
today
as
the
interim
executive
director
of
a
fantastic
new
organization
that
you
may
have
heard
of
called
the
rust
foundation.
What
I'd
like
to
do
in
the
talk
today-
and
I
only
have
20
minutes
so
it
is
going
to
be
a
wild
ride.
I
always
make
way
too
many
slides.
Is
I'd
really
like
to
talk
to
you
about
the
philosophical
kind
of
background
behind
the
foundation?
What's
motivating
it
and
help
you
try
to
understand
why
we
are
so
excited
about
it.
B
There's
probably
eight
talks
worth
of
content
about
how
this
organization
is
set
up,
and
maybe
I
can
come
back
and
talk
about
those.
So
if
you
have
a
particular
question-
and
I
don't
end
up
answering
in
in
this
talk-
please
don't
hesitate
to
reach
out
infamously.
I
am
a
g
underscore
dubs
on
twitter.
If
you
follow
me,
I'm
sorry,
but
also
if
you
follow
me
on
twitter,
some
of
these
ideas
might
be
familiar
all
right.
So
let's
go
all
right.
B
So,
first
off,
if
you
are
unaware,
the
russ
foundation
has
a
website
at
foundation.rusdashlang.org
and
you
can
see
a
ton
of
stuff
here.
But
what
I'd
like
to
draw
your
attention
to?
Is
the
tagline
that
we've
written
here,
which
says
a
new
approach
to
sustaining
and
growing
a
large
participatory,
open
source
ecosystem?
B
And
so,
if
you
haven't
attended
a
talk
of
mine
before
you
know,
I
like
to
kind
of
dig
into
really
simple
kind
of
tactical
questions.
Early
on,
so
I'm
gonna
ask
the
question:
why
does
open
source
matter
keep
it
simple
right?
Why
does
open
source
matter
at
all,
and
I
might
even
grow
that
just
a
little
bit
because
of
the
kind
of
current
zeitgeist
in
the
open
source
ecosystem,
which
is
what
does
software
freedom
mean?
Now
there's
a
lot
of
different
answers
to
this
question,
but
kind
of
canonically.
B
What
we've
seen
is
people
tend
towards
tend
to
talk
about
licenses,
and
they
will
talk
often
about
these
four
essential
freedoms
of
software,
which
were
established
by
the
new
project,
which
is
stewarded
by
the
free
software
foundation,
which
you
may
or
may
not
be
aware
of,
and
is
currently
in
the
news.
We're
not
going
to
talk
about
that
specific
situation
exactly.
B
But
what
I
do
want
to
talk
about
is
these
four
essential
freedoms
and
why,
to
a
certain
extent,
I
think
we're
missing
the
forest
for
the
trees
when
we
talk
about
software
freedom,
so
these
four
essential
freedoms
set
aside
the
idea
that
you
should
be
able
to
have
freedom
to
run
the
program
as
you
wish
to
study
how
it
works
to
redistribute
copies
if
you've
ever
read
a
a
software
license.
These
are
kind
of
the
aspects
that
a
license
will
talk
about.
B
And
this
is
the
driving
force
behind
the
foundation,
and
this
is
an
interesting
thing
and
a
lot
of
people
might
not
realize
this.
But
the
key
word
in
that
previous
slide
is
the
word
maintainer
and
somewhat
artificially.
I
have
created
this
distinction
in
my
head
and
I'm
eager
to
evangelize
it,
which
is
the
concept
of
a
maintainer
versus
the
concept
of
a
contributor
and
how
they
operate
inside
a
large
open
source
ecosystem.
B
Similarly,
and
yet
what
I
hope
to
do
by
the
end
of
this
talk
is
to
make
them
be
actually
a
very
clear
distinction
and
that
the
health
of
both
of
these
classes
of
participants
in
open
source
is
critical
to
that
project
survival
all
right.
So
as
a
basic
definition.
What
I
would
say
is
a
maintainer
is
a
person
that
makes
contributors
to
a
project
possible.
B
B
So
when
we
talk
about
rust
now
with
rust
being
so
huge,
I
would
say
in
general
that
rust
team
members
are
part
of
this
maintainer
class
and
then
there's
a
huge
set
of
folks
who
contribute
to
rust,
underneath
so
just
to
run
a
couple
of
numbers.
Russ
governance
is
really
uniquely
distributed
and
delegated,
which
is
to
say
we
have
a
lot
of
people
who
are
participating
in
rust
and
they're,
also
participating
in
a
leadership
role.
B
So
russ
has
10
top
level
teams,
54
project
groups,
which
could
either
be
top
level
or
within
a
team
and
amongst
the
people
who
are
members
of
those
teams
and
project
groups.
We
have
260
folks.
Now
that
is
not
solely
contributors.
Those
are
people
who
are
leading
contributors,
it's
a
large
number,
all
right
and
then,
as
of
october
and
2020.
When
I
last
ran
these
numbers
on
github,
we
had
5503
all-time
contributors,
and
that
was
averaging
around
350
contributors
per
release
and
growing.
B
C
B
Cargo
rust
dock
there's
several
things,
so
this
is
contributors
just
to
wrestling
rust.
The
number
is
actually
significantly
higher
all
right
and
then,
in
addition,
we've
had
623
new
people
as
of
this
year,
contribute
to
the
github.com
wrestling
github
org
and
we've
had
1467
new
people
contribute
to
erlo,
which
is
our
user
forums
and
if
you're
not
familiar
with
that,
you
should
definitely
check
those
out.
B
B
If
you're
new
to
rust,
rfcs
are
documents
that
we
create
in
a
process
to
make
large
decisions
in
the
rust
project.
All
of
the
large
decisions
happen
there
and
it's
a
very
transparent
process
for
those
471
merged.
Rfcs
we've
had
1128
unique
individuals
participating
in
rfcs.
That
is
an
incredibly
large
number
of
people
to
be
making
these
high
level
decisions
in
the
rust
project,
and
I
think
it
is
a
huge
testament
to
what
we've
built
that
we've
been
able
to
include
those
people.
B
So
first
off,
I
want
to
make
it
very
clear
that
this
is
a
sketch
that
I
made
about
three
hours
ago,
and
it
is
not
scientific
and
it
is
almost
certainly
inaccurate,
but
because
it
is
likely
inaccurate
and
not
scientific.
What
I
want
you
to
get
the
sense
of
from
this
sketch
is
the
idea
of
thinking
about
how
these
constituencies
grow
and
react
to
each
other
over
time,
because
I
think
understanding
this
system
is
the
route
to
finding
sustainability
in
an
open
source
project.
B
B
So
with
that,
let's
take
a
look
at
this
in
particular,
so
there's
a
project
here,
this
kind
of
represents
an
open
source
project.
The
y-axis
represents
number
of
humans
and
the
x-axis
is
overtime.
So
you
can
see
if
you
look
right
at
the
beginning
of
time.
Clearly
this
is
already
inaccurate,
because
every
project
starts
with
basically
no
users,
no
commenters
and
probably
one
maintainer,
so
we're
starting
our
timeline
a
little
bit
a
little
bit
later
on
in
the
process.
But,
looking
at
this,
what
we
can
see
is
we
start
with.
B
B
What
we
see
is
that
we
see
a
growth
in
contributors
alongside
the
growth
of
users,
as
well
as
the
growth
of
commenters,
whereas
the
maintainer
level
tends
to
stay
around
the
same
number
and
if
we
take
a
look
at
some
of
these
ratios
thinking
about
the
number
of
maintainers
who
have
to
be
helping
those
number
of
contributors
responding
to
those
number
of
commenters.
That
ratio
is
starting
to
grow
quite
dramatically
as
time
moves
on.
B
I
think
we
hit
a
critical
spot
where
the
number
of
users
is
actually
surpassing
the
number
of
contributors
and
that
you
have
a
lot
of
folks
who
are
able
to
use
and
comment
on
your
software,
but
not
able
to
contribute
back,
and
what
you
should
also
note
is
on
that
maintainer
line.
That
number
is
starting
to
slide
down
and
then,
finally,
at
the
end
of
time.
In
this
scenario,
what
we
see
is
we
have
both
commenters
and
users
growing
exponentially
and
we
start
to
see
a
dip
in
maintainers
and
contributors
are
staying
flat.
B
Now
I've
drawn
this
in
this
way,
because
this
is
how
I've
seen
a
lot
of
a
lot
of
open
source
projects
play
out,
and
this
starts
to
be
around
the
time
where
you
feel
the
velocity
of
the
project
slowing
down
a
lot
of
people
talk
about
the
hype
cycle
of
projects
where
oh
everyone's
so
excited
at
the
beginning.
But
then,
eventually
you
know
they
kind
of
go
to
the
next
new
thing
and
people
often
blame.
You
know
the
people
chasing
those
things
for
this
reaction,
but
I
think
that's
an
inversion
of
the
problem.
B
Whereas
what
happens
is
these
projects
tend
to
slow
down
because
they
haven't
found
a
way
to
increase
the
number
of
contributors
and
maintainers
to
be
able
to
support
their
growth,
and
so
their
growth
to
a
certain
extent,
stalls
the
project
and
then
the
project
stalls
out
we
move
on
to
something
new.
This
is
the
future
that
I
don't
want,
and
what
I'm
trying
to
focus
on
is:
how
can
we
change
these
lines
in
order
to
build
a
healthier
and
more
exciting
future
for
rust?
B
So
we're
talking
about
maintainers?
What
is
this
plight
of
maintainers?
I
think
there's
a
lot
about
this
role
because
we
haven't
given
it
a
name
that
we
don't
pay
attention
to
and
if
we
do
we'll
be
able
to
figure
out
some
ways
to
help
focus
on
it.
So
in
particular
I
would
say,
maintainer
work
requires
incredibly
high
context
and
very
high
consistency.
B
If
you
have
the
misfortune
to
succeed
in
open
source,
maintainership
is
going
to
become
a
full-time
job.
However,
it's
really
rarely
the
case
that
we
see
that
open
source
maintainers
actually
get
compensated
for
their
work.
The
way
a
full-time
job
might,
I
think,
we're
at
a
moment
right
now
in
open
source,
where
we're
seeing
a
lot
of
interesting
different
attempts
at
solutions.
B
So
to
kind
of
throw
this
home,
I
thought
hey.
Why
don't
I
just
search
search
my
twitter
for
how
many
times
I've
talked
about
burnout,
and
this
would
be
the
moment
where
I
look
out
on
the
room
and
say
how
many
people
here
are
open
source,
maintainers
and
feeling
burnt
out.
How
many
people
here
just
are
maintaining
any
piece
of
software
and
feel
burnt
out
and
so
we'd
see
all
these
hands?
B
I
know
everyone
doesn't
have
their
video
open,
but
I
ran
this
search
and
I
took
a
look
at
some
of
the
things
I
said
and
one
of
the
things
that
I
was
struck
by
is
that
not
only
had
I
talked
about
burnout
a
lot,
but
I
also
had
talked
about
it
for
a
really
long
time.
I
don't
know
if
you're
seeing
the
time
stamps
on
these,
but
I'm
looking
at
this
and
I'm
like
wow.
I
was
tweeting
about
burnout
five
years
ago.
B
You
know
fresh
and
healthy,
as
well
as
its
relationship
to
burnout,
seemed
really
interesting
to
me.
As
you
can
see,
2016
saying
I
see
a
lot
of
startups
burn
out,
because
building
a
thing
requires
five
people,
but
maintaining
and
changing
it
over
time
takes
exponentially
more,
and
I
don't
think
this
is
unique
to
startups
what
is
a
large
open
source
project
except
a
less
well
organized
giant
or
like
company.
B
B
B
Not
only
is
this
an
old
problem
that
a
lot
of
people
have
to
face,
but
rust
russ
has
set
the
bar
extremely
high,
and
I
think
that
this
is
one
of
the
reasons
that
we're
in
a
best
position
to
tackle
it,
because
we
can
feel
these
pains
extremely
carefully
and
because
our
values
are
so
associated
with
making
that
contributor
experience
high.
We
really
are
motivated
to
figure
out
how
we
can
continue
to
enable
that
over
time.
B
So
what
do
we
do?
You
just
talked
about
a
whole
bunch
of
problems,
everyone's
like
yeah,
open
source.
It
has
a
sustainability
problem.
What
do
we
do
all
right
enter
rust
foundation?
This
is
something
that
we're
really
zeroed
in
on
trying
to
fix
so
classic
open
source
foundations
generally
focus
on
growing
adoption,
particularly
in
corporations,
and
so
what
I
would
like
to
propose
is
like
the
rust
foundation
is
actually
not
concerned
about
growing
adoption
whatsoever.
B
In
fact,
I
think
we
can
assume
adoption.
We
are
seeing
people
pick
up
rust
in
so
many
different
places.
Instead,
I
think
our
focus
needs
to
be
surviving
adoption
and
when
I
ran
this
by
some
of
my
folks
on
the
board
and
on
the
core
team
they're
like
we
don't
want
to
just
survive,
we
want
to
capture
adoption,
and
so
what
does
that
mean?
So
we
got
this
picture
right,
so
the
picture
is
very
similar
to
the
one
that
we
had
before,
but
it's
particularly
focused
on
growth
of
corporate
use.
B
So
again,
our
axes
are
the
same
y.
Is
number
of
people
x
is
time,
and
what
we
see
here
is
the
one
up
at
the
top.
Is
people
with
ideas
about
your
thing
generally
high
and
just
grows
even
higher,
and
then
we
have
corporate
users
which
starts
very
low
and
then
starts
growing
exponentially
and
then
in
the
middle
we
have
maintainers.
B
Now
this
line
is
very
interesting
because
you
often
see
once
you
have
this
kind
of
hockey
stick
growth
of
corporate
users
that
your
number
of
maintainers
actually
starts
to
decrease
and
part
of
this
is
because
corporate
users
go.
Oh,
my
gosh
rust
is
awesome.
I
want
to
build
the
rest
of
my
products
future
on
rust.
I
need
to
hire
the
best
rust
developers
who
are
the
best
rust
developers-
oh,
my
goodness,
they're
the
people
who
wrote
rust
and
so
inevitably
what
happens?
B
B
A
B
The
final
point
is
being
a
maintainer
should
be
a
career
opportunity
and
we've
been
designing
the
rust
foundation
to
help
support
that,
so,
in
particular
for
our
membership
fees.
We
have
what
we
call
this
team
member
discount,
where
four
organizations
that
employ
rust
team
members
for
a
hundred
percent
of
their
time
we're
giving
them
a
15
discount
on
their
fees,
which
can
go
up
to
a
45
total
discount.
B
So
we
are
trying
to
incentivize
organizations
to
hire
folks
full
time
to
work
on
rust
in
their
capacity
as
a
maintainer,
and
so
this
is
all
stuff
about
our
board,
and
we
can
talk
about
that.
Obviously,
I've
been
doing
all
this
crazy
stuff
with
lines,
and
you
probably
think
this
is
wild.
But
if
you
hear
anything,
what
I
want
you
to
hear
is
that
I
feel
an
optimism
that
I
haven't
felt
in
a
long
time
about
open
source
sustainability,
and
I
want
you
all
to
feel
it
too.
All
right.
B
Rust
is
the
only
thing
that
rust
is,
is
the
emergent
product
of
the
people
who
are
building
rust,
and
so,
while
people
and
collaboration
are
both
expensive,
they
are
the
only
thing
worth
investing
in
and
so
investing
in
rust
and
investing
in
the
rust
foundation
is
really
about
investing
in
its
people.
With
that,
I
will
stop
taking
up
all
the
time.
Thank
you
very
much.
A
A
C
The
outline
here
is,
as
I
mentioned,
I'm
going
to
start
just
sort
of
generally
taking
a
step
back
talking
about
this
problem
of
sharing
state,
and
so
the
the
general
problem
is.
Basically,
you
have
multiple
instances
of
a
rust
program.
In
this
case
it's
going
to
be
program
running
in
webassembly,
but
we
can
think
even
more
generally
than
that
about.
You
know
you,
you
just
have
some
some
rust
code.
C
The
these
use
cases
of
this
have
actually
kind
of
exploded
in
the
last
few
years
kind
of
pre-covered,
but
even
especially
during
covid,
where
we
have
a
lot
of
these
use
cases
for
things
like
figma
or
multiplayer
games,
where
we're
doing
things
online
that
we
used
to
do
kind
of
standing
around
a
whiteboard
or
you
know,
editing
code
pairs
side
by
side
now
is
happening
in
the
browser.
So
I
think
it's
a
great
time
to
be
interested
in
stage
sharing.
C
C
C
Here's!
Here's
a
example
to
show
what
I
mean.
This
is
a
hypothetical
packing
list,
a
shared
packing
list
application.
You
can
imagine
something
like
notion
or
or
google
keep
where
you
have
a
multi-user
checklist,
that's
being
synced
in
real
time.
Let's
say
at
time:
zero.
We
have
three
items
on
the
list
at
time
and
at
time,
zero.
Both
bob
and
alice
get
a
copy
of
that
state
simultaneously.
C
Alice
adds
a
camera,
stand
to
the
list
and
puts
it
at
position
index
1,
because
it's
associated
with
the
camera
at
the
very
same
time,
bob
checks
phone
charger
because
he's
packed
that
so
we
have
these
two
operations
that
change
the
data
structure.
One
is
an
insert,
and
one
is
this-
modifying
the
checked
item.
C
The
server
gets
both
of
those
alice's
connections
a
little
bit
faster,
so
that
change
comes
in
first
and
by
the
time.
Bob's
change
is
applied.
The
item
at
index,
one
which
he
thinks
is
the
phone
charger
or
it
was
the
phone
charger
when
he
checked.
That
item
is
now
the
camera
stand,
so
he's
checked
that
he's
packed
the
camera
stand
even
though
he's
packed
the
phone
charger,
so
this
type
of
conflicts
kind
of
arise
when
you
just
naively,
take
this
data
structure
based
approach.
C
So
an
example
of
what
that
would
look
like
is
in
this
case.
What
I've
done
is
added.
Ids
to
each
of
these
items,
so
these
are
unique
identifiers
generated
using
the
uuid
crate
when
these
are
created.
So
in
this
case,
he's
checking
the
item
and
instead
of
passing
the
index
he's
passing
the
id
similarly
alice
when
she
adds
the
camera
stand,
adds
it
in
reference
to
another
item
or
it's.
C
C
C
Example-
and
so
I've
been
working
on
that-
and
it's
called
apr,
it's
a
a
rust
crate,
it's
in
crates
dot
io
now,
but
it's
a
very
early
kind
of
work
in
progress
thing.
So
I
wanted
to
kind
of
get
out
early
and
show
it
to
the
world
and
and
get
some
of
your
feedback
and
show
what
I'm
working
on.
So
that's
what
I'd
like
to
do
today,
so
there's
kind
of
two
main
pieces
to
this
crate
or
really
multiple
crates,
so
two
main
pieces
to
this
project.
C
The
first
is
kind
of
the
core
data
structures
and
state
library-
and
this
is
this
part-
is
completely
agnostic
to
the
transit
layer.
So
you
could
use
this
for
synchronizing
state
within
the
on
the
same
cpu
just
as
easily
as
you
could
across
the
network.
Then.
The
second
part
is
some
client
infrastructure,
client,
server
infrastructure.
C
The
state
machine
itself
is
very
simple.
It
looks
like
this.
I've
removed
a
few
type
bounds,
but
this
is
basically
the
core
implementation
of
what
a
state
machine
is
there's
a
transition
type,
which
is
just
the
encoding
of
the
user,
intent
associated
with
your
data
structure,
and
this
apply
method
which
takes
your
you
know.
Your
data
structure
takes
the
transition
and
applies
that
change
in
place.
C
There's
two
conditions
you
need
to
satisfy.
If
you
do
choose
to
implement
your
own
state
machine.
The
first
is
that
the
only
method,
the
only
public
method,
that's
allowed
to
modify
state
is
apply,
and
that
also
means
you
can't
expose
your
members
to
the
public
in
a
way
that
they
may
mutate
them,
and
the
second
is
that
the
call
to
apply
must
be
deterministic,
and
the
reason
for
that
is
that
we're
running
that
apply
multiple
times.
We're
running
that
on
every
instance
that
is
synchronizing
state.
C
C
C
C
C
This
board
starts
to
get
filled
in
and
I've
just
wrapped
it
in
a
board
struct,
so
that
I
can
implement
some
behavior
on
it,
but
you
could
just
as
easily
use
a
raw
array
of
race
here
then
kind
of
expanding.
What
this
looks
like
as
a
state
machine.
One
thing
in
the
context
of
of
april's
serving
architecture
is
that
players
or
users
when
they
join,
they
are
given
a
player
id,
but
there's
no
significance
assigned
to
that
at
the
time
they
join.
C
So
we
kind
of
have
to
manage
the
state
changes
as
users
join
the
app.
So
initially
we
have
no
users
in
sort
of
in
the
game.
We
have
this
waiting
player,
none
when
the
first
player
joins
they
get
put
into
this
waiting
player
slot.
If
you
want
to
think
of
it
that
way,
but
they're
still
we're
still
missing
one
player
to
actually
start
the
game.
C
C
C
So
the
way
we're
representing
this
in
code
is
there's
a
playstate
enum.
It
has
this
waiting
type,
I
guess
or
waiting.
What
do
you
call
a
thing
of
any
enum
option
and
there's
another
option
that
is
playing
that
has
a
little
bit
more
state
attached
to
it,
because
when
the
game
is
in
play,
we
need
to
know
who's
playing
next.
What's
on
the
board,
who's
won
the
game
and
something
called
player
map
which
we'll
show
on
the
next
slide.
C
This
is
again
wrapped
in
another
state
kind
of
for
ergonomics,
reasons
that
I'll
ignore
for
now
there's
this
player
map,
which
I
mentioned
in
the
last
slide.
This
is
kind
of
just
storing.
This
is
what
tells
the
game
state
which
of
the
connected
users
is
which
associated
with
which
color.
So
this
is
what
prevents
the
brown
player
from
playing
for
teal,
for
example-
and
this
is
see
player
id
here-
is
a
kind
of
an
opaque
type
that
comes
from
the
serving
architecture
of
apr,
but
basically
what
it.
C
C
Those
are
wrapped
here
in
this
transition
event,
which
is
a
part
again,
a
part
of
the
serving
architecture
or
infrastructure
that
tells
associates
a
player
id
and
time
and
a
bit
more
metadata
with
each
event
and
then
the
apply
here
is
just
a
branch.
Looking
at
what
transition
type
we've
received
in
the
join
case,
we
first
check
whether
there's
a
waiting
player.
So
again,
this
is,
you
know
we
have
two
states
associated
with
waiting.
One
is
when
there's
no
players
yet,
and
one
is
when
there's
one
player.
C
C
We
we
let
the
player
teal
player,
go
first
refresh
the
board
or
empty
the
board
start
with
a
initialized
board.
We
have
no
winner
and
then
we're
ready
to
start
playing
the
game
with
drop.
It's
a
little
bit
more
complicated.
We
first
check
if
we
check
on
the
game
state,
so
we
first
check
if
the
game
has
been
won.
If
it
has.
A
C
It's
a
no-op
april
doesn't
support
conflicts
yet,
but
I
think
that
would
sort
of
raise
a
conflict
once
it
says.
If
the
we
also
check
if
this
player
who's
playing
is
actually
next.
So
if
the
the
computer
that's
connected
or
the
machine
that's
connected
for
you
know,
as
the
brown
player
can
tries
to
go
out
of
turn
when
its
teals
turn,
it
falls
into
this
if
clause
and
doesn't
go
through
with
it.
C
But
if
those,
if
neither
of
those
two
things
are
true,
then
we
see
if
we
can
play
in
the
next
available
the
next
available
row,
so
discs
fall
because
of
gravity.
So
we
this
is
kind
of
the
implementation
of
gravity.
We
look
for
the
the
row
that
it
would
that
the
disc
would
fall
into
we
put
it
there
we
check.
C
C
We
just
passed
the
player
map,
as
is-
and
we
say
that
there's
no
winner,
so
you
know
I.
I
obviously
skipped
over
some
implementations
of
a
few
of
those
methods.
I
was
trying
to
sort
of
speed
run
this,
but
I
think
you
know
at
a
high
level.
At
least
that
gives
you
the
idea
of
what
the
state
machine
implementation
looks
like
and
from
there
it's
actually
really
easy
to
kind
of
synchronize
that
state
machine
across
a
client
server.
C
This
is
using
the
actix
server
framework,
and
so,
if
you
want
to,
you,
can
write
your
own
active
server
and
kind
of
use
the
pieces
of
this
to
get
a
bit
more
control,
but
as
a
dev
server
you
basically
just
initialize.
This
server
builder
pass
up
the
state
program
and
say
dot
serve,
and
it
runs
a
dev
server
on
port,
8080
and
kind
of
just
works
and
that's
serving
web
sockets,
then
on
the
client.
C
So
remember,
the
client
is
compiled
to
webassembly,
I'm
using
a
framework
called
you
for
that,
and
so
the
the
way
that
I
do.
That
is
you
implement
this
game
view
or
sorry.
This
view
trait
of
of
the
package
apriu,
and
so
in
that
case
I
have
this
game
view.
The
only
real
important
thing
here
is
that
the
it
implements
this
view
method
which
takes
a
reference
to
the
state,
as
well
as
a
context
object
which
has
some
other
things
like
the
callback.
C
You
need
to
call-
and
this
renders
this
returns
you
html,
so
it
can
do
that
using
use
html
macro
again
I've
kind
of
hidden
away,
some
of
the
implementation
of
view
inner
here.
But
basically
everything
under
this
is
just
regular.
U
code,
it
doesn't
really
have
to
interact
with
the
aper
state
framework.
C
And
then
the
last
bit,
that's
important
on
the
client
is
to
call
call
this
client
builder,
so
this
wasn't
by
gen
start
decorator
kind
of
tells
it
to
enter
with
this
and
client
builder.
Here
is
just
a
april:
u
struct
that
will
take
that
it
connects
to
the
server,
renders
the
initial
state
things
like
that.
C
C
So
the
idea
is
here:
there's
two
instances
in
the
initial
state
I'm
going
to
hit
join
on
each.
You
can
actually
see
the
messages
that
are
going
over
the
wire
in
production.
This
is,
it
uses
bin
code
to
to
fairly
concisely
pack
these
messages
as
binary,
but
in
this
dev
environment,
I'm
just
outputting
json.
C
C
When
I
do
that
now
it's
my
turn,
as
you
can
see
too
it's
using
the
player
id
of
the
client
that
I'm
running
to
to
actually
change
what
it's,
how
it,
how
it
displays
the
view
itself,
so
each
v,
each
user
can
see
a
different
view
of
the
data,
even
though
their
client
does
have
an
identical
copy
of
the
state
I'll
play
it.
One
more
and
you'll
see
that
this
is
sent
to
the
server.
C
This
actually
doesn't
modify
the
estate
internally
until
it's
received
the
state
update
from
the
server
and
that's
what
allows
it
to
keep
doing
these
things
in
order.
Although
one
of
the
next
things
I
want
to
implement
is
an
approach
where
it
optimistically
applies
it
locally
and
then
ensures
that
the
server
sends
the
same
state
update,
expects
and
rolls
back
if
it
doesn't.
C
C
This
example
that
I
showed
is
right
in
the
github
you
can
just
cargo
run
and
it
will
actually
compile
both
the
client
and
the
server.
Assuming
that
you
have
the
right
bosom
tools
installed
like
bind
gen,
but
it's
it's
again
pretty
standard
tool,
ecosystem
or
you
use
this.
This
ecosystems
tools
and
these
slides
are
also
online
on
that
website.
A
C
C
This
is
an
amazing
question.
I
actually
predicted
this
question,
so
I
have
a
couple
more
slides
on
this,
so
it
is
not
a
crdt
one
of
the
big
differences.
The
way
I
think
of
it
is
with
the
crdt
you're
dealing
with
a
set
of
of
these
transitions.
This
is
dealing
with
an
ordered
sequence
of
transitions
and
the
nice.
The
advantage
of
the
set
approach
with
crdts
is
you
don't
need
a
central
server
to
manage
that
set
peers
can
can
kind
of
send
peer-to-peer
what
those
transitions
are.
C
There's
also
the
downside,
though,
that
that
set
will
only
ever
grow
over
time
with
apr.
You
kind
of
you
you
step
into
the
stream
and
get
a
complete
copy
of
the
state,
and
then
you
just
get
versions
of
the
stream
from
there.
So
this
you
know
the
big
thing
for
me:
was
this
monotonic
memory,
footprint,
growth
or
or
state
size
footprint
growth
with
crdts?
C
What
I
found
was
looking
in
the
wild
is
that
a
lot
of
people
who
you
think
might
be
using
crdts
are
using
crdts
as
inspiration,
but
actually
aren't
using
crdts
themselves,
especially
if
they
have
a
central
server
that
it
just
seems
the
cost.
The
cost
that
you
pay
with
the
crdt
doesn't
always
pay
off.
If
you
don't
need
that
peer-to-peer
aspect,
so
thanks.
That's
a
great
question.
A
C
I
took,
I
definitely
took
I
looked
a
lot
at
what
figma
has
done.
The
excalibur
developers
as
well
have
been
pretty
open
with
how
they
kind
of
architected
things.
So
there's
some
good
resources
out
there
now
and
I
definitely
did
look
at
at
crdt
approaches.
There's
also
a
ton
of
great
material
on
crdt
and
operational
transform
as
well.
But
games
are
really
interesting.
C
C
That's
definitely
something
that
that
I've
read
about
happening
in
game
development,
as
is
the
idea
of
kind
of
sharing
the
state
code
between
the
client
and
server,
which
I
think
is,
is
a
really
great
idea,
even
if
you're,
not
using
apr
like
one
of
the
coolest
things
to
me
about
webassembly,
is
that
you
can
write
the
same
code
and
share
it
between
the
client
and
the
server
without
restricting
yourself
to
javascript
and
node.
You
know
you
can
use
whatever
language
you
want
and,
and
rust
is
a
great
choice
for
that
so
yeah.
A
A
C
It
uses
you
and
the
dom
I
use
svg.
I
actually
learned
a
lot
of
svg
while
I
was
doing
this,
I
didn't
think
it
would
be
capable
of
doing
the
both
the
some
of
the
transitions
I
used
and
also
drawing
a
rectangle
with
holes
in
it
turns
out
to
be
really
easy
to
do
with
svg.
I
thought
I
would
need
to
write
some
path
commands
or
do
something,
but
it
turns
out
you
can
just
subtract
using
masks,
which
is
pretty
cool,
yeah.
A
D
D
So
this
will
be
an
introduction,
and
I
I've
been
writing
about
this
topic,
so
you
can
find
some
blog
posts
on
my
dev
account
and
right
after
this
talk,
there
will
be
another
blog
post
available
that
I
wrote
last
weekend.
I'm
also
a
member
of
the
gitlab
heroes
program.
You
can
find
me
on
twitter,
as
mario
gmg.
D
So
these
are,
these
are
the
tools
that
I've
tried.
I
I
started
with
tri-ci
and
gitlab.
Ci
was
the
second
one
that
I
tried
gitlab
ci.
I
started
with
with
this
tool
about
two
years
ago:
github
action
wasn't
available
yet
during
that
time
it
was
released.
Well,
the
the
beta
access
was
open
later
that
that
year
and
why
I
choose
gitlab
over
the
other
tools
that
I
listed
that
other
that
are
available
out
there.
D
Well
this-
and
these
are
some
of
the
resources.
Why
well
gitlab
ci
is
part
of
the
of
the
whole
platform.
I
mean
when
you
register
an
account
on
gitlab.com.
You
would
get
access
to
gitlab,
ci
and
other
features
that
you
will
find
interesting,
but
it's
also
part
of
the
open
source
project
of
gitlab
and
it
has
docker
support.
I
will
talk
about
about
that
later
today
and
other
features
that
I
like
about
gitlab
is
that
you
have
also
gitlab
pages.
D
D
D
This
is
a
a
project
that
I
have
configured
for,
trying
gitlab
ci,
but
you
have
to
add
these
three
files
that
will
contain
the
following
lines.
So
this
one
that
is,
the
proc
file,
google
contained
instructions.
This
is
for
heroku.
I
will
talk
about
heroku
and
google
app
engine,
how
you
can
use
gitlab
ci
for
deploying
on
any
of
those
platforms,
but
you
can
also
use
gitlab
ci
for
amazon
web
services
or
any
other
platform
like
like
network,
but
this
little
example
here
is
for
for
heraku.
D
This
is
the
instruction
that
heroku
has
to
run
so
so
your
application
start
when
you
deploy
on
that
platform,
you
have
to
assign
the
value
of
the
the
port
that
heroku
assigned
to
your
application
in
this
variable,
and
you
have
to
specify
the
the
environment
where
the
where
your
application
will
be
running
and
the
the
path
for
for
the
binary.
That
is
created
after
you
build
your
your
project
and
we
have
another
one
that
is
for
us
config.
D
You
have
to
specify
the
url
and
these
files
are
so
important.
We
have
to
create
those
files
of
heroku
know
what
version
of
of
ros
we
have
to
use
and
what
will
be
the
instructions
for
running
the
application.
But
these
are,
depending
on
the
on
the
platform
that
you
that
you
choose
for
deploying
your
application.
D
D
And
if
we
talk
about
google
app
engine,
we
have
to
create
a
dockerfile
with
the
instructions
for
building
our
application.
Something
that
is
recommended
is
that
you
use
multi-stage,
builds
for
building
the
docker
image
that
will
be
used
for
deploying
on
that
platform
and
the
file
app.
The
java
file
that
we
have
here.
You
can
check
an
example
in
this
repository.
D
And
the
docker
file
will
look
similar
to
this,
while
using
multi-stage
built
for
creating
this
docker
image.
The
reason
why
is
that
when
we
run
cargo
build
release,
we
get
so
many
files
in
the
target
directory,
but
we
only
need
the
binary
that
we
have
to
execute
for
running
our
application.
So
we
don't
need
the
other
files
available
there
and
that's
why
we
use
multi-stage
build
for
that.
D
First,
we
compile
our
project
without
we
download
the
the
dependencies
of
our
project
and
compile
the
project
in
general,
and
we
get
the
binary
from
from
that
first
stage
and
copy
that
binary
to
the
to
the
last
stage
that
were
that
would
contain
also
the
other
files
that
we
have
in
the
repository
that
are
important
for
telling
the
platform
how
it
has
to
how
the
the
application
has
to
be
executed,
and
this
is
the
content
for
the
the
jammon
file
that
we
have
here.
This
is
for
configuring,
google
app
engine.
D
Well,
talking
about
heroku
there's
a
built,
there's,
not
an
official
buildback
for
for
ross,
but
there's
a
buildback
that
I've
been
using
for
for
deploying
some
applications
to
heroku.
This
is
a
a
build
pack
developed
by
the
community.
You
can
check
the
repository
here
and
but
if
you,
if
we
want
to
deploy
an
app
to
heroku,
we
have
to
register
an
account.
D
D
This
is
so
important
that
we
require
this
information
for
telling
gitlab
gitlab
ci
how
to
access
our
account
on
heroku.com
and
for
google
engine.
We
have
to
spend
a
little
more
time
for
configuring,
our
application
and
configuring.
The
the
platform
for
deploying
our
project,
but
what
we
have
to
do
is
first,
is
create
creating
an
account
at
cloud.google.com
app
engine.
We
have
to
create
a
new
project.
I
won't
explain,
won't
explain
the
whole
process
as
this.
D
I
already
wrote
an
article
about
that
that
will
be
available
right
after
this
talk
and
well.
We
have
to
create
an
application
select
a
region
from
that
select
the
programming
language
ros
is
not
listed,
so
we
have
to
to
choose
other,
but
google
app
engine
has
a
performance
and
set
the
environment
to
flex.
D
D
D
D
D
And
for
google
engine
the
the
steps
will
be
the
same,
but
we
have
to
add
two
variables
one
for
the
project
id.
This
is
the
id
of
the
project
that
we
created
before
and
we
have
to
add
the
the
content
of
the
json
file
that
we
downloaded
in
the
service
account
variable
and
after
that
we
have
to
create
the
gitlab
ci
demo
file
for
the
first
scenario,
when
we
use
heroku
for
deploying
our
application.
D
D
We
have
here
the
build
and
deploy
stages
in
the
build
stage.
We
build
our
application
and
run
the
test
that
we
that
we
wrote
in
in
the
in
our
in
our
code,
and
we
can
change
here
this
value
to
true.
If
we
don't
care
about
the
the
test
failing,
but
if
we
don't
want
that
the
following
stage
started:
we
have
to
to
leave
the
the
default
value
that
is
false
and
finally,
in
the
deploy
stage.
D
The
information
about
the
service
account
that
we
are
using
for
accessing
our
our
account
on
google
app
engine.
We
have
to
specify
the
information
needed
for
for
accessing
our
project
and
something
that
happened
when
I
was
building
the
demo
that
is
available
in
in
this
repository
is
that
the
the
build
the
building
process
took
so
much
time.
So
I
have
to
to
what
to
set
the
time
out
to
this.
D
D
D
D
Job
this
is
really
helpful
as
there
wasn't
enough
documentation
about
what
roles
I
have
to
add
for
to
to
the
service
account
I
created
for
google
app
engine,
but
also
the
the
blog
post
that
I
checked
didn't
mention
that
we
have
to
enable
the
app
engine
admin
api.
So
the
the
log
here
shows
you
the
the
errors
that
you
can
get
when
when
running
your
your
pipelines-
and
this
has
been
really
helpful
for
understanding
how
to
configure
gitlab
ci
for
deploying
on
platforms
like
heroku
or
google
app
engine,
the
other
one.
D
D
D
D
D
But
have
a
community
one
available
and
you
have
to
create
those
three
files
that
I
mentioned
before.
But
what
happened?
If
we
decided
to
use
another
technology
within
ros
for
building
a
project,
I
mean
what,
if,
if
we
want
to
build
an
app
with
both
ros
and
python,
something
that
happened
here
when
we
decided
to
use
heroku
is
that.
A
D
D
D
A
D
Yeah,
I
was
talking
about
some
example
of
some
web
apps
that
I
that
I've
been
building,
but
you
can
also
use
for
for
for
for
a
project
that
that
that
will
run
on
on
the
on
the
terminal
that
you
don't
you
don't
require
to
to
run,
to
deploy
to
any
platform
you.
You
can
run
your
application
inside
gitlab
ci
by
running
the
the
app
after
the
building
process.
So
you
can
use
gitlab
ci
for
testing
the
apps
that
you
that
you
are
building
while
you're
learning.