►
From YouTube: RustConf 2018 - Writing Crates for Complete Beginners - A Tour of Turtle by Sunjay Varma
Description
RustConf 2018 - Writing Crates for Complete Beginners - A Tour of Turtle by Sunjay Varma
Turtle is a Rust graphics crate for creating animated drawings. It is designed to be used to teach programming to complete beginners using Rust. In this talk, you'll learn the inner workings of turtle. We'll show you how we managed to create a library that is both full of features and very easy to learn. We'll go deep into how turtle works and tell you the key aspects of creating a crate that is accessible for anyone of any skill level. You'll leave with new ideas for your own crates and a good understanding of what went into making turtle so beginner friendly.
A
Okay,
hi
everyone,
my
name
is
Sanjay
Varma
I've
been
writing
rust
for
just
over
two
years
now
and
I'm
the
author
of
a
rest,
library
or
crate
called
turtle.
The
turtle
crate
is
unique
in
that
it's
designed
to
be
usable
by
people
who
haven't
learned
programming
before
and
it's
actually
a
teaching
tool.
That's
for
anybody
who
wants
to
teach
Russ
to
other
people
today.
So
today,
I'm
going
to
talk
to
you
about
my
experience,
creating
turtle
and
tell
you
what
the
specific
things
that
I
did
to
make
the
crate
as
easy
to
use
as
possible.
A
There's
a
lot
of
thought
and
care
that
went
into
creating
turtle
and
I'm
really
excited
about
sharing
that
with
you
today,
I'm
gonna
start
by
giving
you
an
overview
of
turtle
what
it
is
and
how
to
use
it.
Then
I'm
gonna
give
you
a
high-level
tour
of
how
turtle
works
and
talk
about
some
of
the
specific
design
decisions
that
I
made
to
make
turtle
as
usable
as
possible
and
to
make
sure
that
we
can
grow
the
turtle
project
as
it
matures
I'll
talk
about
some
of
the
lessons.
A
I
learned
as
I
was
creating
turtle
and
give
you
some
tips
too
on
how
to
make
your
own
projects
accessible
to
a
wider
audience.
Finally,
I'll
finish
off
with
some
thoughts
and
a
summary
of
what
I've
told
you
about.
So
there
are
a
lot
of
resources
online
for
learning
about
rest.
There
are
full
books,
online,
tutorials
websites,
podcasts
and
YouTube
channels,
and
so,
where
does
turtle
fit
into
all
of
this?
A
Well,
the
vast
majority
of
these
resources,
if
not
every
single
one
of
them
is
and
at
about
the
level
of
somebody
who's
learned
at
least
one
programming
language
in
the
past.
So
while
these
resources
give
you
a
good
introduction
to
rust,
not
a
lot
of
these
resources
give
you
a
really
good
introduction
to
programming.
So,
just
over
a
year
ago,
Steve
Crabb
Nick
who's,
the
author
of
the
rust
book
and
the
leader
of
the
rust
documentation
team
made
this
comment
on
reddit.
A
He
said
that
rust
could
be
somebody's
first
programming
language,
but
the
resources
and
learning
materials
that
are
needed
for
that.
Just
don't
exist
yet
so
I
thought
about
that
call
a
lot,
because
you
know
rust
has
incredibly
good
error
messages.
It
has
a
friendly
kind
and
helpful
community
and
really
nice
features
that
make
you
productive
and
allow
you
to
have
a
lot
of
fun
when
you're
programming.
A
My
hypothesis
is
that
rust
is
going
to
make
a
really
great
first
language
for
anyone
wanting
to
get
into
programming,
and
so
my
goal
with
turtle
is
to
create
the
resources
and
community
that
we
need
in
order
to
make
the
rust,
in
order
to
make
the
rust
language
a
language
that
anybody
can
learn.
So
now
that
you
know
what
I'm
actually
out
to
accomplish,
let's
talk
a
bit
about
what
turtle
actually
is.
The
concept
of
the
turtle
crate
is
actually
pretty
simple.
A
You
have
this
window
and
in
the
middle
of
this
window,
is
this
little
triangle
and
that
triangle
is
actually
a
turtle.
It's
the
turtles
show.
So
this
turtle
is
pretty
special.
If
we
enhance
this
image,
a
bit
you'll
see
that
you'll
see
that
this
turtle
actually
has
a
pen
attached
to
it.
Still
that's
a
real
drawing
that
took
me
a
lot
of
time
to
do,
despite
what
it
looks
like.
So
this
bat
is
pretty
awesome
because
we
can
use
it
to
draw
pictures.
A
If
you
look
here
as
the
turtle
moves,
it
drags
its
tail
and
the
pen
actually
draws
the
path
that
the
turtle
takes,
and
so
this
is
the
central
concept
of
the
turtles
right
and
you
can
draw
all
kinds
of
amazing
things
just
by
telling
the
turtle
where
to
go.
All
of
these
were
drawn
in
turtle,
and
some
of
them
were
actually
contributed
by
people
in
the
rest
community.
You
can
find
the
source
code
for
all
these
drawings
in
the
examples
directory
of
the
turtle
github
repository.
A
The
reason
this
is
great
for
teaching
is
that
the
interface
provided
by
turtle
is
fairly
simple
without
being
limited
in
functionality.
There
are
movement
and
rotation
methods,
methods
for
controlling
the
turtles,
walking,
speed
methods
for
manipulating
the
pen
and
even
some
commands
for
fillings
the
shapes
that
you
draw
or
controlling
whether
the
turtle
is
visible
or
not.
A
You
get
all
of
these
different
ways
to
draw,
but
very
simple
mental
model
to
teach
it's
just
a
turtle
moving
around
the
screen,
so
this
type
of
teaching
tool
goes
beyond
the
typical
text,
manipulation
of
most
introductions
to
programming.
You
can
write
lessons
that
produce
really
cool
drawings
without
necessarily
needing
to
dive
into
the
more
complicated
features
of
rust.
The
idea
for
this
actually
isn't
even
mine
if
you
look
up
turtle
graphics
on
the
internet,
there's
a
pretty
rich
history
of
people
using
this
to
teach
other
people
programming.
A
In
fact,
one
of
the
first
incarnations
of
turtle
was
a
real
physical
robot.
The
robot
would
move
around
a
piece
of
paper
and
draw
pictures.
A
software
version
of
logo
was
created
to
be
used
with
the
programming
language
called
logo.
Logo
is
a
simple
command
base
language
that
allows
you
to
draw
pictures
using
a
turtle.
A
Lots
of
languages
have
built-in
implementations
of
turtle
graphics.
For
example,
Python
has
a
module,
a
turtle
module
that
allows
you
to
draw
pictures
just
as
easily
as
if
you
were
using
logo.
So
in
this
code,
Turtle
dot
forward.
Instructs
the
turtle
to
walk
forward
by
200
steps
by
calling
turtle
dot
right.
You
tell
the
turtle
to
turn
to
the
right,
90
degrees.
A
It
was
really
important
for
me
to
make
sure
that
this
was
a
useful
tool
for
teaching
rust,
not
just
an
identical
copy
of
the
Python
implementation,
and
so
the
turtle
crate
is
written
in
idiomatic
rust
and
follows
rust
best
practices.
One
thing,
you'll
notice
in
the
Python
code
on
the
left,
is
that
we
directly
call
methods
on
the
turtle
module
that
we
imported.
A
We
didn't
create
any
turtle
explicitly
it's
just
there
in
the
module
itself,
and
so
the
Python
implementation
uses
some
global
mutable
state
inside
of
the
module
itself
in
order
to
implement
that
global
mutable
state
is
this
pattern
that
can
lead
to
a
lot
of
subtle,
bugs
and
cause
problems
in
your
code.
So
that's
why,
in
the
Rustom,
you
actually
have
to
create
the
turtle
explicitly
as
a
local
variable,
and
you
even
have
to
mark
it
with
the
mute
keyword
in
order
to
modify
it
rust.
A
Won't
even
let
you
use
the
forward
and
right
methods
if
you
don't
declare
your
variable
with
mute,
because
both
forward
and
right
modify
the
turtle
itself.
So
this
is
a
tiny
bit
more
friction
than
you
had
to
experience
with
the
Python
implementation,
but
I
think
it's
worthwhile
because
it
teaches
people
good
habits,
that'll
help
them
in
the
future,
as
they
continue
programming
and
the
wonderful
thing
about
rust-
and
this
is
particularly
for
rust-
is
that
even
if
they
do,
for
example,
forget
the
mute
keyword.
A
There's
this
really
nice
error
message:
that'll
tell
them
exactly
how
to
fix
the
problem
and
tell
them
what
went
wrong.
That
means
that,
even
if
you're,
new
and
you're
still
not
used
to
things,
it's
very
hard
to
get
stuck,
if
you
just
read
the
error
message,
I'm
very
proud
of
the
fact
that,
although
there
are
a
few
differences,
the
rust
code
is
basically
the
same
as
the
Python
version
and
accomplishing
that
took
quite
a
bit
of
effort.
So,
let's
talk
about
how
I
did
it?
A
The
turtle
crate
has
quite
a
bit
of
stuff
going
on
behind
the
scenes.
The
crate
creates
a
window,
manages
events
like
the
close
button
being
pressed
the
window
being
resized
or
someone
clicking
on
the
canvas
and
still
has
to
respond
to
all
of
your
drawing
commands
with
the
appropriate
actions
behind
the
scenes.
Turtle
has
to
run
a
complete
event
loop,
while
still
allowing
you
to
write
normal
looking
code.
That
is
reasonably
simple
to
understand.
Well,
what's
an
event
loop.
A
Well,
basically,
the
idea
is
that
both
the
program
and
the
user
are
continuously
trying
to
do
things.
At
the
same
time,
a
program
written
using
only
the
turtle
crate
might
be
trying
to
draw
a
picture
or
do
some
calculations,
whereas
the
user
might
be
minimizing
or
maximizing
their
screen
clicking
on
something
or
pressing
a
key
on
their
keyboard.
An
event
loop
simply
manages
all
this
continuously
in
the
loop
inside
of
an
event
loop.
You
take
turns
quickly,
switching
back
and
forth
between
handling
the
events
from
the
user
and
performing
the
intern
singing
of
the
program.
A
This
isn't
actually
too
hard
to
grasp
once
you
get
the
hang
of
it
and
if
I
were
writing
a
general
purpose,
graphics,
crate
I
would
definitely
allow
the
user
of
that
crate
to
write
their
event
loop
themselves
so
that
they
could
have
full
control
over
their
application,
but
that
really
doesn't
work
the
same
way
for
turtle.
It's
not
that
important
here,
because
we're
really
only
trying
to
be
a
good
tool
for
teaching
rest.
A
These
kinds
of
details
don't
really
help
us
and
that's
why
we
hide
all
of
that
behind
the
simple
interface
that
you
saw
before.
So
this
is
how
the
architecture
of
the
first
incarnation
of
the
turtle
crate
looked
when
you
create
a
turtle
in
your
code.
Using
turtle
knew
the
turtle
crate
spawns,
and
you
thread
that
thread
is
where
we
create
the
window,
run
the
event
loop
and
do
all
of
the
rendering
and
event
handling
that
I
described
on
the
previous
slide.
A
A
The
threads
can
communicate
back
and
forth
to
do
drawing
and
handling
events
as
they
as
needed,
and
this
is
a
great
and
relatively
straightforward
way
to
accomplish
our
goal
of
having
an
easy-to-use
interface
that
hides
all
of
the
complicated
details
of
the
event
loop
and
rendering
the
event
loop
runs
in
the
background,
and
the
main
thread
goes
on
normally
telling
the
turtle
what
to
do
in
each
step.
Now
there
are
a
couple
of
things
to
consider
about
this,
though.
Normally,
the
program
ends
when
the
main
thread
ends.
A
Now
we
don't
want
that
here,
because
that
would
mean
that
the
window
would
immediately
close
after
it
finished
drawing
whatever
the
users
program
specified
to
prevent
that
when
the
turtle
goes
out
of
scope,
we
actually
wait
for
the
window
to
be
closed
and
then
we
end
the
main
thread.
In
addition
to
that,
we
need
to
make
sure
that
any
memory
that's
shared
between
these
threads,
any
information
we
have
about
the
turtle
or
the
drawing
or
anything
like
that
is
available
to
both
of
them
as
much
as
possible.
A
We
wouldn't
want
the
main
thread
to
wait
for
the
crowd
or
vice-versa,
so
this
approach
actually
worked
really
well
and
it
allowed
me
to
get
turtle
off
the
ground.
I
had
a
working
crate
and
I
even
published
it
for
the
world
to
see.
However,
given
that
the
last
slide
was
titled
attempt
number
one,
you
probably
already
guessed
that
this
didn't
last
long.
A
Yes,
unfortunately,
the
day
after
the
crate
got
a
lot
of
attention,
someone
came
and
found
out
that
it
didn't
work
on
Macs
at
all,
see
I
developed
turtle
on
Linux,
which
is
apparently
totally
fine
with
you,
creating
and
managing
application
windows
in
any
threat
at
all,
but
on
Macs,
the
implementation
of
window
management
isn't
thread
safe.
That
means
that,
in
order
to
manage
a
window,
you
need
to
create
it
and
handle
the
event
loop
on
the
main
thread.
A
This
is
a
huge
deal,
because
the
whole
magic
of
turtle
is
that
you
could
write
simple,
normal
looking
code
on
the
main
thread
without
doing
anything
special
in
order
to
create
the
window
like
it
would
not
be
good
to
have
to
force
somebody
to
squeeze
an
entire
event
loop
in
the
middle
of
the
turtle
code.
We
saw
before
the
code
on
the
right
here
is
completely
different
from
the
left
and
will
more
complex
for
a
beginner.
So
it
was
unacceptable
for
me
to
have
to
add
this
extra
burden
of
complexity
to
turtle.
A
Turtle
just
couldn't
be
an
effective
teaching
or
learning
tool.
If
you
had
to
learn
about
all
of
this
just
to
write,
simple
programs.
So
after
a
lot
of
thought
and
consideration,
I
came
up
with
the
second
architecture.
I
I
needed
some
way
to
continue
to
allow
the
user
to
write
their
program
on
the
main
thread
and
also
create
and
manage
the
window
on
the
main
thread
as
well.
We
can't
actually
do
both
of
these
together.
A
Well,
it
turns
out
there
is
actually
a
way
to
do
this.
Well,
you
can't
have
two
main
threads
and
process.
You
can
have
two
processes
with
one
main
thread
each,
and
so
the
solution
I
came
up
with.
To
give
me
everything
that
I
wanted
was
to
spawn
a
new
process
to
run
the
event
loop,
instead
of
relying
on
a
separate
thread.
Now
processes
are
a
little
bit
more
complicated
to
handle
than
threads.
But
if
you
do
it
correctly,
it
turns
out
to
not
be
that
bad
we're
still
sending
drawing
command
messages.
A
It's
just
that
now
we're
doing
it
between
processes
instead
of
between
threads
and
we're
still
waiting
for
the
window
to
be
closed
before
we
exit
main
thread
number
one.
Instead
of
sharing
state
between
threads
like
we
were
before,
we
now
have
to
deal
with
synchronizing
that
state
between
two
processes.
The
way
we
handled
this
today
in
turtle
is
pretty
simple:
we
just
keep
all
the
state
and
one
of
the
processes,
and
then
we
make
the
other
process
request
it
whatever
it
wants
to
look
at
it,
so
this
attempt
actually
ended
up
working
great.
A
You
probably
only
talked
about
a
day
or
two
of
work
to
convert
the
old
thread
based
architecture
to
the
new
process
based
one-
and
this
has
actually
been
so
successful
so
far-
that
this
is
still
how
turtle
works
today.
Now
one
of
the
greatest
things
about
this
is
that
it
actually
didn't
require
any
changes
to
the
public
API
at
all.
The
entire
turtle
crate
stayed
the
same,
but
the
internals
of
how
it
worked
got
completely
switched
out.
A
The
turtle
crate
you
see
online
today
is
in
no
way
complete
it's
fairly
stable
now,
but
there
are
still
a
ton
of
features
that
we
could
potentially
add
I've
taken
a
lot
of
time
to
carefully
plan
things
so
that
we
can
reach
a
minimal,
Viable,
Product
and
and
then
build
all
kinds
of
really
cool
features.
On
top
of
it.
Turtle
has
a
really
good,
really
well-organized
issue
tracker,
with
lots
of
good
first
issues
and
Help
Wanted
issues.
A
If
you're
looking
to
get
involved,
we're
really
open
to
anybody
of
any
experience
level
with
programming
or
with
rust
and
we'll
help
you
figure
things
out
as
long
as
you're
willing
to
work
with
us
to
do
so.
We
especially
love
it
when
people
come
and
contribute
examples
to
turtle
and
there's
this
great
example
idea
label
on
github.
If
you're
looking
for
inspiration,
we
really
want
to
see
it.
A
If
you
use
turtle
to
create
something
cool
and
these
example,
ideas
are
just
there
to
spark
your
imagination
if
you're
interested
in
contributing
to
turtle
but
you're
not
sure
how
to
get
started.
We
have
a
detailed
contributing
guide
that
walks
you
through
the
process
of
contributing
step-by-step,
a
great
way
to
contribute.
If
you're
looking
for
something
to
do
is
to
read
this
contributing
guide
and
tell
me
where
you
get
stuck
so
I
can
fix
it.
Opening
issues
is
fantastic.
A
The
future
of
turtle
has
a
lot
of
really
cool
features.
I
want
to
add
things
like
multiple
turtles
3d,
drawing
text,
rendering
support.
We
want
more
widgets
like
buttons
and
text
fields
for
user
input.
We
even
want
to
add
asynchronous
turtles
using
async,
await
and
the
futures
crave
and
add
web
assembly
support
so
that
you
can
write
turtle
code
from
your
browser
without
downloading
anything
at
all.
These
are
all
really
exciting
ideas
and
I'm
definitely
going
to
need
all
of
your
help
in
order
to
accomplish
them.
A
A
So
as
I
was
designing,
turtle
I
put
a
lot
of
thought
into
what
kinds
of
things
that
create
needs
in
order
to
be
accessible
to
people
who
don't
know
programming
at
all,
I,
don't
know
of
any
other
case
that
try
to
do
this,
so
it
was
particularly
important
that
I
think
about
it
a
lot
and
get
it
right.
I'm
now
going
to
share
with
you
some
of
the
things
I
learned
along
the
way
and
give
you
some
tips
to
help
make
your
own
crates
more
accessible
to
a
wider
audience.
A
So
it's
true
that
not
every
crate
is
aiming
for
as
large
of
a
group.
Most
crates
probably
don't
need
to,
or
even
shouldn't
try
to
cater
to
people
who
don't
know
programming.
It
would
be
way
too
much
to
ask
if
every
crate
author
to
teach
basic
programming
to
every
user
of
their
crate.
That
being
said,
the
nice
thing
about
at
least
thinking
about
it
is
that
you
have
the
opportunity
to
increase
the
number
of
people
who
can
use
your
crates
successfully.
A
I've
sat
down
and
taught
Russ
to
people
who
don't
know
programming
but
well
and
managed
to
explain
some
pretty
complicated
crates.
Sometimes
you
just
need
somebody
to
put
in
the
time
to
write
something
that
will
teach
you
what
you
need
to
learn
when
you
put
in
some
effort
to
make
your
create
accessible
to
an
audience
that
might
not
be
familiar
with
what
your
crate
does.
It
benefits
everyone,
including
the
people
who
are
experts
in
it.
Like
you
I'll
give
you
a
small
example
of
something
that
I
did
to
make
turtle
accessible.
That
actually
ends
up.
A
Helping
me
a
lot.
Turtle
isn't
just
meant
to
be
a
good
teaching
tool.
It's
meant
to
be
a
very
accessible
project
for
people
who
want
to
contribute
to
a
Russ
project.
That's
why?
If
there
are
any
quirks
that
might
trip
someone
up
when
they're
trying
to
contribute
to
turtle
I,
take
extra
care
to
make
sure
that
people
get
the
information
they
need
in
most
crates.
You
can
go
in
and
run
cargo
tests
to
run
the
tests
for
that
crate.
A
But
since
turtle
has
a
graphical
user
interface,
just
running
cargo
tests
alone
would
make
a
whole
bunch
of
windows
pop
up
unnecessarily.
This
is
undesirable
and
closer.
All
of
these
windows
is
really
hard,
so
I
added
a
special
test
feature
to
the
crate
that
disables
any
window
creation
during
tests.
The
problem
is
that
you
can't
just
run
the
regular
test
command
anymore.
You
have
to
run
cargo
tests
with
the
features
flag
and
then
add
the
word
test.
A
I
didn't
want
people
to
get
tripped
up
on
this,
so
I
used
a
special
macro
that
rust
recently
added
called
the
compile
error
macro,
and
so,
with
these
two
lines
of
code,
if
anybody
tries
to
compile
tests
without
the
appropriate
features
flag,
they
get
this
really
nice
error
message
that
tells
them
exactly
what
to
do.
This
is
this
was
supposed
to
be
a
small
quality
of
life
improvement,
but
I
only
really
intended
to
help
new
programmers,
but
it's
something
that
helped
me
a
whole
bunch
of
times
as
well.
A
So
some
of
the
things
I
talked
about
today
are
probably
going
to
seem
a
little
bit
obvious
at
first,
this
first
one
good
documentation
is
probably
something
you
know
to
do
already
right
like
want
to
make
your
crate
more
easier
to
use,
write
some
docs.
So
that
people
know
how
to
do
it,
the
thing
is
to
make
your
documentation
actually
good.
You
need
to
put
some
thought
into
it.
I
find
personally
that
the
first
time
I
write
documentation
I
only
really
end
up.
Writing
it.
A
A
First,
it's
also
a
really
bad
idea
to
try
and
write
your
documentation
after
having
written
all
of
your
code,
because
you'll
probably
forget
most
of
the
important
things
that
you
want
to
write
down
by
the
time
you
get
to
your
documentation
in
the
turtle
crate.
We
take
documentation.
Really
seriously,
we
aren't
perfect
yet,
but
we
really
make
an
effort
to
have
detailed
documentation
that
covers
the
information
you
need
in
order
to
use
the
item
being
documented.
A
One
example
of
a
method
that
has
some
pretty
good
documentation
is
the
set
speed
method.
Here
we
take
the
time
to
explain
the
most
important
information
about
the
method,
what
it
does,
how
to
call
it
when
it
might
panic-
and
we
talked
about
how
to
achieve
specific
effects
using
the
method
using
some
special
values
that
it
can
take
since
turtle
is
targeting
new
people
who
aren't
familiar
with
programming,
aren't
familiar
with
rust.
We
also
take
the
time
to
explain
some
rust
concepts
that
the
user
might
not
be
familiar
with
now.
A
One
way
you
can
avoid
such
long-winded
explanations
is
by
linking
to
the
many
rust
resources
that
are
available
online.
We
do
that
a
lot
in
the
turtle
documentation
and,
if
you're,
a
little
apprehensive
about
writing.
Docs
yourself.
This
is
a
great
way
to
cut
down
on
the
total
number
of
things
that
you
need
to
write,
so
don't
hesitate
to
take
advantage
of
the
resources
that
other
people
have
created
to
make.
A
Your
life
easier,
one
of
the
final
things
that
I'll
point
out
about
writing
good
documentation,
is
that
you
need
to
think
about
how
people
will
find
the
information
that
they
need.
The
users
of
your
crate
will
not
always
be
experts
in
it,
so
they
need
to
know
which
types
functions
or
methods
they
should
look
at
if
they're
trying
to
accomplish
a
certain
task.
One
way
you
can
help
them
is
by
putting
something
at
the
root
of
your
documentation
that
directs
them
to
the
places
they
might
want
to
go.
A
A
There
are
quite
a
few
methods
in
the
turtle
crate
that
need
to
have
their
documentation
improved
a
lot,
in
fact,
sometimes
in
my
own
haste,
to
finish
something
I've
written
examples
like
this.
This
example
is
more
of
a
unit
test
than
a
real
example.
It
doesn't
explain
anything
for
an
example
to
be
useful.
You
actually
need
to
motivate
it
and
and
talk
about
why
people
should
use
it
and
what
ended
and
what
situations
that
comes
in
handy.
A
If
you
find
this
really
difficult
to
describe
for
a
particular
item,
you
should
really
think
about
why
it's
in
your
public
API
in
the
first
place,
if
you
can't
even
explain
what
it's
supposed
to
be
used
for
a
method
with
much
better
documentation,
is
the
set
pen
size
method?
Not
only
does
it
have
complete
example
that
motivates
the
use
for
that
method.
It
also
gives
you
a
picture
of
exactly
what
result
is
produced
by
running
that
example.
A
A
Easily
cargo
can
run
any
rest
file
placed
in
the
examples
directory
of
your
project,
and
you
can
use
these
to
provide
more
comprehensive
examples
of
the
major
use
cases
of
your
crate
turtle
has
a
lot
of
examples
in
its
examples
directory
and
we're
always
looking
for
more
people
to
add
examples
of
the
things
they've
drawn
so
far.
We've
talked
about
good
documentation
and
examples,
but
our
discussion
wouldn't
be
complete.
If
we
didn't
also
touch
on
writing
a
guide,
a
guide
is
a
tutorial
that
goes
through
the
key
pieces
of
functionality
in
your
crate.
A
Your
guide
needs
to
at
minimum
walk
people
through
the
first
time,
using
your
crate
now,
once
you've
done
that,
you
should
aim
to
show
them
detailed
examples
of
each
of
the
major
features
and
use
cases
for
your
crate.
The
difference
between
a
guide
and
the
examples
in
your
examples
directory
is
that
in
a
guide
you're
able
to
explain
your
crate
and
how
it
works
in
detail,
this
is
essential
for
somebody
to
have
a
complete
understanding
of
how
to
use
your
code
and
a
guide
is
actually
one
of
the
major
pieces
that
turtle
is
still
missing.
A
I
want
the
turtle
guide
to
be
an
introduction
to
programming
that
incrementally
teaches
people
programming
in
rust
by
having
them
draw
pictures.
The
final
thing
that
I
want
to
mention
is
that
is
the
rust
api
guidelines.
These
guidelines
go
through
a
lot
of
the
different
aspects
of
creating
a
rust
crate
and
tell
you
exactly
how
your
crate
should
work
in
each
category.
There's
a
checklist
that
you
can
use
to
make
sure
that
code
is
idiomatic
and
follows
rust.
Best
practices,
I
highly,
recommend
these
guidelines
for
making
sure
you're
writing
the
best
rust
code
possible.
A
So
thank
you
for
listening
to
my
talk.
We
covered
a
lot
today,
including
how
to
you
how
the
turtle
create
works
and
how
you
can
make
your
crates
accessible
to
a
wider
audience.
Please
come
and
try
total
out.
We
really
need
people
to
try
and
draw
non-trivial
things
in
turtle
so
that
we
can
see
what
breaks
if
you'd
like
to
come
contribute.
We
have
plenty
of
things
to
work
on
regardless
of
your
skill
level.
I
also
want
to
take
a
moment
and
thank
all
the
wonderful
people
who
have
contributed
to
turtle
already.
A
Many
people
come
in
and
they've
picked
up
the
slack
when
I
haven't
been
able
to
work
on
turtle
very
much
and
I
really
appreciate
everybody
who
contributes
code
and
everybody
who
files
issues.
The
turtle
crate
has
a
Twitter
account.
So
if
you
blog
about
turtle
or
draw
something
and
post
it,
I'll
retweet
you.
If
you
tag
this
account,
you
can
also
follow
me
on
Twitter
as
well
I'll
be
around
today
and
online.
If
you
have
any
questions,
that's
my
time.
Thank
you
very
much.