►
From YouTube: 2019-02-28 Rust and WebAssembly Working Group Meeting
Description
A
Welcome
to
another
rusts
and
webassembly
meeting
working
group
meeting
so
first
on
the
list
is
RFC
triage,
and
so
we
still
have
two
proposed
for
FCP.
Rfc's
final
comment
period
request
for
comments,
and
so
those
are
the
2019
roadmap
and
the
NPM
packages,
and
then
we
also
have
one
that
actually
made
it
to
FCP.
A
B
So
one
I
guess
come
up
in
bundles,
actually
so
I
there's
a
sample
implementation
of
the
gia
snippets.
The
current
design
act
and
I
was
a
change
before
we
actually
merge
it.
But
if
you're
curious
to
try
it
out
see
what
it
looks
like
play
around
with
it.
It's
sitting
there
as
a
pull
request,
and
apart
from
that
I
think,
there's.
A
A
A
The
output
stuff,
which
is
kind
of
a
continuation
of
some
of
the
things
we
talked
about
at
the
Russell
hands,
which
was
basically
trying
to
to
migrate
as
impact
to
this
kind
of
ideal
future
around
its
output,
both
around
like
kind
of
graceful
degradation
in
the
face
of
like
bulbs
or
less
feature
full
terminals
that
don't
support
emojis
or
spinners.
And
things
like
that,
as
well
as
just
kind
of
like
being
deliberate
and
conscious
about
like
what
we
print
and
whether
we
print
a
given
message
or
not.
Essentially,.
B
C
B
A
Word
so
the
the
one
thing
I've
been
thinking
about
in
terms
of
like
a
larger
milestone
for
for
our
dock
stuff.
Well,
I
guess:
there's
there's
two
things
I'll
get
to
the
other.
One
once
again
would
be
for
the
game
of
life
tutorial
to
be
a
bit
more
stripped-down
and
basic,
and
since
that
right
now
it
is
doing
the
whole
like
webpack
integration
and.
A
A
That
just
needs
like
some
more
I,
think
what
at
least
before
landing
is
like
a
little
bit
more
like
here's
like
random
links
and
a
little
more
like
here's.
What
these
links
are
and
why
you
want
to
follow
this
link
instead
of
that
other
link.
So
if
you're
interested
in
taking
over
that
as
well,
okay,
yeah.
D
B
B
D
A
E
D
D
B
Recommendation
I
might
also
have
is
on
the
for
the
book.
It
might
actually
be
cool
to
use
the
propose
browser
flag,
that's
being
implemented
with
the
gia
snippet
stuff,
because
I
feel
like
then
feels
much
more
natural
than
the
new
module
stuff,
where
no
module
still
feels
kind
of
like
a
little
bolted
on
a
little
weird,
and
so
that's
like
using
modernist
modules
using
modern
JavaScript.
So
that
might
be
a
good
way
to
introduce
things
as
well.
Okay,.
D
B
A
F
Okay,
so
yep,
so
we
we
I
think
they
also
discuss
this
long
back
and
some
of
our
issues
and
I
think
this
is
a
good
time
to
bring
it
back
now.
We
need
to
add
some
way:
code.
Splitting
and
dynamic
loading
stuffs
inside
this,
whatever
be
generate
because
whatever
via
current
is
generating,
is
a
single,
huge,
fine
right,
so
by
any
means
of
any
means,
can
we
split
it
and
then
try
to
load
it
dynamically
and
things
like
that
which
kind
of
increases
performance
for
discussion?
Can
we
start
something
related.
F
A
So
everything
is
possible.
Now
we've
created
demos
in
the
past
and
like
a
lot
of
the
work
we
did
in
the
past,
was
kind
of
around
trying
to
make
it
a
nice
rusty
interface
and
also
trying
to
avoid
the
problem
of
like
having
to
manually
choose
like
which
functions
end
up
in
which
blob
and
do
a
bit
more
of
and
I
guess
like
a
graph
based
approach.
A
That
stuff
I
feel
is
a
little
bit
further
off,
because
it
involves
like
doing
a
lot
of
stuff
that
the
linker
does
for
you
or
like
needing
stuff
out
of
the
linker,
but
like
just
doing
like
basic
dynamic
loading
and,
like
manual
manually
kind
of
doing
code,
splitting
instead
of
kind
of
an
automatic,
transparent
thing
that
happens
for
you
is
totally
possible.
Now
and
like
you,
just
need,
like
a
tiny
bit
of
JavaScript,
to
manipulate
the
function
tables
for
you.
A
F
Thoughts,
yep
I
think
that
would
be
really
useful,
but
added
to
that,
because
the
current
issue
with
the
Packer
webassembly
is
the
file
that
we
use
the
library
that
we
used
to
split
or
compile
this.
Whatever
code
to
be
generating
is
like
we
try
to
manually,
try
to
allow
remove
certain
bits
and
then
add
some
bits
to
it
like
try
to
manipulate
that
past
the
best
in
the
file
that
we're
generating,
which
kind
of
having
a
bit
more
trouble
because
sometimes
the
spaces
might
increase.
F
Sometimes
we
have
to
be
very
careful
when
we're
doing
that
stuff.
So
I
think
if
we
have
the
library
that
itself
creates
us
an
opportunity
to
create
those
kind
of
files,
I
think
it'd
be
really
helpful.
That's
that's
what
I
am
thinking
of
at
this
moment:
yeah,
maybe
the
future.
If
someone
is
really
interested
in
do
that
stuff,
but
we
should
have
some
people
C's
or
examples
Saturday.
C
I
mean,
as
Nick
mentioned
so
I
currently
enjoy
us.
We
have
like
code
splitting
points
where
you
say
that
this
drink
of
Jes
and
this
part
of
the
graph
must
be
loaded
dynamically,
like
with
using
the
import
function
right
and
so
I
guess
in
I
wasn't
buying
it
some
kind
of
saying
to
say
that
this
should
be
loaded
dynamically,
maybe
an
annotation
or
bindings
to
the
to
the
J's
import
function.
A
B
Or
somebody
motivation
like
these
cases,
they're
like
this-
is
in
production
and
like
this
slow
and
we
realized.
If
we
can
do
this,
this
would
solve
our
load
times
or
whatever,
because
that
this
is
such
a
major
change,
not
just
a
compilation
model,
but
also
just
kind
of
like
how
you
build
it.
The
tool
chain,
a
lot
of
moving
parts
here
and
there's
so
many
ways
we
could
design
this.
F
C
A
That's
it's
definitely
possible
right
now,
but
a
lot
of
it
is
how
nice
do
we
want
to
get
it,
and
where
do
you
make
that
cut
like?
Because,
as
soon
as
you
do,
this
you're
probably
gonna
want
to
like
factor
out
the
allocator
into
its
own
thing
as
well,
because
that's
likely
to
be
shared
between
both
model
modules
etc.
C
Also
I'm
thinking
about
something
else,
I
think
it's
quite
some
a
more
general
issue
because,
like
in
a
web
bike,
we
are
thinking
of.
If
your
load
medieval
was
module,
is
it
may
be
worth
it
concatenating?
You
can
cut
them.
Maybe
just
loading
game
entirely,
so
maybe
wasn't
managing
could
have
some
such
of
such
a
very
heuristic.
That
says
that
if
the
file
is
bigger
than
one,
we
can
straight
it
if
two
less
than
1
K,
we
can
edit
them
whatever,
but
something
like
that
could
be
in
the
this
together.
Yeah.
A
That's
I
think
that's
something
that
Wesson
bind
Jen
could
consider
or
wise
impact
or
something
like
a
tool
chain
for
a
specific
like
language
or
ecosystem
or
vendor
I.
Don't
know
how
to
say
like
for
a
web
pack
to
do
that.
I
think
it's
a
bit
scarier
because
you
don't
know
like
like
putting
two
things
into
the
same
linear
memory.
Like
you,
don't
know
if
they're,
how
they're
using
linear
memory-
and
they
might
both
be
saying,
like
here's,
my
global
at
this
location.
A
G
Me
it
sounds
like
this
would
be
an
optimization
for
load
times
and
if
we're
like
gonna
do
any
sort
of
optimization,
maybe
it
would
be
good
to
have
like
numbers,
so
maybe
like
the
starting
point
for
all
of
this
would
be
to
start
benchmarking
like
hey
what-what
are
a
lot
of
times
like.
What's
our
binary
size
like
don't,
can
we
speed
this
stuff
up
and
then
later
on,
like
wait
online,
we
can
like
figure
out
the
perfect
way
to
like
do
all
these
things,
but
your
practical
for
now
may
be.
A
Agreed
this
kind
of
comes
back
to
the
you
know.
Maybe
we
should
wait
for
real-world
use
cases
before
we
start
like
pushing
forward
on
this
lot
and
then
yeah.
Also
so
did
you
do
any
binary
size
stuff
at
the
hackathon
at
all?
Okay,
but
we
have
vague
plans
in
the
roadmap
to
start
watching
binary
size
over
time.
I
don't
know.
If
we
talked
about
that
last
yeah
we
did
okay,
so
I'm
not
gonna.
Go
over
that
again.
A
B
A
A
A
Okay,
well
have
a
great
week
and
yeah
I'll
put
out
another
this
week
in
Ruston
webassembly,
really
trying
to
do
that
weekly
now
and
a
reminder
that
if
you
have
anything
that
you
want
to
show
up,
there
put
the
label
Twi
r
AWA,
which
is
this
week
in
Reston
webassembly
yeah.
So
have
a
great
week.
See
you
later
see.