►
From YouTube: Rust and Tell Berlin - June
Description
“Rust and Tell“ is a monthly event to share ideas, and learn about new things in and about Rust. Meet fellow Rustaceans, share your learnings, get motivated and inspired.
https://berline.rs/2020/06/30/rust-and-tell.html
#1: 00:11:00 - Rusty Beads by Maxim Zaks
#2: 00:47:26 - Transit Radar by Mike Bush
A
B
A
D
D
C
A
A
All
right,
hopefully,
everybody
can
see
my
screen
thanks
for
joining
everybody.
This
is
Russ
intel
I
want
to
welcome
everybody
from
far
and
wide,
whether
you're
joining
from
Berlin
or
from
somewhere
else
in
the
world.
Welcome,
first,
a
little
bit
about
who
we,
the
organizers,
are
I'm
Ryan
Levesque.
You
can
find
me
on
twitter
at
ryan,
underscore
Levesque
and
I
work
in
restful
time.
I
work
at
Microsoft
doing
rest
things.
Let
me
know
if
you're
interested
in
learning
more
about
what
we're
doing
with
rust
and
my
co-organizer
is
pasty-ass.
C
Think
groovin
hi
thank
you
for
the
introduction.
I
worked
in
rust
and
full
time
for
a
year
now,
not
so
much
anymore,
I'm,
currently
about
to
ride
a
rust
book,
a
rust
web
programming
book.
So
if
you're
interested
in
these
types
of
things
feel
free
to
get
in
touch,
if
you
want
to
have
a
preview,
if
you
have
any
questions,
I
would
be
happy
to
get
some
early
feedback
and
yeah
I'm
happy
to
have
you.
A
So
a
little
bit
about
the
concept
for
this
meetup
for
those
who
are
joining
for
the
very
first
time,
rust
Intel
is
really
about
sharing
struggles,
ideas
and
hacks
that
you
might
have
done
or
are
doing
and
rust,
and
really.
This
is
from
beginner
to
expert,
so
whether
the
project
that
you're
working
on
is
hello,
world
and
you've,
just
learned,
rust
or
learning
programming
for
the
very
first
time
or
you've
been
working
on
rust
for
the
past
10
years.
C
And
we
also
take
our
and
code
of
conduct
very
seriously.
We
follow,
even
if
this
meet
up
now
is
universal
and
global,
and
we
follow
the
berlin
code
of
contact
and
you
can
check
it
out
on
berlin
code
of
conduct
Dork
and
if
you
think
that
somebody
violated
the
code
of
conduct,
if
you
feel
I'm
threatened
or
not
welcomed
here,
please
I'm
a
feel
free
to
reporters
I'ma.
Privately,
we
have
twitter
emails,
LinkedIn
Facebook,
probably
just
feel
free
to
get
in
touch
and
yeah
to
report,
and
we
take
those
matters
very
very
seriously.
A
A
We're
going
to
have
zoom
breakout
rooms
as
well,
so
to
hopefully
give
a
little
bit
of
the
in-person
meetup
experience
if
you
want
to
you're
not
obligated
to,
but
if
you
would
like
to,
we
will
break
you
out
into
two
different
rooms
where
you
can
get
to
know.
Fellow
attendees
talk
about
the
talks.
Talk
about
whatever
you
choose
to.
We
also
have
a
matrix
chat,
so
you
can
find
the
instructions
for
joining
that
inside
of
the
meetup
org
instructions
for
the
Meetup
and
please
feel
free
to
at
any
time
in
any
of
the
chats
type.
C
A
Yeah
this
is
Maura.
This
is
my
part
really.
We
are
always
in
continually
looking
for
new
speakers
and
really
what
that
means
is
that
we
want
you
and
yes,
that
means
you.
It
doesn't
matter
if
you
think
your
idea
is
not
very
good
trust
us.
It
is
we're
happy
to
work
with
you
on
your
talk.
Just
let
us
know
if
you
have
anything
that
you
might
be
interested
in
telling
anybody
else
about,
and
we
will
help
you
get
your
your
talk,
ready
to
go
for
one
of
our
next
meet.
C
The
shout
out
to
our
M
co-sponsor
co-host,
which
can't
be
here
today,
but
young
Eric
M,
helped
us
in
the
past
them
to
set
up
the
whole
thing
to
go
and
he
guided
us
and,
through
the
whole
I'm
going
from
offline
to
online.
So
thank
you
very
much.
It
wouldn't
be
possible
without
him,
and
also
a
little
M
shout
out
to
an
online
conference
in
Poland,
which
is
called
the
rusty
days.
It
will
happen
from
the
27th
of
July
until
the
2nd
of
August.
It's
am
7
days,
7
talks
and
the
hackathon
during
the
weekend.
C
A
Alright,
so
we
have
three
talks
today.
The
first
one
by
Maxime
will
be
on
rusty
beads.
So
that
will
be
interesting
to
learn
what
that
is,
then
the
next
one
by
Mike
on
transit
radar
and
the
last
one
will
be
by
Zi
Shan,
who
will
be
catching
us
up
on
on
Zee
bus,
which
we've
heard
about
in
the
past,
at
unrest,
Intel
and
we'll
learn
more
about
the
progress
of
that
project.
B
A
B
Probably
you
can
okay
great
so
right,
so
my
name
is
Maxine.
You
can
find
me
on
github
at
anzacs
and
I
would
like
to
talk
about
a
product
of
mine
which
I
was
building
in
it.
It's
called
rusty,
beads,
it's
a
simple
binary
data,
serialization
format,
and
the
question
is
why
why
did
I
do
this
and
generally,
first
of
all
for
sports,
so
I
don't
use
it
in
production.
B
I
use
our
different,
that
is
binary
data
serialization
formats
in
production,
I'm
also
a
committed
to
flatbuffers
project
by
Google
and
I
have
some
experience
in
porting
different
detalization
formats.
So
at
some
point,
I
decided.
Why
not
invent
your
own
and
then
implement
in
a
language
which
you
like,
and
this
is
basically
rust,
was
second
reason
why
I've
built
rest
bits
is
simplicity.
If
you
have
used
some
binary
situation
formats,
they
are
normally
kind
of
trying
to
solve
a
very
big
problem.
B
So
you
have
some
kind
of
object
tree
which
needs
to
be
civilized,
but
actually
I
haven't
found
any
sedation
formats,
which
just
does
citizen
of
sequence
of
values,
just
sequence
of
values.
So,
for
example,
I
have
a
sequence
of
strings
and
I
would
like
to
serialize
them
now
the
complex
object,
3
and
so
on,
and
so
forth,
just
a
sequence
or
a
sequence
of
numbers,
and
so
on
and
so
forth.
B
So
with
beads
I'm,
focusing
on
the
simple
problem
just
being
able
to
serialize
a
sequence
of
something
and
for
this
I
have
three
type
of
beats,
so
I
call
this
kind
of
sequences
beats.
So
it's
I
was
inspired
by
a
video
set
where
you
have
like
small
things
and
connected
together
and
for
me
every
value
is
one
beat
you
know
so
here,
I
have
three
options:
I
have
fixed
size,
big
bits,
I
have
index,
speed
and
I
have
typed
beats.
So,
let's
start
with
fixed
size,
beats
and
I.
B
Think
a
unit
tail
test
tells
more
than
300
slides,
so
I
will
just
start
with
with
a
unit
test
and
walk
you
through
what
it
does
and
explain
as
well
what
precipitation
contest
so
in
the
beginning
of
this
unit,
test
I
am
creating
a
builder
and
I
say:
I
create
a
fixed
sized
bits,
build
up
or
even
constant
free.
It
means
that
every
name
says
it
is
a
fixed,
fixed
size
beads.
So
every
bead
is
of
fixed
size.
B
Size
for
me,
is
I'm.
Sorry
format
size
for
me
is
the
number
of
bytes,
so
I
can
push
slice
which
have
three
bytes
in
it.
So
you
can
see
here,
I'm
pushing
free,
sorry
for
free
byte
slices.
Then
I
can
encode
it
and
then
I
see
I
have
this
nice
buffer,
but
buffets
itself
is
very
simple,
so
the
first
byte
is
number
of
the
size
of
six
beads,
and
then
you
see
I'm,
just
concatenating
all
the
slices
to
each
other.
B
In
order
to
read
this
I
have
a
different
struct,
which
I
called
a
fixed
size,
bead
and
then
instantiating
it
just
with
a
borrowed
Bubba,
so
quick
slice
and
important
same
with
beads.
What
was
important
for
me
is
basically
that
everything
is
a
zero
copy
abstraction.
So
when
I'm
instantiate
in
this
thing,
I'm
really
not
doing
much
I'm,
just
basically
borrowing
a
splice,
and
this
is
basically
it
then
I
have
this
function
length,
because
it's
a
sequence
I
would
like
to
know.
B
How
long
is
the
sequence
and
I'm
directly
tells
me,
for
how
does
the
do
it
well
internally?
I
know
that
my
bead
is
free.
Bytes
long
and
I
know
that
my
data
is
12
bytes
own,
so
12
divided
by
3,
is
4
very
simple.
You
can
directly
basically
concatenate
slices
together
and
have
something
and
then
you
can
also
directly
index
into
the
bead.
If
itself
saying
give
me
a
bead
on
index,
0
1,
2,
&,
3
and,
as
you
can
see
like
actually
here,
I
do
a
copy,
but
it's
not
necessary.
B
What
I
get
here
is
a
slice
and
I
would
like
to
convert
it
into
a
vector
just
to
have
a
nice
assertion.
Actually,
ok,
so
this
is
kind
of
interesting,
but
it's
also
kind
of
limiting,
normally
I,
don't
have
like
fixed
sized
slices,
see
I
would
like
to
put
somewhere
in
order
to
serialize
them
right.
So,
but
one
idea
on
this
idea,
I
can
do
something
Krita,
let's
say
nice
abstraction,
so
for
this
abstractions
I
create
a
different
builder
and
I.
Call
that
fixed
size
beats
incremental.
B
B
B
Now
340
can't
be
seated
in
one
bite,
it
has
to
be
represented
in
two
bytes
and,
as
you
can
see,
when
I
encode
this
buffer
and
code,
this
builder
into
this
buffer
when
I
see
that
the
size
is
2
of
each
bead
and
now
I
also
see
the
number
representation
in
two
whites
and
it's
in
little-endian
representation.
So
1
is
1.
0
2
is
2,
0
20s
2002
hundred
five
is
2005.
Zero
and
340
is
84
and
1.
B
And
so,
for
example,
in
embedded
system,
you
have
some
kind
of
sensor
which
gets
some
kind
of
a
values
you
could
use
beads
to
actually
just
concatenate
and
uncreate,
a
binary
stream
to
serialize
store
sandoval
over
wire
and
ok,
let's
switch
to
ver
index
beads.
This
is
the
second
type
of
beads
that
I
have
in
this
library
and
we'll
come
back
to
fixed
size
beads
later
alright.
So,
first
of
all,
what
does
index
beads
solve
what
kind
of
a
problem
with
fixed
sized
beads?
B
My
slices
can
be
only
of
a
fixed
size
of
a
fixed
size
right,
but
what
if
I
would
like
to
I
know?
I
have
like
different
sized
things.
For
example,
strings
strings
are
normally
have
different
lengths
and
what
can
I
do
there?
So,
with
index
beats?
What
I
can
do
is
again.
I
can
push
slices,
but
now
it
doesn't
I,
don't
provide
the
size
from
your
beginning.
B
I
just
push
different
slices
and
then
I
have
I,
have
a
possibility
to
read
my
beads
out
and
civil
length
as
well
and
then
also
directly
index
and
get
exactly
of
size
of
the
slaves.
So
exactly
the
bytes,
which
I
see
realized
all
right.
So
how
does
it
work
internally
so
kind
of?
How
is
sausage
made
right?
So
in
a
way
here
we
say
again,
we
initially
initialized
by
index
bits
builder.
B
We
push
one
two
three
four
and
then
we
just
directly
encode
it,
and
we
see
here
now
we
see
this
is
one
two
three
four
and
we
see
another
two
bytes
which
are
kind
of
like
a
magic
header
which
tells
the
reader
how
to
read
the
stream.
If
I
would
push
another
slice
this
one
with
eleven
bytes,
then
this
is
my
result
which
I
get
so
you
can
see
here
again.
This
is
the
first
slice.
B
This
is
the
second
slice
and
now
I
see
here
it's
four
and
fifteen
and
when
I
have
here
an
album
magic
number,
which
I
will
talk
about
in
a
second
basically
regarding
foreign
hand,
15.
What
I'm
doing
here
is
basically
I'm
saying
this
is
well
when
I'm,
adding
the
first
sequence,
it's
off
link
for
so
I
say
like
okay,
first
sequence
and
@pytfall
when
I
add
another
sequence
of
length
11.
The
second
sequence
ends
at
byte
15.
This
is
how
I,
later
in
the
Builder,
can
read
the
slices
with
zero
copy
and
directly
for
comparisons.
B
We
have
this
fixed
size,
beads,
which
structured
very
simply
like
the
first.
Let's
call
it
sequence
of
bytes
represents
for
element
size.
So
how
big
are
my
beads
right
and
then
we
have
like
multiple
beads,
which
we
add
to
the
sequence,
by
pushing
them
to
the
Billa
with
an
index
bits
we
have
slightly
more
complex,
shall
we
say
like
okay,
we
have
this
header,
which
is
an
element.
Count
word
with
offset
size
in
bytes,
and
here
is
a.
B
Small
snippet,
which
actually
kind
of
like,
represents
how
these
things
work.
So
builders
contains
all
the
elements
which
we
pushed
so
all
slices
which
we
push.
So
we
were.
This
represents
one
number
of
elements
which
we
added
to
the
sequence
and
we
shifted
by
free
and
when
we
all
it
with
a
bite,
spell
index
entry,
minus
1,
so
bytes
by
a
index
entry,
as
I
explained
to
you
before
in
here,
I
need
to
store
at
which
byte
does
the
element
end
and
the
problem
is
in
the
beginning.
B
Last
but
not
least,
what
type
beads
this
is
sequence,
where
we
store
values
and
the
type
information
before
they
had
in
perform
at
we
just
said
like
ok,
we
stop
storing
the
values
and
for
us
it
just
slices.
So
it's
just
some
kind
of
a
bytes.
Sometimes
it's
free
byte
sentences.
Why
I
buy
it?
Sometimes
it's
7
bytes,
but
I,
don't
really
know
what
exactly
they
mean.
B
They
could
mean
numbers,
they
could
mean
strings,
they
could
even
mean
some
civilized
fixed-sized
struct,
for
example,
but
here
in
tight
beats
I
we
can
define
a
sequence
and
tell
like
what
kind
of
type
we
actually
store
in
the
six
in
this
sequence
per
type.
What
kind
of
types
do
we
have
in
that
beats?
We
have
nine
for
basically
no
value
at
all.
We
have
a
true
flag,
false
flag.
We
have
unsigned
integers
from
eight
bits
to
128
bits.
We
have
signed
integers
from
8
to
128.
We
have
floating
numbers
from
16
to
64.
B
Quantity
and
we
have
variable
quantity
with
zigzag,
then
for
Strings
we
have
utf-8
and
for
some
kind
of
a
civilized
data.
We
also
have
bytes
so
in
to
see
it
like
following
in
the
previous
sequences,
we
just
have
head
bytes
and
now
we
can
actually
annotate
with
different
primitive
types.
You
know,
but
again,
all
these
types
are
still
simple:
they
are
not
complex,
so
I
don't
have
maps
or
another
sequence,
as
some
other
formats
actually
have
so
example:
sequence
of
Baux
values
or
a
bit
set.
If
you
will
so
what
do
I
do
again.
B
B
Then
I
just
pull
push
12
billion
values,
true
true,
false,
true,
false,
false,
false
and
so
on
and
so
forth,
and
at
the
end,
I
say
like
okay,
builder
and
code
into
one
out
letter,
and
this
is
what
I
get
as
a
result.
We've
tagged,
beads
I,
have
here
the
number
of
elements
and
in
these
two
bytes
I
encoded
all
12
values.
B
B
Alright,
so
the
structure
of
type
beats
is
as
following.
We
had
this
element
count
in
the
beginning,
as
I
explained
before,
and
then
we
have
one
bite
of
type
information
and
then
multiple
type
bites
which
represent
the
values
themself.
So
now,
for
example,
in
case
of
boolean
as
true
value
and
false
value
are
represented
as
flags
we,
actually
we
don't
have
values
at
all.
We
just
have
the
type
information,
and
this
is
it.
B
This
is
also
how
it
is
possible
to
store
twelve
value
or
actually
up
to
sixteen
values
in
two
bytes,
so
I'm
getting
a
little
bit
ahead
of
myself,
how
many
type
in
four
values
per
byte
can
we
have,
and
it
depends
so,
as
you
saw
before
when
I'm
instance,
taking
the
builder
I,
tell
it,
which
kind
of
types
I
would
like
this
bill
that
to
accept.
If
the
number
of
types
is
smaller
or
equal
to,
then
type
information
can
be
represented
in
one
bit.
So
I
can
store
eight
elements
per
byte
just
of
attack
information.
B
If
it's
small
equals
four,
then
I
need
two
deeds
to
represent
the
type
information
and
therefore,
in
one
bite,
I
can
store
four
elements
in
incase.
If
I
have
less
than
sixteen,
then
it
will
be
stored
in
four
bits
and
I
will
represent
the
type
information
of
two
of
two
elements
in
one
bite
in
comparison.
B
If
you
are
familiar
with
message
pack
or
sibour,
they
all
represent
that
information
as
well
similar
to
beats,
but
they
do
it
in
one
bite
where
in
this
case,
dependent
on
how
many
types
we
pre-configured
the
builder
to
be,
it
will
be
much
more
dense.
So
we
have
like
that
a
bit
pecking
strategy
in
a
way
again,
with
cases
with
message
back
and
seaboard,
it
is
a
little
bit
different
because
they
also
store
complex
types
and
therefore
it
would
be
a
little
bit
more
complicated
to
do
to
pack
them.
B
Better,
but
this
is
also
why
I
talked
in
in
the
beginning.
If
you
have
a
simpler
problem,
you
can
wish
you
trying
to
solve
the
and
the
solution
can
be
also
simpler
and
much
more
optimized,
okay,
so
here's
an
example
where
I
would
like
to
push
so
but
times
which
I
have
in
the
Builder.
Are
you
ate
so
unsigned
integer,
which
is
just
one
bite
and
bit
type?
None
right,
then
I'm
pushing
20
I'm,
pushing
none
I
am
pushing
21
and
I'm
pushing
22.
B
Now,
when
I
encode
I
see
that
I
have
four
values:
encoded
13
is
my
type
information
and
then
I
have
just
four
values:
20
21
22.
As
you
can
see,
this
none
should
be
theoretically
here
and
in
most
other
civilization
formats.
It's
actually
also
like
represented
as
one
byte,
but
in
case
of
beads.
It's
just
absent.
B
Will
the
type
information,
so
we
know
which
types
are
actually
represented
in
sequence:
okay,
slightly
different
example:
now
the
types
are
you
eight
and
you
16
and
I'm
pushing
three
numbers:
I
pushed
28
I
pushed
261
and
I
push
22
again:
I
have
three
values
and
now
I'm.
Actually
you
can
see
that
this
is
the
type
information
and
you
can
see
like
I
store
20.
Only
in
one
bite,
I
saw
261
in
two
bytes,
because
I
physically
can't
store
it
in
one
bite
and
when
I
thought
22
in
just
one
bite.
B
Basically,
when
you
have
different
types
in
the
Builder
and
you
push
values,
the
builder
will
check
what
is
the
smallest,
appropriate
way
of
representing
this
value.
So
we
could
also
represent
20
with
two
bytes.
It
would
be
when
20
and
0,
but
it's
not
the
most
compact
ways
and
we
have
this
u8
declared.
B
This
is
lots
of
code
here.
I
just
have
strings
which
I
concatenate
and
it's
basically
with
the
same
stuff.
I
have
Maxime
I
push
Maxime
to
the
Builder
and,
like
way
interesting
part
I
just
wanted
to
tell
you
how
strings
has
utilized
strings
as
she
realizes
utf-8
buffa
prepared
it
with
the
size
of
the
string.
So
in
case
of
how
many
bytes
this
string
actually
takes
right.
So
in
case
of
Maxime,
it's
5
in
case
of
hello,
it's
actually
10
bytes
in
case
of
man.
B
Nothing
changes
the
only
thing
which
changes
is
we
say
like
here.
We
had
two
elements.
Now
we
have
three
elements.
Everything
else
is
equal
and
case
of
aha.
We
have
four
elements,
and
this
is
utf-8
representation
of
four
bytes
for
aha
exclamation
marks
all
right
round
tip.
How
does
it
look
if
you
would
like
to
not
only
serialize,
but
also
with
data
out
of
that
bits?
So
here
you
can
see
that
I'm
defining
the
types
it
suit
a
frickin
month,
then
I
create
a
builder
and
I.
Have
here
a
string,
hello,
my
name
is
Maxime.
B
B
So
this
is
important,
because
we,
when
we
just
encode,
we
don't
encode
net
information
about
other
types
of
the
sequence.
It
is
fine
if
you
are
creator
and
work
consumer
or
you
have
some
kind
of
hard
definition
of
the
schema.
You
know
that
this
buffer
will
only
contain
strings
and
maybe
some
non
values
right.
So
you
know
how
to
read
this
stuff
and
the
problem
here
of
type
beats
again.
As
I
said,
everything
is
zero
copy.
Everything
is
lazy,
so
what
it
does.
B
The
whole
three
object
for
you,
and
if
it's
a
big
one,
then
you
have
like
a
very
large
initial
cost.
With
Beats
we
can
actually
lazily
go
and
just
extract
values
as
we
go.
We
don't
have
this
big
penalty.
In
the
beginning,
we
just
can't
get
an
iterate
and
just
iterate
over
all
the
values.
In
the
sequence,
it's
an
iterator,
so
map
collect
works
and
all
the
other
stuff
that
you
know
from
standard
library
which
kind
of
work
with
iterative
work
with
beads
then
as
well.
B
One
more
difference
and
here's
basically
I
just
wanted
to
showcase
that
you
can
encode
with
types
and
in
this
case
where
you
can
initialize
without
beads,
with
new
types
included,
and
now
we
just
have
to
provide
the
slice
itself,
not
very
information
about
the
types
because
of
information
about
the
types
is
already
encoded
in
the
buffer
itself.
Everything
else
works
the
same
okay.
So
what
about
type
beats
and
indexing
so
like
Jim,.
A
B
B
So,
for
example,
here
we
have
a
sequence
of
names,
all
right,
Maxim
Alex,
video
Maxim
magazine,
and
then
we
would
like
to
compact
it
somehow
and
the
simplest
way
of
compacting.
It
is
saying
like
okay
I
would
like
to
do
duplicate
values
because
I
see
like
who
Maxim
is
appearing
three
times,
so
how
I
can
do
it?
I
make
a
sequence
of
sequences
where
the
first
sequence
is
index
of
value
and
the
second
sequence
of
values
themselves,
and
here
actually
we
would
save
already
five.
B
B
So
we
have
indexed
bits
with
fixed
size,
beads
and
it
is
bit
doesn't
matter
I
end
I
would
like
to
show
you
so
I
as
I
say,
I
said
I'm
doing
it
for
sports,
so
I
try
to
transform
CSV
files
into
bits
to
see
how
much
gain
can
I
get,
and
here
is
an
example
of
a
typical
CSV
file,
where
it's
statistics
of
crime
in
a
US
state,
I.
Think-
and
you
can
see
we
have
here
and
a
time
address:
district
beatgrid,
a
crime,
description
and
other
stuff.
B
So,
basically,
for
this
I
can
transform
this
file
into
a
misrepresentation
and
for
this
I,
basically
defined
which
column
should
be
represented.
How
so
I
say
first
column
should
be
duplicated
utf-8
because,
as
you
can
see
here,
we
have
lots
of
the
application
in
this.
In
this
first
column,
it's
all
strings
and
we
also
pretty
much
duplicated.
B
B
So
basically
one
we
could
reduce
the
file
by
one
third
and
we
still
keep
the
same
data
and
it's
actually
a
little
bit
better
represented
because
we've
CSV,
we
can't
have
direct
in
this
indexing
into
the
columns.
It
needs
to
be
parsed
first,
but
with
beads.
The
structure
is
in
a
way
where
I
can
just
say
like
okay,
give
me
the
column,
free
and
then
I
will
just
go
through
boroughs
in
country.
C
C
B
B
C
D
Him
yeah
hi
everyone,
I'm
Mike,
so
we're
gonna
talk
today
about
transit
radar,
so
if
I
am
on
screen
so
yeah,
firstly,
just
a
little
quickly
about
me.
I've
worked
mostly
in
application
backends,
so
in
different
things
for
data
processing
and
backends
for
web
applications.
I'm
really
interested
now
when
working
using
rust,
especially
on
web-based
tools,
especially
ones
that
get
ax
use
usable
data
as
well
a
few
times
over
the
last
few
years,
I
was
trying
to
learn
rust,
but
each
time
I
think
I've
tried
to
use
it.
D
The
things
that
I
couldn't
do
with
the
other
languages
that
I've
always
worked
with
and
so
I'd
be
trying
to
do
systems
programming
things
which
is
not
my
background,
so
here
I
decided
instead
I
should
learn
it
by
doing
an
application
making
an
application.
So
the
idea
for
the
application
that
came
from
looking
at
looking
in
transit
maps
so
like
this
is
the
s1
and
I
find
I,
find
other
transit
maps
quite
interesting.
D
It's
like
at
all,
that's
over
a
hundred
years
old
and
at
the
time
the
technology
you
needed
to
use
for
this
was
like
painting
it
on
the
wall.
About
a
train
station
nowadays,
nowadays,
we
have
all
this
computation
power
in
everyone's
pockets
and
instead,
so
instead
of
the
we
solve
this
problem
of
providing
a
tool
to
send
to
this
route
across
the
city.
D
They
start
out
points
destination
to
your
search,
so
we
have
so
here
and
sports
respond
station
and
based
on
the
based
on
the
routes
available.
It
now
shows
you
everywhere
that
you
could
get
to
within
30
minutes,
and
you
know
map
format.
So
each
of
these
there
are
three
rings
here,
and
each
of
them
is
ten
minutes
away
from
us
quite
at
the
center
of
the
map
and
it's
updating
in
real
time
based
on
their
based
on
timetables.
D
D
So
the
the
dotted
lines
here
represents
waiting
times
and
transfers
and
the
solid
lines
are
the
trips
with
trends.
The
the
angles
are
actually
the
compass
angle
to
the
stops.
So
you
do
get
geographical
features
which
are
not
just
about
the
distance
traveled,
and
so
you
can
see
the
s
s42,
curving
anti-clockwise
up
to
the
north
and
the
s41
combing
clockwise
down
to
the
south
and
east
west
lines
going
in
that
direction
spot,
and
so
this
has
been
like.
D
This
has
been
quite
a
big
project,
but
quite
a
lot
of
time
into
it
and
use
it
as
something
which
I
can
do
a
lot
of
experimentation
with
and
trying
out
techniques
and
technologies.
That
I
was
interested
in
working
on.
So
we
can
have
a
look
at
the
yeah,
so
I
can't
I
can't
go
through
I
can't
go
over
it
like
that.
Much
of
the
much
of
the
project
today
but
I
will
give
them
over
to
you
first
of
all,
and
so
the
high-level
components.
D
These
are
the
most
sort
of
important
as
highlight
components,
and
it's
it's
false
back
rust.
So
it's
both
the
server
and
client
components
both
of
us
and
the
it's.
It's
not
an
interactive
program.
Really
apart
from
the
only
interactive
component,
is
that
you
can
also
choose
you.
Can
you
can
choose
where
you
know?
Your
start
point
is,
and
you
can
also
change
the
transform
works
that
you
have
to
search
with.
D
So
here
the
date
was
all
data
flow
of
these
components
goes
from
left
to
right
and
they
originate.
The
data
originates
in
general
transit
feed
specification
files,
that's
published
on
sort
of
a
week,
roughly
weekly
basis
by
the
BBB,
and
those
are
present
property
available
and
they're
in
CSV
format.
So
just
the
first
part
is
passing
most
funds.
A
D
Possible
and
those
two
components:
the
lookup
data
structures
and
the
algorithm
both
run
on
both
the
server
and
plan.
So
exactly
the
same
code
gets
to
kiss
p1
and
I.
Think
there's
one
of
the
things
that
I
find
interesting
about
being
able
to
do
this
with
rust.
That's
that
the
being
able
to
share
this
this
code,
and
especially
when
it's
quite
at
a
complex
algorithm.
D
That's
some
of
them
some
of
the
server-side
data,
which
is
quite
a
bit
of
and
transferring
its
to
the
clams
when
it
needs
it
and
I'll
talk
a
bit
more
about
that
in
the
moment
and
then
in
the
front
ends
of
the
in
the
front
end
of
the
application.
There
is
the
various
seat
components
and
including
the
autocomplete
box
and
the
other
controls,
and
then
the
practical
part
of
the
display
is
working
using
them
using
an
HTML
campus,
which
also
provides
and
is
also
doing
animation.
D
So
the
the
synchronization
component
and
I
think
is
one
of
the
two
parts
that
I
want
to
zoom
in
all
of
it
today.
The
main
tere
is
that
the
when,
when
the
user
changes
the
control
in
ads,
there's
that
produces
a
query
and
we
run
that
we
send
that
query.
We
run
that
query
using
the
algorithm
on
the
on
the
data
sets
and
both
the
client
and
the
server
at
the
same
time
or
on
the
clients
waiting
for
because
it
can
run
instantaneously.
D
So,
on
the
client
side,
the
algorithm
is
running
against
the
data
and
producing
the
tree
results
and
that
trade
results
means
that
is
then,
is
then
rendered
on
to
the
canvas,
as
you
can
see
the
and
it's
it's
running
the
algorithm
and
against
the
living
to
the
updates.
That's
on
the
client
currently
and
query.
There
is
also
run
against
the
data
on
the
server
and
instead
of
producing
a
result,
we
produce
the
IDS
after
the
records
that
will
need
it
in
order
for
the
algorithm
to
complete
run
and
from
from
that
required
data.
D
I
then
subtract.
The
data
is
currently
available
to
the
client,
which
is
thought
in
that
session,
variable
to
find
the
missing
data
and
then
the
missing
data
is
the
data.
That's
the
claim
that
the
client
should
have
used
to
produce
its
results,
and
but
because
it
didn't
have
it,
it
was
unable
to
produce
it
and
clean
result.
D
D
D
It
gets
provided
with
the
full
data
set
from
the
of
the
trans
information,
a
reference
to
that
stop
that
the
weather
search
is
originating
from,
and
then
the
moment
I
said
parameters
and
we
constructing
an
instance
of
the
algorithm
bra,
which
is
this
journey
graph
button
and
then
adding
the
other
parameters
to
it.
And
then,
at
this
point
on
the
client,
it
would
be
asking
for
the
results
of
the
search,
but
on
the
server
side,
we're
asking
for
this
sort
of
data,
and
that's
that's
looping,
because
it's
an
iterative
algorithm.
D
So
this
is
is
running
the
iterative
iterations
of
the
algorithm
and
when
we
get
II
and
the
results
that
we
get
from
each
iteration
as
q
items-
and
we
don't
care
about
most
of
the
parameters
of
it
there,
because
all
we're
doing
is
we
just
want
to
know
which
stock
was
it
going
to
be?
Parents
of
that
start
and
which
trip
wasn't
using
if
it
is
usable
if
it
is
using
a
trip
so
and
those
each
of
those
their
stops
and
the
trip
get
recorded
in
this
required
data
object.
D
The
this
is
the
this
is
before
the
function,
which
is
calling
the
function
above
that
I'll
show
you
which
gets
that
required
data.
So
this
is
running
doing
the
running
running
query
on
back-end
in
order
to
find
the
data
that's
needed
for
those
needed
in
order
to
to
perform
this
run,
and
here
we
also
have
a
handle
on
a
session.
D
So
the
session
is
a
meet
X,
so
it's
something
that
we
can
learn
lock
and
get
mutable
access
to
and
the
once.
We
have
access
to
the
session
then-
and
we
have
also
the
IDs
of
the
data
that's
required
to
run
to
make
do
this
run
this
add
data
function.
The
purpose
of
this
to
both
ad
is
to
produce
the
date
of
the
new
data
that
needs
to
be
serialized
from
central
clients
and
also
updates
the
session
with
the
data
that,
with
rookie's
to
the
data
that
the
client
will
now
have.
D
D
Let
me
taste
the
session
and
we
have
access
to
the
default
data
source,
which
is
read-only,
and
we
also
have
the
IDS
that
we
need
to
know
the
client
needs,
and
so,
if
it
is
a
new
session,
then
we
know
we
just
need
to
get
all
the
trips
and
the
stops
that
were
referred
to
in
this
required
data
with
these
IDs
and
we
create
any.
We
also
add
them
with
we
record
those
in
the
session
and
we
then
send
them
full
data.
D
Initial
data
load
with
the
newly
generated
session
ID
and
the
full
set
of
data
or
a
partial
set
of
data,
but
using
at
all
and
data
structure.
And
if
it's
some
old
session,
then
instead
we
will
do
use,
retain
to
filter
out
filter
out
the
trips
and
the
spots
that
were
already
had
and
just
then
get
the
send
the
new
trips
and
the
new
stocks
and
the
other
parts.
They
are.
The
same
then
lowered.
Look
at
on
the
drunken
part
of
the
synchronization.
D
So
we
have
a
real
estate
objects,
enum,
Jeremy
or
stadium,
which
is
either
not
synchronized.
So
we
don't
have.
The
client
doesn't
have
any
information
from
the
server
or
we
have
a
scene
or
we
are
synchronized,
in
which
case
we
should
have
data
and
the
monthly
account
90
and
the
update
function
is
an
important
part
of
is
typical
part
of
the
seed
application,
which
I
can
talk
a
bit
more
about
later.
D
So,
for
instance,
here
fetch
data
is
telling
it
that
the
query
that
the
result
on
the
client
sort
has
been
invalidated
somehow,
and
so
we
need
to
perform
a
synchronization
with
the
server
and
the
data
fetched
is
called
when
we
get
a
response
from
the
server,
and
at
this
point
we
call
this
receive
function
on
the
model.
So
the
model
is
is
the
is
on
the
client
side.
It's
this
representation
of
the
synchronize
data
and
so
recordings
received
with
the
new
data.
D
That's
been
sent
from
the
client,
something
from
the
server
see
what
data
model
and,
if
the,
if
we
receive
an
initial
sync
data
that
could
be,
that
is
usually
that
would
be.
That
is
the
first
one
in
the
session,
or
it
could
be
that
we
validated
this
in
session
somehow,
which
I
haven't
tried
to
fix
in
many
clever
ways.
Really,
so
it's
just
if
the
session
games.
This
has
something
going
wrong
with
it.
D
Then
we
just
reset
it
with
an
initial
sync
data,
and
with
that
we
can
just
set
the
we
can
just
set
the
sink
status.
This
model
item
to
a
a
new
synced
model
with
that
information,
and
if
it's
an
increment,
then
we
need
to
add
the
update.
The
update
counts,
which
is
how
we
check
to
see
whether
the
session
is
still
valid
and
we
add
the
increment
into
the
existing
data.
D
So
unless
so
in
this
part,
I
used
the
a
design
traits
so
that
this,
this
module
is
kind
of
generic
over
the
types
of
things
things
that
it
can
work
with.
So
it
gives
some
kind
of
dish
which
can
be
added
into
the
core
data,
and
that
is
then
just
adding
adding
those
records
into
clients,
data
centers.
D
D
D
Like
okay,
so
yeah
so
see
a
seed
application
runs
on
a
raw
straight
type
called
cdy
lib,
which
is
a
c
type
dynamic
library.
And
then
we
have
these
blue
components
which
all
built
by
the
rusts
web
working
good.
So
what's
behind
Jenner's,
then
there
is
the
base
of
that
which
actually
has
the
bindings
between
JavaScript
functions
and
Trust
functions.
So
they
even
call
both
ways
and
from
Brussels
to
JavaScript
and
vice
president
and
wasn't
pack
is
a
crate.
D
So
he's
a
cargo
task
which
packages
up
wasn't
managing
projects
into
wasn't
file
a
JavaScript
file
with
all
this
bindings
and
that
you
can
then
use
and
Jas.
This
is,
is
the
JavaScript
language
bindings,
so
you
can
call
into
string,
functions
and
functions
on
dates
and
all
this
kind
of
stuff
is
all
written
into
Genesis
so
that
you
don't
need
to
make
your
own
buttons.
D
When
the
update
function
is
the
only
one,
that's
mutating
the
model,
and
it's
doing
that
based
on
messages
that
it
receives
and
the
view
function
is
responsible
for
writing,
creating
the
event
listeners
in
the
Dom,
which
then
produce
the
events
of
messages
which
work
which
caused
the
update
function
to
mutate
and
model.
So
this
is
based
on
the
Elm
architecture
it
now
it
will
be
different
because
it's
an
immutable
architecture
and
in
rust
this
works
better
with
the
company
function,
mutating
Ashley,
mutating.
D
D
Think
is
a
good
idea
and
I
think
it's
fights
and
I
think
it's
gonna,
be
it's
something
I'm
pretty
excited
about
and
I
think
the
it's
good
for
sharing
these
complex
data
structures
and
algorithms,
and
between
the
backend
and
the
front-end,
so
that
we
can
do
this
planet,
reactive
applications
that
are
very
feature-rich
and
accessing
lots
of
data
and
the
tooling
the
rust
all
of
tool
sets
and
as
well
as
the
normal
one
as
well
as
the
web.
One
they
work
together.
D
D
C
Thank
you
so
much
Mike
I
before
mov
up
one
question
in
the
zoom
chat,
but
I
have
a
question
right
away.
M.
Is
there
the
code
like
Emma?
Do
you
have
a
github
repository
and
Emma?
Do
you
plan
to
write
this
up
in
some
form
of
blog
post,
serious
I
feel
like
that's
quite
a
bit
of
content
here
like
it
would
be
nice
to
read
up
in
our
own
time,
yeah.
D
I
I
would
like
to
do
that
and
I
had
actually
intended
to
do
that.
One
sorry
when
I
first
started
working
on
this
project,
and
but
I
am
you
know,
it's
like
I
haven't
really
given
presentations
before
when
they
haven't
before.
So
it's
still
something
and
trying
to
do
but
I
think
it's
I
am
definitely
interested
in
doing
that.
They
haven't
posted
the
code.
I
haven't
published
the
code,
but
it's
is
also
something
that
I
would
be
interested
in
doing
as
well.
D
I
know,
I've
done
this
in
a
very
experimental
wet,
so
I
feel
like
I
was
able
to
try
out
a
lot
of
things
because
I
didn't
feel
I
didn't
feel
like
anyone's
going
to
be
looking
at
it,
but
and
definitely
are
definitely
interested
in
what
people
would
like
to
see
or
and
hear
about
his
projects
and
I
will
try
and
write
some
things
up.
Yeah
cool.
C
Thanks
and
we
have
one
question
in
the
zoom
chat
which
is
didn't
get
if
the
client
was
a
local
process
written
in
rust,
which
exposes
a
web
UI
for
the
browser
or
if
it
was
some
other
trick
blossom
like
was
it
written
and
I
hope
would
get
the
question
right?
Can
you
see
the
question
yourself,
so
it's
Johannes
didn't
quite
get
if
the
client
was
a
local
process
written
in
rust
and
then
the
web
UI
exit
was
exposed
for
the
browser
or
if
it
was
written
in
Boston
Morrison.
The.
D
D
C
Think
it
does
yeah,
it
does
perfect.
Thank
you
so
much.
Okay,
another
great
talk.
Now
we
have
our
ten
minute
break
until
5:00,
so
a
time
2025
or
8:25
Emma.
We
are
back
here
we
break
out
now
and
we
have
20
participants
and
soon
we
can
have
four
breakout
rooms
with
four
to
five
participants,
so
I'm
feel
free
to
chat.
If
you
don't
want
to
chat,
you
don't
have
to
join
and
we
see
us
back
in
ten
minutes
have
fun.