►
From YouTube: Rust Lang Meetup - Febuary 2023
Description
Marcus Lee will be sharing on the journey to rust from a student
A
Okay,
I
started
so
very
welcome.
Welcome
to
Ross
Ross
medium
Malaysia,
this
one.
This
is
like
our
our
how
many
years,
third
or
four
years
like
except
the
two
years,
that
is
the
NCO
we
have
like.
We
have
been
doing
this
since
2020
around
20
20.,
so
I'm,
one
of
the
organizers,
my
name
is
Simon
Tom.
You
can
also
see
my
name
in
the
telegram
group
I'm
more
likely
there
and
and
there's
a
couple
of
announcements
to
make
for
for
the
Meetup
today.
So
first,
the
other
call
of
the
other
core
organizer.
A
A
A
B
Okay,
okay,
so
hi
everyone,
I
would
say
this
is
my
first
time
giving
talks
outside
of
school.
Previously
I've
been
just
you
know,
give
talks
at
Thai,
OC
and
whatnot,
but
yeah
so
actually
I
would
first
confess
I'm,
not
really
a
rust
expert.
So
don't
expect
me
to
say
a
lot
of
like
complicated
stuff,
I
I'm
still
learning
them.
That's
why
it's
the
journey
to
us
from
a
student
yeah,
so
I'm
still
a
student
Line
This
regard
still
learning
Russ.
So
so
today
the
talk
mainly
will
be
a
few
things.
B
So
before
we
move
on
to,
like
you
know
the
actual
thing,
so
just
a
little
brief
introduction
about
me,
I'm
currently
infrastructure
engineer,
it's
just
a
fancy
way
to
say
you
do
backend,
actually
yeah,
so
I'm
an
infrastructure
engineer
at
Berliner,
which
is
my
current
company,
so
we're
doing
something
about
quantitative
trading.
It's
it's
not
very
well
known
in
Malaysia,
but
it's
basically
just
programming
and
trading
together,
yeah
so
and
I
recently
graduated
from
Thai
UC
to
go
up
to
Raman,
University
College.
B
That's
why
I'm
saying
I'm
still
a
student
and
I
had
experience
working
with
with
e-commerce
Solutions
and
some
web
free
platform
before
so
I
I
I
would
later
I'll
go
through.
You
know
some
of
my
journey
how
I
got
to
programming
and
some
of
the
work,
experience
and
stuff,
but
but
yeah
before
coming
into
Russ,
I
would
say:
I'm,
I'm
kind
of
like
a
goaling.
Slash
react
programmer
like
react,
engineer
or
golang
engineer.
That
is
what
I
mainly
do
before
I
enroll
in
my
current
job,
so
so
yeah.
B
B
B
How
about
you
only
oh
you're,
working
in
Russ?
Oh
that's,
good,
okay,
yeah!
So
so,
apparently
like
it's,
it's
a
it's
a
common
thing
that
we
see
in
the
rust
Community.
It's
like
it's
very
hard
to
learn,
but
what's
worse
than
hard
to
learn
it's
very
hard
to
find
a
job
for
us.
It's
like
it's
almost
near
to
Impossible,
because
I
went
through
that
Journey.
When
I
was
looking
for
internship
I
tried
to
find
Rush
jobs.
There's
none
in
Malaysia
I
can't
find
one.
B
So
the
nearest
I
found
is
that
Singapore
and
my
experience
is
I,
apply
it
and
then
the
recruiter
got
back
to
me.
Then
they
asked
do
you
have
Visa
I
was
like
no
I'm,
just
a
student,
I
I
don't
have
Visa
so
yeah,
so
that
that
that
is
a
little
bit
sidetracked
but
yeah.
So
let's
move
on
to
the
the
main
thing.
So,
okay,
I
think
the
animation
is
not
working.
Really
well
yeah.
Let
me
just
okay,
okay,
not
a
big
issue
but
yeah.
B
So
here's
a
little
it's
a
it's,
a
kind
of
like
a
timeline
graph
of
myself.
So
how
I
got
into
programming
was
like
back
when
I
was
just
really
young,
when
I
was
10.,
I
got
to
know
Java,
I
wouldn't
say:
I
got
to
learn
Java
because
I
didn't
learn.
It
I
just
got
to
know
Java,
because,
but
at
that
time
I
was
playing
a
game
called
MapleStory
I,
don't
know
how
many
of
you
actually
played
that
game
or
actually
know
about
it.
I
played
a
game
called
Mr
story
and
I'm
broke.
B
I,
don't
have
money
to
buy
a
cash,
that's
what
they
call
it.
So
I
tried
to
make
myself
a
private
server
which
involves
downloading
netbeans
and
then
copying
Java
code
and
then
compiling
Java
cursor,
so
I
got
to
know
Java
back
then,
but
I
don't
really
learn
it.
But
that's
that's
my
exposure
to
programming,
but
eventually
in
2019,
about
I.
B
Think,
four
years
back
in
my
Foundation
years,
where
I
got
to
know
two
of
my
friends
here,
which
we
also
learned
python,
like
very,
very
basic,
python
and
and
I,
would
say:
I
love
python,
a
lot
back
then
as
my
first
language,
because
you
can
actually
do
almost
everything
just
that
it's
super
slow
like
very
freaking
slow.
So
there's
a
story
that
I'll
share.
B
Why
you
know
I
eventually
came
out
of
python
and
stuff,
so
I
learned
python
back
then
and
then
in
2020,
which
you
know
kovit
came,
and
it
was
at
that
time.
I
started
to
learn
a
lot
about
programming,
especially
in
Python.
I.
Do
a
lot
a
lot
of
light
because
basically
I'm
stuck
at
home.
Nothing
else
to
do
so.
I,
just
programmed
and
I
just
learned
python.
B
So
I
created
a
lot
of
Psych
projects,
some
included
some
python
chat,
board
and
stuff,
but
one
of
the
most
notable
projects
that
I've
did
in
Python,
which
I
think
I
will
share,
because
I
think
this
relates
to
why
we
are
all
interested
to
learn,
Russ
or
like
to
learn
a
new
language,
because
it
kind
of
give
you
like
a
new
way
of
thinking
about
programs
and
also
performance
is
a
very
a
very
obvious
reasons,
but
so
in
2020
I
coded
a
project.
So
it
was
for
a
camp,
an
online
Church
camp.
B
We
have
about
22
000
2000
people
trying
to
access
the
web
portal,
so
it
was
my
first
time
making
a
first
project
and
I
think
everything
is
good
because
I
heard
from
people
saying
oh
just
use
cloud
and
then
it
will
scale
to
Millions,
so
I
deployed
the
whole
program,
I,
deploy
it
to
gcp
and
then
through
something
called
app
engine
and
I.
Think:
okay,
it's
fine!
Okay!
Everything
is
good
and
I
saw
you
know.
B
Python
is
so
well
regarded
and
people
say:
Instagram
use,
Python,
Facebook
use,
Python,
Google,
use
Python,
so
I
think
python
is
the
best
one.
So
what
happened
is
just
the
website
like
just
five
minutes
after
the
website
go
live
I've
been
getting.
You
know
a
lot
of
bug.
Report
people
say:
I
can't
load
the
site.
The
lock
side
is
not
loading
and
I
was
like.
Oh,
what
what's
wrong
and
I
and
I
have
no
idea
what's
wrong,
because
I'm
very
new,
so
I
do
not
know
anything
about
it,
but
ended
up.
B
B
Yeah
so
in
2021
I
started
to
pick
up
a
job.
It's
a
it's
a
it's
kind
of
like
a
side.
Job
beside
my
study,
so
that
job
is
is
the
e-commerce
solution
that
I
brought
up
just
now.
It's
basically
where
a
few
friends
and
I
we
decided
to
kind
of
like
do
like
kind
of
like
a
startup.
But
then
it's
it's
kind
of
Niche
I
would
say
because
the
time
we
did
that
whole
thing,
it
was
during
covert,
quarantine
and
stuff.
B
We
are
trying
to
replace
grab
food
which
we
failed,
but
yeah.
It's
like
we
tried,
so
we
built
the
whole
thing
and
go
and
react
which
it's,
where
I
learned
a
lot
about.
Building
apis
learned
a
lot
about.
You
know,
building
I
think
at
that
time
we
tried
to
do
graphql
stuff
and
it's
a
I
would
say
it's
good.
It's
not
the
best
experience
but
yeah.
So
moving
on
to
2022
2023,
so
I
did
a
lot
of
other
stuff,
wet,
free,
stuff,
solidity,
stuff,
typescript
stuff.
B
Until
now,
I
work
in
brass,
but
my
journey
with
Russ
started
like
way
back
like
I
started.
To
learn
about
I
mean
not
learned,
but
I
heard
about
Russ
when
I
was
trying
not
to
build
like
a
new
startup
like
in
2021,
when
we
were
trying
to
build
like
e-commerce
solution
right
and
with
that
experience
that
I
had
like,
where
python
doesn't
scale
and
stuff
I.
Eventually
I
went
to
the
internet.
I
just
looked
I
just
searched,
for
you
know
the
best
performing
language
and
then
what
came
up
there's
a
few
choices.
B
The
number
one
choice
is
CC,
plus
plus
and
second
is
for
us.
I
forgot
what
the
third
one
is.
I
think
the
third
one
is
go
like
so
I
was
looking
at
it
and
then
C
and
C,
plus
plus
it's
I,
had
a
very
bad
experience
using
CSC
plus
plus
last
time,
because
I
started
out
learning
c
as
after
after
python
and
I
was
very
frustrated,
because
every
time
I
tried
to
do
c,
it's
like
I
have
to
spend
a
day.
B
Setting
up
the
environment
before
I
can
do
see,
there's
a
lot
of
stuff
like
cmake,
GCC,
G,
plus,
plus
and
Linker,
and
all
those
kind
of
stuff.
So
I
don't
want
to
do
see
and
then
there's
Ross,
but
then
I
tried
to
you
know:
I
tried
to
I
tried
to
learn
Russ
so,
but
I
failed,
so
I
tried
to
run
a
lot.
Learn
Russ,
but
I
felt
eventually
I
chose
golang,
but
then
I
started
to
know
about
Russ
at
that
time.
So
because
I
was
interested
to
do
kind
of
like
web
programming.
B
B
I'll
show
you
guys
that
the
stuff
later
I
mean
some
of
the
code
later,
but
I
started
to
come
back
to
Russ
again
in
2022,
because
I
think
at
that
time
I
was
trying
to
challenge
myself
because
I
was
like
because
after
a
little
bit
time
into
programming,
I
always
heard
people
say
Russ
is
the
hardest
language
to
learn.
It's
like
they
always
say.
If
you
can
learn
Russ,
you
can
actually
learn
everything
and
anything
they
say.
Russ
make
you
a
big,
better
programmer
and
I
try.
B
I
have
no
idea
why
it's
like
it
just
doesn't,
compile
and
and
I
kind
of
gave
up,
but
yeah,
so
and
and
fast
forward.
To
now,
I
got
like
somehow
very
like
the
end
of
last
year.
Somehow
someone
invited
me
to
do
like
a
part-time
rush.
Job
I
accepted
it
I,
challenged
myself
again
and
I
got
the
full-time
job
now
so
I'm
booking
rust
full-time
here,
but
that
that's
my
story
a
little
bit
of
my
journey
to
grass.
But
but
you
know,
like
learning
Russ,
it's
so
difficult.
B
That's
that's
what
they
say
and
I
was
like
I'm,
pretty
good
at
C,
plus
plus
I
got
a
for
my
C
C
plus
plus
course,
and
I
think
yeah
Rush,
maybe
would
be
just
similar.
But
then,
when
I
started
to
do,
Russ
I
was
immediately
faced
with
all
this
stuff,
which
is
I,
have
no
idea
what
it
is
at.
First
ownership
macros
like
it's
just
everywhere,
and
then
sometimes
you
know
when
I
say
when
the
program
doesn't
compile.
It's
like
it
really
doesn't
compile
like
every
time.
B
They
don't
have
the
ownership
warnings
now,
but
I
have
the
lifetime
kind
of
warning
and
compilation,
areas
and
stuff,
which
is
very
mind-boggling
to
me.
I
can't
I
I,
really
don't
know
why
it
doesn't
compile
so
so
these
are
stuff
that
you
know
like
really
like
I,
never
had
to
learn
a
language
for
that
long.
I
shared
about
my
experience
in
goal
right,
so
I
did
not
know.
B
Go
I
tried
to
use
it
for
for
the
e-commerce
solution,
but
the
thing
is
I
can
pick
up
gold
in
two
weeks
three
weeks,
it's
very
simple,
actually
even
lesser
than
two
weeks.
Three
weeks,
it's
like
just
one
tutorial
video.
You
can
get
a
web
server
running.
It's
very
easy
but,
like
Russ
took
me
like
two
years
and
I
still
cannot.
I
still
can't
get
my
program
to
compound
that
it's
it's
a
it's
a
true
story
and
there's
one
very
particular
thing
that
I
wanted
to
share
it's.
B
B
So
so
it's
like
it's
very
simple
right
in
C,
plus
it's
very
simple,
like
five
flying
six
lines,
and
then
we
have
kind
of
like
pointers
here,
reference
to
the
next
note,
this
kind
of
stuff,
so
in
C,
plus
plus
it's
kind
of
very
simple,
and
it
makes
sense,
like
you
know
like
in
a
in
a
note,
you
have
the
next
node,
which
is
kind
of
like
a
reference.
A
memory
address
I
tried
to
write
this
in
Ross.
I
cannot
I
try
to
use
reference
and
stuff,
it
doesn't
work.
B
It
just
doesn't
work
because,
like
I
have
to
I,
have
a
note
which
contains
the
next
note.
I
have
to
reference
the
next
note
and
then
I.
Try
to
use
reference,
it
doesn't
work
and
then
it
tells
me
the
compiler
tells
me
to
copy
I
try
to
but
I
copy
it
it.
It's
not
going
to
work
because
it's
I
don't
want
to
copy
I
want
to
reference.
That's
the
thing
and
eventually
I
just
got
so
frustrated
I,
just
I.
Just
quit!
Writing
lead
code
in
the
brush
because
I
just
doesn't
get
it
to
work.
B
There's
one
point
that
I
tried
like
whole
day
the
whole
day,
just
porting
this,
like
28
lines
of
code
to
brush
I,
just
can't
get
it
like
one
holy
and
eventually
I'll
I'll.
Briefly
talk
about
how
you
know
the
program
actually
like.
What's
the
actual
program
that
what's
the
code
that
actually
compiles
for
this
there's
something
that
there's
something
called
smart
pointers
that
we
really
had
to
use
in
Rust
else.
It
will
really
not
compile
but
yeah.
B
So
this
is
some
of
my
frustration
in
Russ,
so
so
there's
a
lot
of
stuff
here,
but
eventually
what
I
would
say
is
learning
Russ
is
kind
of
like
a
love
and
hate
relationship.
To
me
it's
kind
of
like
you
love
the
language,
but
you
also
hate
the
language
and
you
love
and
hate
the
language
because
of
the
same
thing,
so
I
hate
Ross,
because
it's
super
straight
it
doesn't.
Let
me
even
Compounce,
you
know
like
simple
code
like
it
doesn't.
Let
me
violate
some
of
the
rules.
B
It's
super
strict,
I
hate
it
that
way,
but
when
I
started
working,
I
love
it
because
it's
so
strict
and
it's
very
annoying
like
day
to
day
but
I
would
say
it's
annoying
because
from
my
day
job
lot
now
what
I
do
is
actually
not
I,
don't
feel
like
I'm
coding,
I
feel
like
I'm,
just
making
the
compiler
happy
and
then
once
my
code
compiles,
then
it
works.
So
that's
why
I
say
it's
very
annoying
because
at
first
you
just
face
so
many
errors
that
compiler
just
throw
stuff
at
you.
But
when.
B
I
never
touched
golang
again
when
they
got
generic.
So
one
of
the
things
that
people
battle
with
like
generic
last
time,
it's
golang
is
doing
code
generation.
So
every
time
you
write
a
function,
you
want
it
to
work
for
other
kind
of
data
type.
You
have
to
generate
a
code
and
then
that
generator
code
easily
could
be
10
000
lines,
20
000
lines
and
it
kind
of
slow
down
the
whole.
B
It's
like
today,
I
own,
this
water
bottle
and
then
I,
I
borrow
it
to
someone
or
I
borrow
something
from
you
or
from
some
other
people.
Essentially
that
is
ownership.
So
it's
a
very
simple
idea:
a
primary
school
student
can
get
it.
You
know.
So
that's
what
I
see
you
think
you
get
it,
but
actually
you
don't
so
so
badly.
You
don't
so
so
I'm
going
to
just
give
a
little
bit
of,
like
example,
in
like
the
ownership
model
in
Russ,
which
is
basically
the
whole
ownership,
is
just
this.
These
three
things.
B
That's
all
ownership
is
just
three
things.
That's
all,
and
but
I
would
say
you
really
need
to
know
this
speak
to
your
heart,
because
a
lot
of
the
time,
based
on
my
experience
when
the
compiler
throws
an
error
to
me,
I,
would
say
50
50.
It
is
because
of
ownership
problems
and
it's
kind
of
like
a
it's
a
graph.
It's
like
a
it's,
not
a
linear
graph.
B
So
learning
Russ
is
not
a
linear
graph
kind
of
like
a
curvy
exponential
graph,
because
the
curve
is
that
when
you
started
to
learn
rust,
it's
very
hard.
The
compiler
maybe
throws
you
five
to
like
100
errors,
but
when
you
started
to
get
comfortable
in
Rust,
eventually
you
don't
feel
it's
it's
annoying
anymore.
You
feel
like
it's
a
very
good.
You
know
error,
message
and
stuff,
but
coming
back
to
ownership,
it's
just
these
three
things.
Number
one
borrow
number
two
move
number
three
copy,
so
bottle
is
very
simple.
B
Very
it's
a
very
like
a
very
simple
idea.
Today,
I
own
this
bottle
and
I
want
to
borrow
it
to
someone.
So
let's
say
I
borrow
it
to
Ivan.
I
can
choose
how
I
want
to
borrow
it.
There's
two
ways
to
borrow:
either:
I
borrow
it
to
you.
It's
a
read-only
borrow.
That
means.
When
you
got
this
bottle,
you
can
only
look
at
it.
You
cannot
open
it.
You
cannot
drink
from.
It
cannot
do
anything.
You
can
just
look
at
it.
B
So
that's
the
first
type
of
borrow
and
then
the
second
type
of
borrow
in
Rust.
We
call
it
mutable
reference.
It's
where
I
borrow
you
my
bottle.
You
can
look
at
it,
you
can
drink
from
it.
You
can
even
I,
don't
know
you
can
feel
more
about
and
you
can
feel
more
water
and
stuff
and
then,
as
long
as
you
return
it
to
me,
then
it's
fine.
Let's
cut
borrow
a
week,
so
this
concept,
it's
very
simple,
I,
try
to
apply
it
to
variables.
B
It
starts
to
get
a
little
bit
messy,
but
I'll
have
like
a
little
bit
of
code
later,
just
to
explain
myself.
But
but
that's
that's
the
first
idea.
It's
borrowing.
So
in
Rust
everything
everything
is
owned
by
someone.
So
every
variables
every
variable
every
function,
you
don't
typically
own
and
function,
but
the
function
owns
something
so
ownership
is
everywhere
in
Rust.
B
So
if
you
want
to
learn
Russ,
you
have
to
learn
ownership,
because
if
you
don't
know
ownership,
you'll
be
me
stuck
two
years
trying
to
solve
compiler
errors
and
don't
understand
what
the
compiler
is
trying
to
say
so
so
and
then
the
second
type
of
ownership
is
where
you
can
transfer
the
ownership.
So
it's
basically
saying
that
I
don't
want
my
bottle
anymore,
I,
give
it
to
you
and,
and
it's
not
mine.
This
is
not
my
bottle
now.
I
cannot
take
it
back
because
I
gave
it
to
someone
else.
B
So
this
is
the
second
thing
and
the
third
thing
is
copy,
so
this
is
kind
of
like
magic
like
you
can
just
copy
my
bottle,
you
get
a
copy
of
your
own
bottle,
so
it's
just
that
simple
and
if
I
look,
if
we
look
at
one
error
message
here,
I
think
it's
kind
of
small.
But
basically
this
is
one
of
the
ownership
error
message.
If
you
look
at
it,
the
compiler
is
saying
borrow
of
move
value.
B
So
if
you
come
back,
what
is
borrow
of
move
value
is,
is
where
I
borrowed
my
bottle
to
him
and
then
I
tried
to
do
something
to
my
bottle,
but
I
don't
have
the
bottle
anymore.
I
gave
it
to
him.
So
this
is
what
rust
compiler
is
trying
to
tell
you
now
when
you
have
no
idea
of
what
ownership
is.
You
just
doesn't
understand
what
it
is
so
I'm
going
to
give
one
example
of
across
code
here.
B
Let
me
just
oh:
it's
really
big
yeah,
so
so
this
is
a
very,
very
basic
class
program.
So
let's
talk
a
little
bit
about
ownership.
So
let's
say
I
have
let's
say:
I
have
I
have
a
variable
here.
It's
called
message:
basically,
it's
a
string.
So
ideally
I
can
do
anything
with
it.
So
I
would
say
now
this
message:
actually
the
main
function
owns
it.
The
main
function
owns
message
and
I
can
do
anything
with
it
so
because
I
own
the
because
I
own,
the
the
variable
so
I
can
print
this
no
problem.
B
B
So
now,
let's
say:
if
I
pass
this
variable
to
do
something
it
will
compile
it's
fine,
because,
basically,
what
happens
is
the
main
function.
Has
this
message
variable
and
we
when
we
say
we
pass
it
to
the
do
something
function?
Okay,
it's
like
I'm,
moving
this
bottle
to
Ivan,
so
I'm
moving
this
variable
to
him.
So
that's
fine,
but
if
I
try
to
call
do
something
again
with
message
so,
let's
say
just
to
say:
if
I
create
another
option
called
do
something
else.
B
Okay,
nice,
so
it's
if
I,
try
to
have
another
function
called
do
something
else
and
I
try
to
pass
it
to
do
something
else.
Now
you
see
the
compilers
started
to
tell
you
it's
kind
of
weak
at
first,
it's
a
value
move
here
and
it's
a
use
of
move
value
like
you
know,
use
after
move.
So
what
happens
is
the
main
function?
Has
the
ownership
of
the
message
variable
and
it
passed
the
ownership
to
the
do
something
function?
B
B
So
this
is
the
first
kind
of
like
pitfalls
where
it
took
me
a
long
time
to
to
understand,
because
this
kind
of
program
works
perfectly
fine
in
almost
any
programming
language
in
Python
golang,
whatever
they
work
but
But,
but
so,
but
so,
if
I
wanted
to
make
this
program
work
to
make
two
choices
which
it
comes
back
to
the
rules,
everything
in
Rust
everything
that
compiles
in
Rust
they
all
they
all
follow.
This
rule,
they
cannot
disobey
this
rule
so
just
now
I'm
trying
to
move
the
ownership.
B
So
let's
say,
if
I
want
to
pass
that
variable
to
two
different
functions
without
recreating
the
variable
so
I
cannot
move,
I
can
borrow
so
I
can
borrow
them.
The
variable
so
I'll
have
to
borrow
so
borrowing.
You
have
two
ways:
one
is
I
call
read
only
borrower
which
in
the
dogs
or
rust,
actually
they
actually
call
it
chat
reference.
So
basically,
if
you
know
C
or
C,
plus
plus
this
or
go
Lang,
it's
just
a
normal
reference.
It's
it's
nothing.
B
Special,
it's
just
reference,
but
something
I'm
very
special
to
us
is
that
they
have
mutable
reference.
This
is
like
read
and
write.
So
if
I
try
to
do
it
here,
instead
of
taking
a
string,
so
I
can
actually
take
a
reference
to
string.
So
let's
say
I
just
changed
the
first
function:
I
I,
don't
take
the
ownership
of
a
string.
I,
don't
pick
the
whole
thing.
I
just
want
a
reference.
We
just
I,
don't
need
anything
else,
I'm,
just
printing
the
message
doing
it
on
the
reference
is
fine.
B
So
actually
you
can
see
the
compiler
is
really
good.
It
tells
you
try
to
borrow
here
like
because
you
consider
boring
here
because
now
you're
not
passing
ownership,
now
you're
just
giving
it
a
reference
you're,
just
borrowing
it
so
borrowing
you
have
to
tell
the
compiler
okay
I'm
boring
this
message
out
now
the
compiler
is
Happy.
Everything
works
it
compiles,
so
I
can
just
try
to
run
this
and
see
it
printed.
Hello,
hello!
So
it's
fine,
and
if
and
here
I
didn't
do
anything
right,
I
can
also
take
just
a
reference.
B
It
will
be
fine,
it
will
compile
and
stuff
so
so
yeah.
So
it
will
compile.
It
will
work,
that's
fine,
but
what
if
today
I
wanted
to?
You
know
kind
of
change
the
message
so
let's
say
I
want
to
take
a
name.
So
let's
say
I
want
to
take
a
name,
or
maybe
let's
say
I'll,
just
if
I
wanted
to
take.
If
I
wanted
to
change
the
message
right
and
if
I
come
back
to
the
rules,
I
cannot
use,
read
only
problem
if
I
try
to
change
it
here.
B
B
B
Want
to
push
something
to
the
string,
so
let's
say
I
do
push
a
so
you'll
see
that
the
compiler
actually
started
to
tell
you
some
really
good
error
messages.
It
tells
you
I
cannot
borrow
message
as
mutable
as
because
it's
behind
a
this
is
what
we
call
a
shared
reference.
The
reason
being
I
cannot
push.
If
you
look
at
the
function.
Signature
here.
B
B
So
this
is
one
of
the
things
that
I
would
say.
It's
one
of
the
most
important
thing
that
we
have
to
know,
or
we
have
to
learn-
is
ownership,
so
no
explanation
so
so
yeah
so
talking
back
to
so
talking
back
to
Ross.
So
if
I
come
back
here,
let
me
just
go
back
to
the
slide.
So
if
I
come
back
here
like
this
is
just
one
thing
like
ownership
is
just
where's,
my
laser
pointer,
yeah.
So
audition
is
just
one
thing.
It's
a
lot
of
other
things
like
the
next
thing.
B
I
would
say
ownership.
You
must
get
it
and
then
the
second
thing
you
have
to
learn
is
about
lifetimes.
If
you
don't
know
about
it
at
first,
it's
kind
of
okay,
you
cannot
escape
from
Lifetime.
You
still
have
to
learn.
It
lifetime
is
a
whole
other
topic
which
I
don't
think
I
have
time
to
talk
about
it.
It
today,
but
yeah.
So
the
the
main
goal
today
I'm
trying
to
share
my
struggle
when
I
started
to
memorize
and
how
I
overcome
it.
B
Maybe
you
can
maybe
you're
a
pro,
but
most
of
us
can't.
So
what
should
we
do
then?
So
the
first
thing
I
would
say
just
write
programs
like
just
try
to
write
and
don't
be
afraid
of
the
compiler.
Even
if
the
compiler
yeah
you
just
let
her
just
let
it
yell
at
you,
because
it's
how
we
become
good
I
think
most
of
the
rust
engineer
would
agree
to
me.
It's
the
compiler
is
the
number
one.
B
The
number
one
reason
which
we
love
for
us
I
think
most
Rush
Engineers
would
agree
with
me.
Compiler
is
the
number
one
reason
and
the
compiler
will
help
you
to
learn
all
this
thing,
no
joke
like
they
will
help
you
to
learn
all
these
things,
because
from
someone
who
learns,
CRC,
plus
plus
I,
would
say,
C
or
C
plus
plus
has
a
very
good
compiler,
very
amazing
compiler,
because
they
can
optimize
code
in
the
machine
like
at
the
machine
code
like
very,
very
good.
B
That
is
why
a
lot
of
C
and
C
plus
code
is
still
now
here.
It
is,
but
then
they
don't
give
you
a
lot
of
information
like
see
or
C
plus
plus
rarely
gives
you
information
like
this,
like
they
really
give
you
kind
of
like
or
message
just
like
this
most
of
the
time.
It's
just
like
very
cryptic
error
messages,
and
sometimes
you
mess
with
the
memory.
It
tells
you
just
SEC
fault
or
something
like
you.
B
You
do
not
know
what
it
is
and
in
order
to
do
like
you
have
to
find
out
divide,
you
have
to
use
profiler.
You
have
to
do
just
forgot.
What
the
two
is,
there's
one
two
for
doing
memory,
stuff
thing
called
V
I,
don't
know
V1
yeah
valgrip.
You
have
to
use
valgrain
to
actually
inspect
and
and
see
what's
wrong,
but
rust.
Doesn't
the
compiler
tells
you
like?
It
actually
tells
you
what's
wrong.
B
B
Think
one
of
my
one
of
the
things
that
I
can
share
to
you
all
if
you're
trying
to
learn
Russ
is
that
in
Russ
there
is
actually
I
would
say:
Russ
has
a
very
fantastic
ecosystem
for
a
friendly
new
language.
It
has
a
lot
of
stuff
there
really
right
and
you
can
find
a
lot
of
like
really
good
things.
One
of
the
best
libraries
that
I've
ever
used
in
all
languages,
there's
one
Library
called
survey.
B
I,
don't
know
how
to
pronounce
it
so
today,
whatever
I
call
it
Sade,
it's
just
the
best
serialization
deserialization
Library
I've
ever
used
because
it's
it's
so
generic.
It
works
whatever
you
throw
it,
it
works.
If
you
want
to
deserialize
yamo
Json,
you
somehow
find
a
very
easy
way
to
do
it
in
Rust,
so
there's
actually
a
lot
of
like
libraries
already
there
in
Rust.
So
if
you
find
yourself
trying
to
write
something,
just
try
to
search
for
a
library
first,
most
of
the
time
it
will
be
there.
B
If
not,
then
maybe
try
looking
harder.
If
not.
If
it's
not.
There,
then
try
to
write
yourself,
but
I
would
say
as
a
beginner
don't
try
to
write
very
complicated
stuff
because,
as
you
are
starting
out,
you're
trying
to
learn
ownership,
you're
trying
to
learn
concept
of
like
lifetimes
and
stuff,
and
you
when
you
try
to
do
something
that
is
so
complicated.
The
compiler
trying
to
trying
to
when
the
compiler
tried
to
tell
you
it's
some
kind
of
error
messages
that
you
don't
understand.
B
It's
very,
very
difficult
to
understand.
I
would
say
just
don't
spend
too
much
time
fighting
the
compiler,
because
one
thing
that
I
find
is
the
compiler
is
always
right,
like
you
are
always
wrong,
like
I,
never
once
in
a
case
where
I
think
the
compiler
is
wrong
and
then
the
compiler
is
wrong.
No,
never
it's
always
I
think
the
compiler
is
wrong,
but
enough
I'm
wrong
and
then
the
compiler
is
right.
B
So
just
just
don't
try
to
curse
or
don't
try
to
fight
against
the
compiler,
because
my
experience
is
always
right,
but
maybe
you
can
find
something
wrong
in
the
rest.
Compiler
I,
don't
know
so
maybe
you're
better
than
me,
and
another
thing
is
Russ,
actually
has
a
very
good
Community.
Just
try
to
ask
around
so
one
of
the
one
of
the
story
that
I
can
share.
Here
is
last
time
I
tried
to
write
an
API
in
Russ
using
sqls
kind
of
stuff
and
then
I
stumbled
upon
a
library
called
SQL,
X
sqlx.
B
It's
a
super
amazing
Library,
I
hope
I
have
time
to
tell
you
how
amazing
it
is,
but
I
don't
have.
But,
but
when
you
face
problems
when
I
face
problems,
there,
I
just
immediately
go
to
the
GitHub
issues
and
just
posted.
You
know
posted
an
issue
there
and
the
community
is
quite
active.
They
are
willing
to
help
and
ended
up
I
I,
even
I
found
a
block
there.
I
was
so
surprised,
I
actually
found
a
bug
in
the
library
and
then
I
opened
a
PR.
It's
a
very
small
bug.
B
They
fixed
it
and
move
on,
but
try
to
not
step
away
from
asking
questions,
because
Russ
is
still
new.
So
a
lot
of
the
stuff.
When
you
face
you
try
to
do,
we
try
to
search
on
Google
or
stack
Overflow.
You
might
not
find
what
you
need,
or
you
might
not
find
what
you
want,
but
just
us
just
be
brave
to
us
and
then
and
then
also
one
thing
about
Russ.
Is
that
I
find
myself?
B
This
is
when
I
try
to
fight
the
compiler
every
time
I
try
to
fight
the
compiler
I
find
myself
writing
even
more
complicated
code.
Like
sometimes
I
wanted
to
write
just
one
very
basic
logic,
and
then
it
doesn't
compile
I.
Think,
okay,
maybe
it's
wrong!
Then
either
this
is,
it
doesn't
compile
I
think,
oh,
maybe
that's
wrong.
B
So
so
just
don't
try
to
fight
the
compiler
and
try
to
rethink
it
like
try
to
rethink
what
you're
doing
and
then
eventually,
you
find
oh
there's
a
better
way
to
do
this.
Oh
yeah,
and
so
these
are
some
of
my
some
of
my
two
cents
in
in
the
whole,
you
know
my
home
journey
in
learning,
Russ
and
stuff,
and
what
I
actually
learned
is
that
system
programmers
can
have
nice
things.
It's
it's
one
I
copy
this
code
from
one
of
the
books
that
I'm
reading
about
Russ.
B
Actually,
the
rust
ecosystem
is
really
good.
It
has
almost
everything
a
lot
of
stuff
cargo
built
we
take
for
granted.
If
you
do
golang,
you
can
do
go
build.
If
you
do
see
C
plus
plus,
you
have
to
go
through
C
make
file.
There's
ninja,
that's
Mason,
all
those
kind
of
stuff
just
to
get
your
code
to
build,
but
but
Russ
has
cargo
bill
and
it's
really
good.
It
works,
there's
a
lot
of
stuff
like
fantastic
macros
and
you
can
compile
your
code.
B
That's
one
of
one
of
my
biggest
complaints
towards
CRC
plus
plus
codes
is
that
they
use
different
compilers.
They
have
different
system
libraries
on
different
platform.
You
find
yourself
able
to
compile
this
code
in
Linux
and
then
you
try
to
compile
in
Windows.
It
doesn't
work
so,
of
course,
there's
this
case
in
Rust
as
well
like
in
some
very
Niche
case
because
of
the
uos
library
and
kind
of
stuff,
but
it's
very
rare.
It's
not
so
common
in
CRC,
plus
plus
and
in
Rust.
There's
a
lot
of
good
things
like
it's
re.
B
It
has
a
very
good
error.
Handling
I
would
say
good
enough
that
I,
actually
after
I
learned
Russ
I,
try
to
use
the
same
error,
handling
method
in
other
language.
It's
where,
if
you
learn
rise,
you
know,
there's
something
called
result:
type
which
is
very
fantastic
like
if
you
have
result
type
you
don't
need
to
use
now
and
when
I
come
back
to
typescript
and
I,
write,
typescript
I
make
my
own
result
type
and
it's
so
much
better
than
just
try
cash
so
much
better
than
just
throw
area
or
just
return.
B
The
null
value
and,
and
one
of
the
best
thing
is,
it
has
I
think
one
of
the
best
package
manager
after
npm.
It
works
sort
of
like
npm
and
it's
very
similar
to
npm
it's.
But
but
it's
very
good.
If
you
try
to
do
CRC
plus
before
you
actually
have
to
manually
download
that
code
put
it
in
your
code
base,
render
it
and
then
put
it
into
your
boom
system,
but
with
Russ,
just
cargo
app
or
just
add
it
to
the
Tomo
file.
Then
it's
there
so
yeah
system.
B
Programmers
can
have
nice
things
because
a
lot
of
system,
programmers
we
work
with
C,
C,
plus
plus
we
are
used
to
having
like
very
bad
tooling,
but
for
us
just
change
all
that
it
has
very
good,
tooling
and
At
Last
I,
just
wanna.
This
is
what
I
did
when
I
was
trying
to.
You
know
just
summarize
my
experience
with
the
top
languages
that
I've
worked
with
before
so
I'll
start
with
python,
because
it's
the
first
language
that
I've
learned
and
back
then
I
wrote
python
like
this
back
then
in
2022.
B
B
It
has
a
lot
of
stuff
that
I
don't
understand
what
I
wrote
now,
but
but
yeah
python
is
very
good
for
very
simple
stuff.
It's
good
in
terms
of
error
handling,
it's
not
there!
Oftentimes
you
have
to
do
you
have
to
make
choices
either
you
want
to
return
now
a
return,
none
in
Python.
They
call
it
none
or
you
have
to
throw
an
error.
B
Then
you
have
to
try
catch
I,
don't
think
it's
good
I,
don't
like
it,
because
if
you
don't
try
catch
something
it
just
the
program
just
crashed
and
comparing
to
typescript
go
C
plus
Ross
generally
I
find
that
better
handling
in
grow
in
Rust.
Actually,
the
first
thing
that
I
Like
It
Go
is
about
its
error
handling,
because
the
convention
is
that
will
always
return
an
error
alongside
the
value,
the
return
type.
B
So
it
kind
of
forces
you
to
take
care
of
the
error
which
the
other
language
doesn't
force
you
to
and
Ross
is
kind
of
similar
in
a
way.
It
does
also
force
you
to
take
care
of
your
area.
Of
course
you
can
ignore
it,
but
you
have
to
take
care
of
it.
So
you
cannot
just
I
forget
about
it.
Then
later
I
only
come
back
and
deal
with
it
like
most
of
the
time
you
come
back
and
do
it
later.
B
Actually
you
did
not
deal
with
it
and
then
it
got
to
production
and
then
it
crashed.
So
that's
my
experience,
so
I
say
tooling
is
another
thing
that
is
very
good
at
rust,
and
the
expressive
syntax
is
what
I
wanted
to
go
into
a
little
bit.
I
know
I'm
running
a
little
bit
running
out
of
time,
but
Russ
syntax
is
complicated,
I
don't
deny,
but
it's
because
it's
complicated
it
allows
you
to
do
crazy
stuff,
like
crazy,
crazy
stuff.
B
There's
like
I
talk
about
web
assembly
right
when
there
are
people
now
trying
making
effort
to
make
UI
Frameworks
in
Rust
allows
you
to
write
web
page
in
Rust
and
the
good
thing
is.
You
can
write
HTML
in
Rust
like
it's
valid,
it
will
compile.
If
you
miss
like
a
HTML
tag,
it
will
have
compiler
error
and
stuff
it's
possible
because
of
macros,
so
it
has
a
lot
of
like
very
good
syntax.
Another
thing
is
match
like
pattern.
Matching
it's
very
good,
because
I
don't
have
to
deal
with
switch
cases.
B
I
don't
have
to
deal
with
a
lot
of
if
else
and
and
yeah.
So
while
golang
is
a
very
good
language,
I
like
it
a
lot,
it's
syntax
is
not
as
hackable
I
would
say:
it's
not
as
expressive
there's
a
lot
of
boilerplate
you
have
to
write
and
productivity
is
another
thing.
Another
thing
that
people
say
you
know:
Russ
is
bad
at
I,
don't
deny,
because
when
you
try
to
start
like
when
you
try
to
learn
rust,
it's
not
productive
because
you
have
to
deal
with
compilers.
B
B
It's
it's
pretty
good,
it's
not
as
bad,
but
if
you
want
to
compare
it
to
python
typescript,
of
course
they
have
better
libraries
than
for
us,
because
Ross
is
still
fairly
new,
but
but
it's
there
so
so
this
is.
This
is
for
us.
This
is
my
comparison.
It's
not
it's!
Not
it's
not
everyone's
favorite
or
it's
not
it's
just
my
preference.
So
you
might
find
you
know
you
don't
agree
with
this
kind
of
table
some
things
that
you
don't
agree
with.
It's
fine,
that's!
Okay!
B
But
lastly,
what
I
wanted
to
tell
is:
there
are
a
few
things
that
I
really
excited
for
the
whole
rust
Community,
because
there's
a
lot
of
stuff
in
like
in
Rust,
it's
still
growing
and
it's
very
fast
and
there's
some
stuff.
That
I
put
here
like
webassembly
and
Wazee
is
another
thing
that
I'm
looking
at
it's
it's
like
very
Cutting
Edge
technology,
but
it's
people
are
already
working
on
on
it
in
Russ
and
I
hope.
B
You
know
we
can
see
more
stuff
like
that
and
then
there's,
maybe
not
many
people
don't
know
about
this.
But
xylem
is
a
fairly
new
framework.
It's
a
UI
framework
in
Rust.
Where
imagine
you
can
write
cross-platform
apps,
but
without
using
flutter,
but
you
can
and
you
enjoy
the
same,
very
simple
apis,
it's
what
the
silent
project
tries
to
get
and
then
this
EVT
is
one
thing.
It's
just
one
of
the
very
rare
things
that
I
have
to
complain
about
Russ,
but
it's
kind
of
advanced
topic.
B
It's
it's
a
I
hope
they
bring
this
to
the
language,
but
I
don't
know,
let's
just
see,
but
these
are
some
of
the
stuff
that
I'm
excited
for
the
language
which
I
think
it
will
grow
into
in
the
future.
So
so
yeah,
that's
I,
think
that's
all
for
my
talk
and
just
a
little
bit
more
summary.
As
a
student
learning
Russ
number
one.
It
helped
me
to
solidify
my
computer
science
fundamentals,
a
lot
of
the
stuff
like
ownership,
that
I
talked
just
now
that
I
shared
with
you
all
they've.
B
Actually
it's
about
memory
management
and
we
all
learn
about
memory
management
in
school
or
somewhere
else,
but
we
don't
actually
understand
it
but
learningwise.
It
helped
me
to
really
understand
it
and
know
how
to
deal
with
it
and
I
would
say.
Russ
helps
us
to
write
software.
The
safe
way,
not
paper,
probably
not
the
right
way,
because
right
is
very
subjective
but
write.
B
It
write
it
the
safely,
because
you
can't
actually
write
unsafe
code
in
Russ
and
a
lot
of
the
stuff,
and
it's
it's
one
of
the
very
good
benefits
that
it
trained
me
to
pre-play.
So
I
have
this
bad
habit
where
I
have
an
idea,
I
just
hop
onto
it,
I
just
write,
but
in
Russ
you
can
still
do
that,
but
you
have
to
face
a
lot
of
like
compiler
errors
and
stuff
you,
you
kind
of
have
to
plan
ahead
a
little
bit
before
you
write
rust.
B
So
so
it's
some
of
the
things
that
that
helped
me
from
my
journey
learning,
Russ
and
and
yeah.
It's
have
a
very
good
Community
as
well.
So
basically
that's
my
sharing
about
Russ
and
I'm
curious.
If
there's
anything
that
you
all
want
to
ask
or
anything
that
we
can
discuss
about
and
regarding
Ross
I
think.
D
C
B
I
would
say
pick
something
that
you
are
familiar
with.
So
let's
say
if
you
are
familiar
with
writing
apis
in
golang,
try
to
write
API
in
Rust
as
well,
because
the
concept
still
applies.
It's
just
some
language
features.
It's
not
it's
different,
so
you
kind
of
learn
to
adapt
them
and
I
would
suggest
you
to
start.
If
you're
like
completely
new.
Apart
from
the
Rust
book,
like
the
official
Rust
book,
it's
really
a
good
place
to
learn.
I
normally,
don't
read
like
when
I
run,
learn,
go
or
whatever
other
language.
A
B
So
it
solves
memory
issues
mainly
so,
if
you
are
familiar
there's
something
called
dangling
pointers
where
you
try
to
access
a
variable
that
has
gone
out
of
scope
or
like
being
dropped
or
something
it's
very
common
in
CFC
plus
first,
but
because
of
ownership
rules,
you
fundamentally
cannot
do
that,
invest
yeah.
So
this
is
one
of
the
things
that
ownership
solves,
but
mainly
it
solves
memory
issues,
I,
understanding
that.
A
Why
does
it
need
to
do
that
because,
like
that's,
called
the
automated
automated
memory,
so
they
are
before
us
to
make
this
popular?
There
are
two
kinds
of
memory:
Concepts
yeah
one
is
called
the
manual
memory,
management
and
I
see
we
have
to
allocate
memory
yourself
and
then
free
and
then
the
other
kind
of
memory
management
is
the
using
garbage
collector.
B
A
Garbage
collected
you,
there
will
be
a
program
that
like
stop
the
world
and
stop
everything,
then
you
see
like
they
consists
quite
a
bit.
If
you
do
a
PSO
that
have
a
lot
of
people
that
use
it
and
then
the
calculator
you
go
and
collect
the
rubbish
and
then
go
and
remove
it
yeah.
But
for
us
that
this
concept
is
not
new,
but
this
thing
they
call
it
automated
memory
management,
so
they
tie
the
scope
like
python,
there's
a
big
block
right
context
manager.
A
So
they
apply
that
to
the
Target
the
scope
to
the
lifetime
of
objectives,
so
they
call
it
Lifetime
and
then,
if
the
ownership
and
lifestyle
are
tied
together
it
can
it
can
decide
when
to
free
the
memory
and
then
or
when
to
destroy
objects
or
when
to
create
them
without
a
rubbish
collector.
So
like
once
that
once
the
once
the
variable
go
out
of
scope,
it
will
be
allocated
and
then
you
know
when
visit
is
located
and
then
there
is
no
double
collector.
A
A
For
you,
like
you,
don't
have
to
worry
about
all
of
that
like
in
in
Python.
If
you
don't
use
the
read
block
you
just
open,
and
then
you
close,
if
you
forget
the
course,
you
get
warming.
If
you
unable
to
that
that
mode
and
then
you
can
go,
if
you
forget
to
write
a
paper,
you
also
like.
We
also
have
faced
some
issues
but
erase
that
these
all
are
handled
by
the
compiler
yeah
yeah.
C
B
The
lifetime
is
kind
of
like
I
think
it
has
a
very
interesting
name,
because
what
lifetime
means
is
how
long
this
variable
will
leave.
So,
like
you
mentioned
about
scope,
it's
correct,
it
does
have
to
do
it
has
to
do
with
Scopes.
So
let's
say
within
this
mean
function:
I
have
another
function,
which
is
called,
let's
say
called,
do
something
another
function
there
so
I
declare
a
variable
inside.
B
Do
something
I
declare
it
inside
that
function,
so
this
phone,
this
variable
the
lifetime
of
this
variable-
will
just
be
within
that
scope
of
the
do
something
function,
because
when
it
goes
out
of
scope
the
variables
is
destroyed.
That
means
the
variable
is
dead,
so
the
lifetime
has
and
and
then
come
back
to
the
main
function.
So
basically,
lifetime
is
something
that
tracks
if
a
variable
is
used
where
it's
not
supposed
to
be
used.
B
Kind
of
like
that
to
my
understanding
is
kind
of
like
that,
like
you
can't
declare
a
variable
and
do
something
function
go
out
of
it
and
then
try
to
use
it
again
with
ownership.
It
actually
cannot
do
that,
but
lifetime
is
to
protect
against
references
because
there's
no
like
you
can
pass
references
freely
around,
but
some
of
the
times
in
Rust
you
find
that
you
have
to
explicitly
tell
the
compiler
okay.
This
reference
is
only
valid
from
here
to
here
and
then
and
then
the
compiler
will
check.
Okay.
B
D
D
B
I
love
gold
because
of
go
routines.
It's
so
simple.
Every
time
you
can
just
spawn
a
gold
routine,
and
then
you
need
to
share
data,
just
do
a
channel
and
then
it's
so
simple,
but
I
haven't
dive.
A
lot
into
you
know
different
type
of
concurrency
models
in
Russ.
The
way
that
I
do
concurrent
program
now
is
is
the
exact
same
way.
How
I
did
it
in
Google,
because
in
Rust
there
is
this
thing
called
channels
which
is
same
in
in
goal,
but
Russ.
They
have
different
types
of
channels.
They
have
mpsc
channels.
B
One
shot
Channel
broadcast
channel
where
different
channels
have
different
properties
like
mpsc,
is
like
multiple
producer
single
consumer.
So
you
can
send
a
lot
of
people
can
send
stuff,
but
only
one
people
can
consume
which
this
kind
of
restriction
doesn't
exist
in
cool.
If
they
have
not
changed
anything
I,
remember,
it
doesn't
exist
there
like.
B
Long
as
you
try
the
same
thing
and
then
someone
is
listening,
then
it
will
work.
So
I
would
say
the
concurrency
model
now
that
I'm
using
is
very
similar,
but
in
Russ
the
good
thing
about
the
channels
and
and
doing
you
know,
concurrency
programming-
is
that
they're,
quite
Fearless
concurrency
because
of
rust
is
so
strict.
It
has
all
the
ownership
rules
the
lifetime
rules
that
fundamentally,
it
prevents
90
of
the
data
right.
B
The
data
racing
problems,
I,
would
say,
I
wouldn't
say
100
there
will
still
be,
but
it
prevents
a
lot
of
the
data
races
issues
like
in
go
right.
You
can
easily
write
a
lot
of
gold
routines.
You
try
to
share
memory
between
them.
You
did
not
use
new
tags,
you
did
not
use,
read,
write
logs
and
then
you
run
into
database,
and
then
you
or
you
won't
run
into
that
log,
but
your
your
program
still
compile
very
nicely
no
problem,
but
in
Rust.
B
If
you
have
problems
like
this,
like
that
loud
Source
or
some,
you
know
data
races
most
of
the
time
the
compiler
will
catch
it
and
you
can't
compile
the
code.
So
that's
why
getting
your
code
to
compile
gives
you
a
very
high
security,
like
not
security,
it
gives
you
a
very
high
guarantee
that
your
code
Works
in
production,
but
not.
A
Get
that
locks
I
do
get
that
yeah.
You
can
get
that
locks,
but
you
don't
from
what
I
heard
you
don't
get
data
results,
because
it's
soft
that
data
races
show
through
the
ownership
at
lifetime
in
other
languages,
I
believe
that
you
can
still
get
data
races,
even
even
with
the
ultimate.
Even
if
the
government
is
like
the
kind
of
thing,
because
it
doesn't
have
a
scope
and
the
ownership
to
help.
You
tell
you
when
to
use
a
variable
event
or
not.
B
B
A
Yeah
I
guess
I'll
bring
it
here.
So
thanks
a
lot
for
coming
to
the
Russia
and
I
think
there
are
some
foods
here.
Okay,
just
done
it
and
the
this
Meetup
beholding
every
Twitter
again
for
those
that
are
new,
this
middle
will
hold
it
every
two
months
we
started
in
like
around
2020
and
then
we
do
it
for
one
two
years
actually
around
two
years,
then
we
stopped
doing
NCO.
Then,
since
last
year
we
started
doing
online
data
and
then,
but
now
we
come
back
to
do
offline
medium.