►
Description
The Rust language is more than ready for production–it excels at it! The Habitat project team has been using Rust for a year in public and an extra year in stealth. With over 40,000 lines of Rust code so far, we maintain multiple CLI applications, a cross-platform process supervisor, a gossip subsystem, and a micro service-oriented distributed build system.
In this talk we will cover some of the challenges that Rust is uniquely qualified to address including static compilation, inlining dependencies, using clap for CLI parsing, pragmatically using native C libraries, maintaining a common codebase for Linux, Mac, and Windows, and on-boarding new Rustaceans. Have no fear: there has never been a better time to use Rust for your next service, application, or tool!
Fletcher Nichol
https://twitter.com/fnichol
https://github.com/fnichol
https://users.rust-lang.org/users/fnichol/activity
A
All
right,
so,
let's
get
this
out
of
the
way.
This
is
probably
all
you
need
for
this
talk.
If
you
want
to
just
take
the
word
of
somebody
who's
on
stage,
Russ
is
ready
for
production.
We
can
move
on
if
you
need
to
be
further
sold
or
if
you
have
co-workers
or
employers,
that
that
kind
of
need
a
little
more
information
than
somebody
on
stage
saying.
Yes,
that's
kind
of
that's
that's
my
reason
for
being
here,
so
my
name
is,
is
Fletcher
you
can
get.
You
can
reach
me
at
all.
A
These
places
on
the
internet,
which
is
like
blue
on
black,
which
isn't
terribly
good.
I'll,
have
the
slide
deck
up
afterwards
and
I
have
it
on
my
my
lanyard,
and
if
you
see
me
today,
I
look
like
this,
so
I
I'm,
here,
I
guess
by
way
of
the
project
that
I've
been
working
on
for
almost
the
last
two
years
called
habitat.
A
We
kind
of
publicly
launched
this
in
June
last
year,
so
it's
coming
up
on
it's
one
year,
anniversary
of
kind
of
being
in
the
open.
We
were
working
on
it
for
almost
a
year
sort
of
Ian
stealthy
mode.
Always
knowing
that
we
were
going
to
flip
the
open-source
bit
at
the
end
and
do
the
kind
of
big
reveal,
so
the
entire
project
is,
is
open
source
and
it's
under
the
Apache
v2
license.
So
there's
right
now,
there's
not
really
any
private
repos
that
we
have.
A
We
have
one
for
some
of
our
infrastructure
for
like
the
little
bit
of
terraform.
We
need
and
the
rest
is
there
for
you
to
see.
So
this
talk
isn't
exactly
about
habitat,
but
I
thought
I
would
try
to
do
the
like
two-minute
version
of
what
habitat
is.
It's
a
large
thing.
It's
a
large
code
base
so
really
at
its
core.
It's
it's
a
it's
a
runtime
system
that
helps
your
apps.
A
So
if
I
need
to
change
the
the
mode
or
the
behavior
of
my
application,
kind
of
live
like
I
need
to
bring
something
offline
or
I
need
to
rotate
a
key
there's.
A
way
to
kind
of
dynamically
apply
a
new
configuration
in
a
way
that
would
be
like
a
software
upgrade
and
again
have
your
your
services
react
to
that
in
an
appropriate
way.
And
finally,
it
also
includes
a
build
system
which
helps
you
to
kind
of
wrap
your
package
up
in
a
kind
of
deterministic
way
that
captures
all
of
the
requirements
that
your
app
needs.
A
All
the
software
that
it
needs
to
run
all
the
software
that
you
need
to
build
itself
and
then
at
run
time,
any
services
that
it
might
depend
on
that
it
might
need
to
get
its
work
done
it.
So
this
this
is
something
that
I've
been
kind
of
focused
on
for
the
last
few
weeks
and
will
be
for
a
while.
I
want
to
make
sure
that
habitat
loves
your
apps
we've.
A
We've
been
doing
lots
of
work
to
make
sure
that
we
have
sort
of
a
baseline
of
software
and
services
ready,
but
I
have
been
interested
in
habitat
for
running
my
software
and
that's
what
we
want
to
provide
to
everybody
else
and
the
large
parts
most
of
the
code
base
happens
to
be
in
rust,
which
is
which
is
why
I'm
here.
So
our
website
kind
of
looks
like
this
and
again
this
blue
and
black
should
have
caught
that
at
a
time.
But
again
the
slides
will
be
online,
its
habitat,
SH
and
dot.
A
Sh
Y
well,
there's
some
shell
code
in
there
too,
so
so
Y
rust.
Why
choose
rust
for
for
a
new
project
like
this,
especially
one
that
grew
to
be
somewhat
large,
something
that
we
work
on
for
a
long
time
that
we
weren't
guaranteed?
Was
you
know,
going
to
resonate
with
people?
So
why
do
we
take
a
chance
on
on
rust?
This
question
comes
up
quite
a
lot.
A
A
So
the
there's
there's
a
few
reasons
for
it:
some
of
the
history
going
back
the
original
kind
of
idea
and
the
prototype
of
what
habitat
became
was
written
by
the
chef
founder,
Adam
Jacob
had
wrote.
Some
of
the
original
stuff
I
came
in
basically
myself
and
one
other
developer,
and
the
three
of
us
worked
on
it
for
a
while
and
kind
of
took
it
forward
to
it
to
a
certain
point
and
the
mcgerr
the
team
from
there.
But
the
original
codebase
was
written
in
rust
and
so
at
the
heart
of
habitat.
A
Is
this
process
supervisor,
so
we
we
call
it
the
supervisor
and
if
we
need
a
short
way
to
describe
it,
we
just
do
su
pee
I
like
to
pronounce
that
soup
and
I
always
think
of
a
can
of
soup.
So
this
at
its
core
is
like
supervising
another
process
or
it's
like
spawning
a
child
and
that
child
happens
to
be
your
application
or
your
service,
or
something
like
that.
A
So
if
anybody
has
used
other
like
system
and
it
processes
or
process
supervisors,
these
tend
to
be
written
in
C
at
the
end
of
the
day,
kind
of
doesn't
matter
how
new
or
old
it
is.
It's
a
C
or
C++
kind
of
codebase,
and
there's
lots
of
good
reasons.
For
this
and
similar
things
we
wanted
with
with
habitat,
is
a
supervisor
that
doesn't
hopefully
consume
more
memory
than
the
process
is
supervising
and
like
will,
you
know,
eat
up
all
that
memory.
A
A
A
So
we
have
a
lot
more
software
in
in
habitat
now
and
that's
just
sort
of
grown
over
time
because,
as
we
sort
of
grew,
the
code
base
and
split
libraries
off
and
made
other
components
and
services,
you
start
to
get
these
small
libraries.
You
know
some
code
to
parse
our
packaged
identifiers
and
to
install
packages
and
do
these
sorts
of
things.
So,
after
a
certain
point,
making
the
little
web
service
to
you
know,
handle
and
upload
like
you've,
already
got
30%
of
the
functionality
in
these
little
reusable
libraries.
A
So
it's
easy
to
just
write
a
little
bit
more
rest,
and
this
wasn't
I
think
originally,
where
we
thought
things
would
go,
but
it's
actually
been
really
great
to
have
kind
of
one
dominant
language
throughout
the
code
base.
So
for
new
contributors,
if
they've
got
one
language,
there
they're
basically
kind
of
ready
to
go,
whether
that's
just
client-side,
tooling
or
the
process
supervisor,
or
dealing
with
our
with
our
gossip
implementation
or
doing
web
programming
on
like
our
back-end
build
service.
It's
kind
of
all
the
same
language.
A
This
was
sort
of
an
added
bonus
for
me
was
the
kind
of
using
rust
to
make
CLI
or
console
based
tools.
It
is
very
good
at
making
you
know,
compile
targets
for
different
systems,
we're
not
using
a
lot
of
cross
compilation
right
now
in
the
habitat
project.
We're
largely
doing
builds
on
the
native
platforms,
so
our
sort
of
main
habitat
program
we're
doing
compiles
on
linux
and
mac
and
windows,
and
it
it
feels
really
good
and
you
get
really
nice
kind
of
output
it
at
the
end.
A
So
for
the
sort
of
the
main
parts
of
habitat
that
are
written
in
Russ,
we
have
our
supervisor
this
have
CLI
or
program.
So
it
would
be
the
thing
that
you
would
download
onto
your
laptop
to
start
playing
with
it
or
to
build
packages
locally
or
the
things
that
you
would
install
like
on
a
server
or
in
a
container
to
like
spawn
the
supervisor
and
get
your
software
installed.
So
it's
kind
of
like
it's,
it's
the
small
seed,
it's
the
small
seed.
A
We
could
get
that
like
germinates
into
whatever
habitat
environment,
you
kind
of
need,
and
we
also
have
this
distributed,
build
system
that
knows
about
the
how
to
make
habitat
packages
and
how
to
do
like
recompiles
of
things
in
a
proper
order
and
that
kind
of
thing.
We
also
have
a
package
hosting
repository
because
we
have
sort
of
a
packaging
system.
So
you
got
to
put
those
somewhere
and
that's
our
depot
service,
that's
kind
of
part
of
builder
and
it's
a
it's.
A
A
growing
codebase
I
took
this
I
think
this
week,
trying
to
figure
out
how
many
lines
of
rust
code
there
are
some
generated
rust
code,
which
is
like
I,
guess
it's
sort
of
we're
responsible
for
it.
But,
like
you
regenerate
it
and
forget
it.
So
it's
not
to
say
that
a
human
being
has
written
like
80,000
lines
of
rust
code,
but
we're
probably
in
the
40
to
50,000
line
range
would
be
my
guess
so
we're
using
kind
of
rust
to
our
advantage
in
a
few
places.
A
So
one
of
them
is
our
ability
to
use
native
libraries.
So
by
that
I
mean
libraries
that
may
not
have
been
written
in
rust
and
that
might
be
well
known
for
the
functionality
that
they
provide,
and
this
is
a
sometimes
a
complicated
thing,
depending
on
the
language
that
you
choose.
Whether
this
is
an
easy
thing
to
do
or
is
really
hard
or
if
you
in
the
worst
case,
incur
like
a
cost
to
actually
use
something.
A
That's
not
like
in
a
managed
runtime,
so
in
habitat
we're
using
the
Lib
archive
project
when
we're
extracting
our
package
format.
It's
you
know
like
in
a
compressed
tar,
ball
format
like
under
the
covers,
and
we
you
know
we
do
some
extraction
and
some
streaming
to
read
metadata
and
that
thing
all
our
crypto
stuff
we're
using
lib
sodium
for
generating
keys
and
doing
symmetric
encryption
for
for
our
gossip
stuff.
A
The
only
place
we're
not
using
the
sodium
for
at
the
moment
is
talking
to
a
cell
naval
two
web
servers.
We
use
zero
and
Q
in
a
few
places
in
our
gossip
system.
That's
how
we
get
the
kind
of
configuration
updates,
so
I
called
this
rumor
propagation
if
anyone's
done
any
gossip
stuff.
That's
that's!
How
we're
doing
a
rumor
propagation
and
to
communicate
with
some
of
the
backend
service
stuff
between
the
components
and
route
messages,
so
there
is
some
open
ssl
in
there.
A
We
have
been
whittling
that
down
over
time
right
now,
it's
only
function
is
to
talk
to
TLS
or
SSL,
enabled
web
servers,
and
that's
really
our
build
Depot
and
github
I.
Think
right
now.
So
I've
got
this
on
my
my
to
do
list
to
replace
this
with
rust
TLS
and
then
we
can
drop
open
a
Cell
as
a
dependency.
So
anytime
is
a
vulnerability.
The
habitat
project
is
rebuilding
and
making
new
open
SSL
packages
for
everybody
else,
so
that
they
become
vulnerability
free,
but
it'll
be
great
that
we
don't
additionally
have
to
like
build
ours.
A
First,
to
give
people
like
a
refresh
set
so
static
compilations.
Another
thing
that
ended
up
being
a
killer
feature
that
I,
don't
think
I,
don't
know
how
much
attention
it
gets.
It
was
something
I
spent
an
awfully
long
time
on
at
a
certain
point,
because
we
were
doing
this
kind
of
in
secret.
It
was
something
I
wanted
and
it
was
tricky
to
figure
out.
I
know
that
some
people
have
now
blogged
about
it,
which
is
which
is
great.
A
So
you
don't
necessarily
need
to
understand
everything
on
here,
but
normally
the
way
that
you
would
build
a
rust,
crate
or
project
is
with
the
the
cargo
build
and
if
you're
doing
this
for
production
release,
you
just
add
the
release,
which
does
a
few
things.
What
you
get
at
the
end,
I'm
just
calling
the
the
file
program
on
on
Linux.
So
it's
basically
getting
me
the
the
the
binary
format
and
some
of
the
characteristics
about
it.
So
I
can
tell
what
it
is.
A
A
So
this
is
where
muscle
comes
in
for
us
that
sort
of
help
with
this
static
compilation
thing
so
muscle,
is
it's
a
Lib
C
implementation
so
similar
to
G,
Lib,
see
or
similar
kind
of
things
it's
supposed
to
be
most
ish
compatible
by
and
large.
It's
it's
pretty
good.
It's
used
in
some
more
popular,
smaller
os's,
so
a
lot
of
like
smaller,
like
router
based
OS,
is
I,
know.
Alpine
Linux
uses
that
as
a
slip
C
core
and
that
kind
of
thing,
and
then
awesome
thing
about
this-
is
with
the
rest
compiler.
A
They
have
this
concept
of
like
a
target
triple
so
kind
of
my
understandings.
It
kind
of
comes
from
the
LVM
target
triple
so
normally
in
Linux
you'd
have
the
Linux
good
new
I
think
for
the
for
the
julep
C,
maybe
I've
stuff,
there's
a
special
target,
though,
for
muscle
and
by
default.
What
you
get
from
that
is
static,
builds,
so
there's
extra
stuff
you
need
to
do.
You
need
to
either
compiler
install
muscle
on
the
system.
A
A
So
they
pass
the
right
things
down
to
Rusty,
which
goes
through
the
linker
and
that
kind
of
thing
and
what
you
get
at
the
end.
If
you
call
file
on
the
same
thing,
is
this
statically
linked
line
in
file
which
the
first
time
I
got?
That
I
was
like
so
excited,
because
then
you
try
ldd
and
you
see
like
it's,
not
a
dynamic
executable,
there's,
nothing
else
that
it
needs
and
kinda
at
the
end.
A
This
is,
after
our
habitat,
build
system
by
default,
we'll
call
strip
at
the
end,
to
do
just
further
crunching
down
and
removing
of
things.
So
we
get
kind
of
like
an
eight
megabyte,
ish
binary
out
of
it,
that
you
can
drop
on
any
64-bit
Linux,
at
least
for
this
one.
That's
like
the
Linux
kernel,
I
can't,
remember,
2.6,
point
32
or
something
and
up,
and
it
basically
works,
which
is
pretty
awesome,
so
I
would
say
for
for
people
who
have
looked
at
go
for
exactly
this
kind
of
thing
like
a
static,
relocatable
binary.
A
You
can
totally
do
this
in
rust.
It's
just
not
like
you
know
the
top
three
like
feature
set,
so
we
do
a
few
things
different
in
the
habitat
project
and
I've,
seen
in
some
of
the
other
ones
and
there's
some
kind
of
reasons.
Why
so
one
of
the
patterns
that
we're
doing-
and
this
is
a
bit
of
a
reaction
to
other
projects
that
we've
been
involved
with
in
the
past,
especially
ones
with
like
many
many
code
bases
and
in
a
really
early
stage
project.
A
We
kind
of
right
now
have
like
almost
all
of
habitat
is
in
one
git
repo,
which
might
scare
some
people,
but
definitely
when
we're
working
on
new
features
or
stabilizing
things
or
refactoring
is
so
nice.
So
this
is
kind
of
a
Factory
listing
in
our
habitat
projects.
We
have
a
directory
called
components
which
will
either
map
to
like
a
rust,
crate
or
a
binary
program,
but
it
might
be
like
our
habitat
studio
is
actually
written
in,
like
busybox
shell
code,
which
nobody
knows,
because
it's
just
we've
kind
of
hidden
that
that
requirement
away
from
you.
A
So
most
people
don't
know
that
or
care.
We've
got
like
this
ruby
gem
in
there
and
a
few
other
things,
so
these
are
largely
rust
crates
with
a
cargo
tunnel,
but
not
all
them
are,
and
this
has
helped
us
when
we're
doing
builds
with
like
the
supervisor
in
the
CLI,
like
we
have
lots
of
common
dependencies,
including
internal.
You
know
crates
of
our
own
and
there's
this
nice
feature.
I
can't
remember
when
this
landed,
but
I
remember.
A
When
we
found
out,
we
were
using
cargo
nightly
for
just
a
little
while
to
get
this
cargo
workspaces
feature
which
is
a
way
to
have
more
than
one
like
rust,
create
share
a
common,
lock
file
and
then
put
all
their
sort
of
build
output
in
one
shared
directory.
So
it
means
that
you're
in
theory
only
building
that
crate
once
for
the
benefit
of
like
everything
else
that
you're
building
along
so
our
cargo
toma
on
the
route
of
our
project
is
a
it's
a
little
strange.
A
It's
just
got
this
workspaces
entry
with
a
members
list
and
it's
basically
all
the
rust
crates
that
we've
got
under
there
and
then
in
this
is
one
of
our
crates
underneath
so
a
line
for
or
sorry
five.
The
last
line
just
shows
like
a
parent
directory.
A
couple
parent
directories
up
to
say
like
this
is
my
my
workspace
route,
where
the
cargo
lock
is
and
where
I
want
all
the
build
stuff
to
go,
and
that
has.
I
can't
remember
what
that
did
to
our
build
times.
A
But
it
was
like
a
4x
speed-up
over
what
we
were
getting
for
stuff
and
that's
why
we
were
consuming
nightly
for
a
little
bit
on
that.
So
similar
we've
taken
lots
of
try
to
model
lots
of
patterns
and
ideas
off
the
the
rust
core
team
in
the
way
that
they
do
releases
so
our
or
the
the
stuff
that
isn't
kind
of
like
server-side
service
stuff,
we're
doing
basically
a
rolling
release
style
of
like
we
try
to
do
on
a
regular
enough.
A
Cadence
just
do
a
release
and
when
stuff
is
there
and
ready
it's
good
and
if
there's
a
feature,
that's
not
quite
ready.
If
we
can
feature
flag
it
and
sort
of
like
land
it
and
enable
it
when
we
want,
that's
been
working
pretty
nice.
What
it
means
is
most
of
these
components,
though
we
just
want
them
to
share
the
same
version,
because
it's
kind
of
like
the
same
set
of
packages
at
the
end.
So
we
ended
up
doing
this
with
a
little
bit
of
this
has
taken
us
a
little
bit
of
work.
A
We
used
to
have
the
same
version
and
are
all
these
cargo
tunnels.
So
release
was
like
editing
a
lot
of
these
files
and
not
forgetting
one.
What
we're
doing
now,
though,
is
basically
using
a
common
build
script,
which
is
a
little
rust
program
that
gets
built
before
the
rest
of
your
crate
gets
compiled
it.
A
And
then
we
write
that
that
string
out
to
just
a
file
in
this
outdoor
directory
and
that's
just
something
that
cargo
provides
with
an
environment
variable.
So
you
can
have
a
place
that
you
can
like
pick
up
files
later
once
you've
once
you've
built
this.
When
you're,
when
you're
doing
your
compilation
and
the
read
version
is
basically
just
reading
a
plain
text
file,
a
couple
directories
up.
It's
just
called
version
for
us
and
it
just
reads
the
contents
and
that's
our
like
semantic
version
and
then
in
our
in
our
code
bass.
A
We're
also
bucking
a
little
bit
of
a
trend
and
I
thought
it'd
be
worth
spending
a
second
to
explain
if,
if
you're
interested
in
habitat-
and
you
go
looking
in
our
crates,
you're
going
to
see
like
an
awful
lot
of
just
wild
card
stars,
you're
going
to
say
that
is
not
what
you're
supposed
to
do,
which
I
think
normally
speaking.
Yes,
that
is
not
probably
what
you
should
be
doing
and
I
think
there
are
some
linting,
especially
on
crates,
I.
A
Think
when
you
publish
it
will
warn
you
and
say,
like
you
probably
shouldn't,
do
this,
what
we're
doing,
though,
under
the
hood
again,
sharing
that
one
lock
file,
which
is
being
versioned
along
with
our
software,
is
this
is
thinking
of
our
code
based
less
as
a
library
and
more
as
like
an
application.
In
that
sense,
this
allows
us
to
be
a
little
bit
more
aggressive
when
we
update
our
dependencies,
which,
yes,
so
our
dependency
strategy
is
I,
would
call
it
aggressive.
A
A
I
know
before
1.6
only
because
it
went
that
far
back
in
version,
control
and
I
have
a
feeling
we
used
earlier
versions
and
I,
don't
think
we've
been
burned
once,
like
typically
always
sees
more
compiler
warnings
and
we're
incentivized
to
clean
those
up
and
then
and
then
we're
kind
of
good
after
that.
And
similarly
this
is
way
too
small.
A
We
got
lucky
because
the
sir
day
update
I
don't
think
there
was
anything
that
we
had
to
change,
which
was
which
was
awesomely.
We
spent
a
little
bit
of
time,
I
think
with
the
Oh
a
two:
oh
nine
upgrade,
and
it
was
like
totally
worth
it.
It
just
took
a
little
bit
longer,
but
we
try
to
continually
eat
that
pain,
which
actually
overtime,
is
not
a
lot
of
pain.
So
we
will
liberally
use
a
lot
of
great
dependencies
and
it's
been
working
really
really
well
for
us.
A
I
think
I'm
going
to
skip
this
cross-platform
other
than
to
say
it
works
really
well
and
the
compiled
in
attributes,
which
kind
of
look
like
this
with
the
little
pound.
Cfg
work
really
good.
If
you,
if
you
model
your
structure,
your
code
in
a
way
similar
to
like
the
rest
project,
I,
basically
just
copied
what
I
saw
in
the
standard
library
and
rust
itself
for
like
how
would
I
do
something
only
on
Windows
and
not
impact
like
the
Mac
build
and
a
lot
of
like
patterns
calling
and
maybe
an
inner
function
or
an
inner
module.
A
That's
that's
worked
pretty
well.
We
just
try
to
centralize
where
a
lot
of
that
stuff
lives
so
that
we
don't
have
like
pound
configs
like
littering
our
code
everywhere
and
in
conditionals.
We
just
try
to
keep
it
module
and
as
few
plays
as
possible.
So
so
another
big
thing
that
it's
it's
a
it's
a
challenge
for
the
rest
community
as
much
as
it
is
for
habitat.
Is
we
want
more
people
working
on
habitat,
contributing
to
it?
So
with
with
that
large,
you
know.
A
Often
new
team
members
are
learning
a
new
language
and
when
I
say
team
members,
we
have
some
active
core,
maintainer
x'
right
now
that
aren't
working
at
the
same
company
that
I'm
at
that
might
not
even
be
on
the
same
continent.
So
these
people
are
in
the
same
boat.
We've
just
found
that
some
of
these
people
they
sort
of
come
out
of
the
blue
and
have
already
had
that
interest
and
are
landing
like
pull,
request,
fixes
and
we're
going
whoa.
That's
awesome.
A
So
we
are
trying
to
figure
out
better
ways
to
bring
people
in
even
before
that
point.
So
when
they're
kind
of
learning
and
wanting
to
ask
questions
because
not
everybody
can
go
from
like
I've,
not
heard
of
you
before
and
now
you're,
an
active
member
of
our
community
like
three
weeks
later
so
I
think
that
the
problem
that
a
lot
of
people
have
when
they're
learning
rusts
are
looking
at
habitat
or
trying
to
be
productive,
is
I
kind
of
felt.
A
So
I
have
here
like
two
apparent
feature:
work
that
can
work
really
well
for
some
people
and
can
be
either
intimidating
or
actively
like
destructive
for
somebody
else's
way
of
thinking,
and
we
have
people
on
our
team
who
absolutely
love
pairing
and
we
have
other
people
who
can
barely
cope
with
with
too
many
people
like
talking
and
typing.
At
the
same
time,
like
people
just
have
different
ways
of
learning.
A
So
we're
trying
to
be
like
aware
and
conscious
of
that,
especially
when
you're
in
a
learning
mode-
and
you
know
I-
guess,
habitats,
my
day
job
and
it
is
some
people's
day
job,
which
means
when
you're
coming
on
to
the
team.
You
want
feel
like
you're,
an
active
contributing
members
quickly
as
possible.
I.
A
Think
a
lot
of
people
want
to
feel
like
they're,
there
they're,
making
an
impact
and
as
far
as
I'm
concerned
as
long
as
like
you're
learning
and
getting
your
head
around
it
and
asking
questions
like
you,
are
being
productive
and
to
try
to
make
sure
people
feel
like
they
have
that
space
and
don't
have
to
be
like
landing.
Big
feature
changes
like
three
days
in
some
people.
Do,
though,
and
that's
the
way
they
learn
so
kind
of
to
each
their
own.
A
It's
also
been
helpful
for
the
particular
parts
of
the
code
base
to
talk
with
people
around
sort
of
like
how
that
code
sees
the
world
so
like
our
supervisor,
for
example,
is
paranoid
and
distrusted
of
other
things,
and
it's
trying
to
be
defensive,
of
everything
trying
to
destroy
it
or
to
influence
it
in
some
way.
So
there
are,
you
know
we
kind
of
make
we
think
about
things
like
unwraps
and
expects
a
lot
more
closely
than
we
might
in
other
places.
A
There
are
like
totally
legitimate
and
good
times
to
use,
unwrap
and
expect,
and
then
there's
others
in
certain
contexts
where,
like
you
might
not
want
to
do
that,
you're,
basically
making
an
assertion.
That's
so
strong,
you're
saying
like
as
a
developer.
My
expectation
is
so
strong
that
this
is
going
to
be
true,
that
if
I'm
not
right,
we'll
just
let
the
program
like
unwind
and
die
if
you're
like
in
the
main
loop
and
that
might
be
okay,
because
that
might
be
a
legitimate
failure
or
if
you're
on
a
thread.
That's
not
the
main
thread.
A
It
might
actually
be
great
to
like
actively
kill
that
thing
before
it
does
further
harm.
So
it
depends
and
that's
why,
especially
when
you're
learning
these
things
you'll
see
a
lot
of
examples
that
use
I've
seen
a
lot,
they
used
unwrapped
and
I've
seen
a
lot
more
now
that
you
expect,
and
there
was
a
while,
where
we
went
kind
of
crazy
with
expect
until
we
really
thought
about.
This
is
just
like
a
nicer
form
of
unwrapped,
so
we
need
to
be
just
as
careful
with
expect
as
we
are
with
unwrap
and
really
on
both
sides.
A
The
more
time
you
kind
of
put
in
I
sort
of
feel
like
it
took
me
a
few
months
to
sort
of
feel
like
I
was
halfway
competent
and
longer,
like
was
sort
of
hitting
my
stride,
and
there
was
a
leveling
up
point
where
I
was
starting
to
I
was
starting
to
figure
out
like
how
do
I
get
rid
of
these
clones
because
I
know
like
I.
Don't
really
need
this
twice
so
like
when
you
kind
of
reach
that
point
where
you're
sort
of
able
to
think
about
like
the
memory
that
you
might
be
wasting
like.
A
That's
that's
usually
a
sign
that,
like
they've
sort
of
been
at
it
a
you
know
enough
to
be
at
us
sort
of
like
a
certain
level
and
like
again
not
everyone
really
needs
to
be
at
that
point,
and
there's
a
few
of
us
that
if
it
is
more
critical
in
our
code
reviews
that
we
might
use
that
as
a
learning
opportunity,
so
I'm
going
to
quickly
go
through
pain
points
and
then
and
then
we'll
call
it
because
we're
probably
at
time
here.
So
this
is
a
problem
that
gets
actually
much
better
over
time.
A
That
Russ
has
gotten
a
lot
quicker
to
compile.
The
problem
is
in
habitat.
We
keep
adding
code
and
complexity
and
finding
about
these
amazing
things
like
traits
which,
like
add
complexity
of
the
compiler,
so
we're
kind
of,
like
always
in
a
race
I
find
but
for
stuff,
like
you
know,
doing
multiple
compiles
stuff
like
workspaces,
helps
the
single
most
important
thing
you
can
do
to
avoid.
This
is
keep
using
latest
stable
or,
if
you
want
nightly
and
you're
going
to
basically
get
the
benefit
of
of
the
compiler
getting
better
all
the
time.
A
So,
like
don't
stick
on
one
version
of
Russ,
just
like
keep
upgrading,
if
you
can,
the
cross-platform
stuff
is
not
usually
a
problem.
It
only
is
when,
like
I
forget
about
the
windows
use
case
when
I'm,
just
like
focused
on
landing
my
feature
and
I'm
in
a
Linux
VM
continuous
integration
is
like
the
Savior
here.
A
We
had
an
interesting
bug
with
our
supervisor
really
early
in
its
life,
and
it's
basically
doing
like
you
know
an
event
loop
going
through
a
you
know:
an
infinite
loop.
In
order
for
it
to
be
fast,
we
didn't
really
think
about
having
it
block
on
anything
or
sleep
and
I
know
for
a
little
while
we
could
not
figure
out
why,
when
we
started
up
our
supervisor,
it
was
like
pinning
our
CPU.
A
We
had
a
moment
where
the
supervisor
could
set
itself
up
faster
than
the
gossip
system
would
you
know,
get
updates
and
that
kind
of
thing
so,
like
it's
led
to
interesting
things
where
this
code
runs
way
faster
than
I
expected
it
to
I.
Guess
we
got
to
think
about
that
and
so
yeah
to
wrap
up
I
hope,
I've,
helped
to
convince
you
that,
like
there,
you
know,
have
no
fear,
try
this
out.
A
So
our
habitat
website
the
package
system
and
everything
it's
written
in
rust,
it's
running
under
habitat,
it's
deployed
out
there
you're
going
to
know
if
we
drop
the
ball
and
push
some
bad
software,
because
our
website
will
go
away
so
we're
betting
on
on
rust
and
habitat
ourselves
by
running
it
ourselves.
That's
the
best
way.
A
We
can
keep
ourselves
honest
if
you're
still
interested
in
looking
at
either
habitat
itself
or
the
the
parts
in
rust
I
would
encourage
you
to
join
our
public
slack
so
with
habitat
we
enjoy
puns,
which
don't
always
translate
if
you're
not
english-speaking,
but
we
have
habitat
and
slack.
So
we
call
it
happy
slack,
and
this
is
where
the
like,
the
the
core
team
like
for
the
people
that
are
fortunate
enough
to
do
habitat
for
our
day
job.
We
use
the
general
channel
to
like
communicate.
A
So
you
can
see
how
the
habitat
team
is
working
with
each
other
and
with
members
of
the
community
and
answering
questions
throughout
our
day.
It's
kind
of
all
there.
We
try
to
sort
of
keep
it
that
way.
So
when
people
are
coming
in
with
questions,
we're
literally
like
answering
them
as
we're
answering
our
like
coworkers
questions,
so
with
that,
thank
you
very
much.