►
Description
No description was provided for this meeting.
If this is YOUR meeting, an easy way to fix this is to add a description to your video, wherever mtngs.io found it (probably YouTube).
A
A
So
I
have
a
rust
application
here.
It's
a
sort
of
little
game.
It's
a
very
simple
game.
I
can
basically
fly
around
shoot
on
things,
it's
sort
of
a
little
bit
like
an
asteroid
claw
night.
So
but
at
the
same
time,
what
I
can
do
here
is
I
can
go
into
my
source
code
and
I
can
start
changing
things
over
here.
So,
for
example,
these
things
here
fly
around
with
a
certain
velocity.
A
So
let's
change
that,
let's
save
the
code
and
let's
wait
a
second
and
then
these
things
start
flying
a
little
bit
faster.
We
can't
not
only
change
the
speed,
so
basically
the
certain
things
we
can
also
change,
basically
the
source
code.
So
here
when
I
press
the
key,
then
for
each
key
press,
I
basically
fire
a
shot.
A
We
can
change
how
the
firing
rate
works
simply
by
basically
firing
something
whenever
we
keep
the
key
pressed
down.
So
this
should
basically
increase
the
firing
rate
a
little
right,
and
so
the
idea
here
is
you
basically
write,
make
a
code
change
and
directly
have
that
reflected
in
your
program,
all
right.
A
A
Exactly
in
invest
how
how
does
it
work
and
then,
basically,
I
show
you
a
demo
of
how
you
can
build
something.
I'll
also
talk
about
the
the
limitations
of
that
approach,
because
there
are
quite
a
few
that
you
should
be
aware
of,
but
there
are
also
a
bunch
of
examples
and
demos
around
that
that
basically
show
you
a
certain
patterns
of
how
you
can
use
it
so
that
talk
basically
presents
that
create
a
hot
loop.
A
Erlang,
for
example,
has
like
built-in
support
for
this
kind
of
a
feature
called
hot
code
swapping
there,
which
basically
is
not
only
for
development,
but
it's
also
used
basically
directly
to
deploy
applications,
because
if
you
have
like
many
hundreds
or
thousands
of
nodes
running
and
a
large
distributed
system,
you
don't
want
to
tear
that
entire
thing
down
and
and
restart
it.
We
want
to
gradually
update
it
step
by
step,
so.
A
A
Options
there
that
you
can
use
for
basically
doing
code
changes
on
on
the
fly
and
these
languages,
basically
ship
sort
of
a
compiler
this
their
this
their
runtime,
and
this
is
basically
how
they
make
it
it
possible
in
with
with
static
languages
like
c
plus,
plus
and
c
and
rust.
This
is
not
the
case
and
we
basically
need
the
different
options
there
to
to
implement
it.
So
one
option
is
basically
to
directly
change
the
running
code.
A
A
Compilation
and
and
linking-
and
they
call
it
edit
and
and
continue-
and
this
is
basically
a
way
to
inside
the
debugger
in
visual
studio
to
basically
change
code
and
then
basically
reload.
These
changes
on
the
fly
there.
Also,
there
is
tools
like
frida
that
are
mostly
used
to
basically
patch
up
assembly
code
and
basically
directly
change
the
function
in
invocations
here,
mostly
for
the
purpose
of
doing.
A
A
Library
approach
where
you
basically
just
use
what
the
operating
system
offers
you
in
in
that
you
have
these
kind
of
of
modules
that
you
can
load
at
one
time
and
even
if
your
program
is
already
running
and
the
idea,
there
is
basically
that
you
will
create
new
versions
of
of
a
library.
While
the
program
is
running
and
then
you
basically
just
reload
these
kind
of
new
new
versions
on
the
fly.
There
are
a
couple
of
issues
there.
A
Basically
operating
systems
assumes
that
one
version
of
of
the
library
basically
is
aesthetic
and
won't
change.
So
you
there
are
certain
workarounds
that
we
also
need
to
do
here,
but
it
basically
works,
and
this
is,
for
example,
also
something
that
the
unreal
engine
users
they
have
have
licensed.
The
cool
tool
called
live
plus
plus
they
are
basically
wrapping
each
c
plus
plus
file
inside
the
library
and
are
then
basically
doing
a
reload
of
that.
A
Like
that,
in
order
to
basically
create
a
library
and
rust,
what
we
need
to
do
is
to
basically
specify
a
crate,
because
the
the
compilation
unit
and
rust
is
basically
a
great.
So
what
we?
What
we
want
to
do
is
we
want
to
build
an
executable
that
is
sort
of
the
outer
project
here
defined,
for
example
like
that,
so
we
define
a
workspace,
the
workspace
defines
a
wood
package.
A
This
is
then
holding
the
main
ice
file,
the
actual
thing
that
will
run
in
when
we
started,
and
it
defines
a
sub-package
lib
package
that
basically
just
defines
the
code
that
we
want
to
to
reload.
We
can
depend
on
the
package
just
using
that
pass
syntax
here,
and
then
we
also
pull
in
the
hot
reloader.
A
The
library
itself
looks
fairly
normal.
It
just
needs
to
define
as
a
crate
type
so
that
we
basically
create
a
dll
on
windows,
dot,
so
file
on
on
linux
and
delip
file
on
mac
os
so
and
then
the
source
code
in
the
simplest
version
that
we
can
basically
come
up
with.
Basically,
the
library
just
defines
a
function
and
functions
are
basically
the
reloadable
things
that
we
can,
that
we
can.
A
Purpose
and
that
function
needs
that
no
manual
attribute,
so
that
we
can
basically
look
it
up
inside
the
library
when
it
gets
built
and
the
main
file
then
basically
just
starts
a
main
loop,
but
it
also
loads,
basically
a
special
version
of
that
offset
library,
which
is
basically
provided
by
the
the
crate
that
we
that
we
are
using
here.
So
we
have
said
hot
module
macro
that
we
are
annotating
the
modules
and
then
we
basically
say
we
want
to
just
load
all
the
functions
that
are
defined
inside
of
that
lib
ice
file.
A
A
We
basically
keep
that
main
loop
running,
but
we
will
sleep
basically,
after
every
step,
there
are
different
ways
of
dealing
with
that
and
I'll
talk
about
it
later.
But
that's
that's
basically
the
the
simplest
example
that
you
can
come
come
up
with
so
and
then,
basically,
when
we
have
the
source
code,
then
the
question
is:
how
do
we
run
that
code
right?
What
we
do
is
we
basically
start
two
build
commands.
A
A
A
A
Okay,
so
here
we
basically
just
print
out
whatever
we
had
in
our
print
line
there.
Let's
go
back
into
lip
lippers,
and
here
we
can
now
basically
start
to
change
to
change
things.
So,
for
example,
I
don't
know
it
says,
insert
we
have
like
a
fire
emoji
here
like
so
we
should
we
save
the
source
code
and
then,
after
a
short
reload,
we
basically.
A
So,
as
I
already
said
like,
we
are
using
a
library
behind
the
scenes
right
and
when
we
take
a
look
at
what's
actually
going
on
here,
I
can
take
a
look
in
the
target
debug
directory
and
we
see
that
there
is
a
liblip
dot
julip
file
here.
Lip
is
just
a
prefix
that
the
operating
system
appends
right
lip
is
the
name
of
the
crate,
which
gets
basically
translated
into
the
name
of
the
library
file,
and
the
loop
is
just
the
extension.
A
A
It
does
not
want
to
reload
all
these
things,
and
it
basically
thinks
that
once
you
have
that
library,
with
a
certain
name
that
code
inside
of
that
library
will
stay
the
same
and
what
we
are
doing
behind
the
scenes
is
basically
just
watching
that
file
here
and
then
basically
copying
new
versions
whenever
it
changes
and
then
basically
telling
the
poor
the
the
program
to
please
we
reload
that
there's
a
crate.
There
called
lip
loading.
A
Systems-
and
this
is
basically
what
is
used
behind
these
scenes,
so
now,
let's
go
back
into
manas
and
just
for
a
second
I'm
gonna
expand
the
marco,
it's
a
bunch
of
source
code,
but
it
might
be
interesting,
come
on
yeah,
a
microphone
that
point.
Okay
come
on:
okay,
let's
use
a
cargo
expand
over
here.
That
will
work
as
well
and
we
don't
want
to
have
any
color.
A
Morning
so
it
generates
a
bunch
of
source
code,
and
not
all
of
that
is
ours,
but
this
year's,
so
what
we
basically
do
inside
the
marker
is.
We
read
the
file
that
was
specified
in
that
inside
the
the
module
that
we
wrote
right.
We
are
reading
the
contents
of
libra
rs
and
for
each
function
in
there
we're
going
to
produce
a
new
function
inside
of
the
scope
of
that
hot
lip
thing
and
when
we
call
that
function
basically,
whatever
function.
A
A
A
The
macro
also
has
additional
support
for
basically
allowing
you
to
control
how
the
reload
is
working,
so
you
can
expose
a
subscribe
function,
and
that
has
two
methods
wait
for
about
to
to
reload
and
wait
for
wait
for
the
the
reloads
to
happen,
and
those
functions
will
basically
block
where
we
call
them.
The
wait
for
about
to
reload
function
will
return
a
token
and,
as
long
as
the
token
is
in
the
scope,
we
will
not
reload
the
the
library.
A
This
means
that
here
you
basically
can
be
certain
that
you
still
have
access
to
the
old
version
of
the
library.
So
this
is
important
when
you
want
to
deal,
for
example,
the
the
state
right.
You
could
export
a
struct
or
an
enum
from
the
the
library,
and
if
you
want
to
change
that,
you
really
need
to
be
careful
there,
because
the
the
the
the
executable
basically
only
knows
about
the
old
version
right
and
when
you
want
to
reload
state.
A
You
basically
need
to
do
additional
steps,
for
example,
to
to
serialize
and
deserialize
the
state
between
when
a
reload
happens,
and
this
basically
allows
you
to
have
some
option
to
basically
in
between
the
about
to
reload
and
the
drop
token.
You
can,
for
example,
get
rid
of
the
old
state
you
can,
you
can
save
it
in
some
form
and
wait
for
reload
once
that
call
gets
back
there.
You
have
the
new
version
of
the
library
where
you
can
basically
load
new
state
from
one
question.
A
Yeah,
no,
no
I'll
get
it
okay.
So
there
are
other
functions
that
you
can
expose
from.
The
marco,
for
example,
to
get
a
version.
Number
of
of
the
library
might
be
useful
for
doing
a
migration
of
the
state.
If
you
deal
with
that,
you
can
also
get
just
like
a
a
flag
that
says
whether
or
not
the
library
was
just
reloaded
or
not.
A
A
Storage,
then
you
will
lose
it
and
there
are
some
some
frameworks
that
make
use
of
that.
So,
for
example,
the
macro
quad
and
a
mini
quad
game
engine
makes
use
of
that.
They
basically
initialize
behind
the
cnc
opengl
state
and
those,
unfortunately,
will
not
work
with
that
approach,
because
you
basically
don't
have
the
opengl
context.
Once
you
do
a
reload.
A
A
And
then
again,
the
state
layout
of
the
of
the
state
being
held
in
the
executable
can
sort
of
change.
If
you
are
a
careful
there's,
one
example
here
that
I
won't
go
into
detail
because
of
time,
but
you
can
find
it
here
on
the
slides
and
there's
also
examples
inside
of
the
also
the
repository
that
basically
show
how
you
can
serialize
and
deserialize
a
state
in
order
to
make
changes
in
in
state.
A
The
short
version
is
right:
you
can
save
and
load
it,
and
you
can
make
use
of
the
subscribe
feature
and
then
between
wait
for
about
to
to
to
reload
and
the
reload
itself.
You
can
save
and
then
load
the
this
date,
and
this
is
basically
how
that
stuff
can
can
work
all
right.
So
if
you
want
to
know
more,
you
can
find
that
on
the
github
repository
there
are
a
bunch
of
examples.