►
From YouTube: RustEdu Workshop 2022 - Imagining Introductory Rust
Description
Rose Bohrer talks about the possibility of Rust as an introductory programming language. Considerations discussed include: motivations for students and instructors to choose Rust; possible introductory Rust course structure; opportunities for success and failure including syntax and types, educational tooling maturity, and language relevance.
A
Great
thank
you
for
the
intro,
so
my
name
is
rose
bohrer
pronoun,
she
her
top
from
wpi,
and
actually
you
know
my
talk
like
my
paper.
It's
a
little
bit
off
the
top
of
the
dome,
so
I
saw
cyrus
posting
about
this
workshop
and
social
media
and
saw
oh
intro.
You
know,
intro
rust
is
one
of
the
topics
and
you
know
my
background
is
my
phd.
Like
a
lot
of
very
programming,
languagey
foundations,
rust
wise.
I
used
it.
Maybe
like
a
little
bit
in
a
research
paper.
A
I
had
a.
I
have
an
undergrad
who's
using
it
for
a
project.
He
thought
it
was
very
hard
to
learn
because
he
started
with
ferrite
as
his
way
to
learn
must.
But
I've
also
done
a
lot
of
intro
teaching
and
I've
done
a
lot
of
intro
teaching
in
languages
that
are
not
the
most
two
or
two
or
three
most
popular
in
the
world.
A
What
my
talk
is
is
about,
which
is
what
are
some
of
those
barriers
we
always
face
almost
on
like
a
social
level
when
we're
going
into
academia-
and
you
know-
I
think
it's
one
of
the
things
that
that
deserves
a
lot
of
focus-
is
how
do
we
overcome
those
in
a
good
way?
In
a
way
that
we
feel
like
is
scientifically
sound,
you
know
I've
I've
met
folks,
who
will
not
be
named.
It
often
becomes
sort
of
a
point
of
argument.
Almost
like
a
religious
feeling
of
you
know.
A
Everyone
has
their
favorite
programming
language
and
it's
my
favorite,
so
I
want
to
use
it
or
I
use
this
in
my
research.
Do
I
want
to
use
it
and
definitely
because
both
standard
ml,
which
I
taught
at
cmu
and
these
racket
toy
languages
which
I'm
teaching
at
wpi,
because
these
are
not
one
of
the
most
popular
languages
out
there
we
often
get
asked.
Why
are
we
teaching
this
language?
A
A
You
know,
I
think,
if
we
want
to
make
that
part
of
the
core
curriculum
part
of
a
part
of
the
message
we
want
people
to
have
with
their
first
computing
experience.
That
makes
a
lot
of
sense,
but
then
you
get
to
the
the
learning
goals
section
of
the
course
right,
and
you
have
to
ask
yourself:
what
are
we
trying
to
teach
in
an
intro
course,
and
I
think
a
lot
of
us
don't
even
know
the
answer
to
that
question.
So
I
tried
to
go
through.
You
know
in
my
paper.
What
is
in
the
syllabus?
A
What
do
we
think
we're
trying
to
teach
now
and
what
do
we
want
to
be
teaching
in
the
future?
So
if
you
look
at
the
actual
things
that
we
claim,
we
want
to
teach
an
ensure
level
course,
a
lot
of
it's
really
basic
things
like
you
know,
can
you
write
a
recursive
function
on
numbers
right?
Can
you
deal
with
a
list?
A
A
There
may
not
be
any
one
programming
language
community,
where
it's
perfectly
diverse
perfectly
representative,
but
I
do
want
them
to
be
able
to
look
out
there
and
see
a
community
that's
making
some
efforts
and
inclusion.
You
know
communities
that
have
strong
code
of
conduct
and
actually
bring
them
up
during
the
start
of
the
conference.
A
So
that
is
something
that's
maybe
you
know
maybe
is
not
on
every
teacher's
front
of
their
mind,
but
it's
something
that
I
think
we
should
all
lean
into
the
other
things
that
I
was
looking
at.
You
know
I
was
looking
into
both
departmental
research
and
broader
research
on
what's
motivating
students
right.
A
One
thing
that
you
know
a
lot
of
us
can
do.
A
lot
of
us
have
schools
that
participate
in
the
survey
called
data
buddies,
and
I
was
using
that
to
look
into
what
are
students
motivated
by
and
what
I
found
was.
Yes,
they
are
motivated
by
jobs.
They
are
motivated,
motivated
by
making
money
they're,
also
very
motivated
to
learn
the
fundamentals
of
computer
science,
and
so
when
we're
thinking
of
teaching
things
right,
you
know
we
don't.
A
So
I
do
think
we
should
be
honest
about
the
jobs
part
and
the
argument
I'm
trying
to
make
there
is
when
we're
preparing
someone
for
the
future,
we're
looking
at
potential
right.
The
world
is
going
to
change
during
their
degree
like
after
their
degree,
that
doesn't
mean
we
should
teach
a
programming
language,
that's
50
or
60
years
old.
It
means
that
that
we
should,
you
know,
be
optimistic
and
include
languages
that
have
good
future
growth
potential
and
rust.
Right
now
is
at
that
moment
where
it's
getting
that
critical
mass
of,
I
feel
like.
A
I
could
look
at
what
we
have
now
and
show
it
to
people
and
teach
it,
and
I
can
honestly
look
to
to
other.
I
could
kind
of
look
to
future
projections
and
say
yeah,
there's
a
real
chance
that
they're
going
to
use
this
in
their
careers,
but
also
looking
at
fundamentals
right
looking
at
teaching
programming-
and
I
have
this-
did
come
up
in
the
reviews
of
like
okay.
Russ
is
good
for
systems
things.
It's
good
for
type
systems
things.
A
So
so
is
there
a
link
to
the
data,
buddies
survey?
So
what
I
wanted.
So
this
is
a
question
that
came
up.
If
you
look
up
cra
data
buddies,
there's
a
little
bit
of
nationwide
statistics,
it's
not
nearly
as
detailed
the
way
the
system
works
is
that
your
department
at
your
school
would
sign
up
to
it
and
they
make
a
special
one
for
your
department.
A
A
I
have
so
many
times
taught
a
programming
language
that
felt
like
it
was
the
odd
one
out
that
it
felt
like
it
was
so
different
from
everything
else
they
were
using
and
some
students,
some
students,
you
know,
carry
that
knowledge
on
some
of
them
do
feel
like.
Oh,
I
learned
this
and
then
I
forgot
it,
and
then
I
learned
how
to
program
all
over
again
in
the
next
course,
and
so,
although
you
know,
I
think
some
of
us
in
the
intro
like
there's
some
concerns
over
is
rust,
syntax
too
difficult.
A
A
Having
something
that,
if
I'm
teaching
another
class
or
someone
else
is
teaching
another
class
later
on
that
they
can
point
back
to,
and
they
can
say:
oh,
this
is
something
that
was
foreshadowed
in
your
intro
class.
So
when
they
move
on
it
feels
like
something
that's
coherent
with
the
rest
of
what
they're
doing.
I
think
I
can
use
the
next
couple
of
minutes
to
try
and
go
through
some
examples
of
that,
so
I
will
finally
use
that
screen
sharing.
A
Thank
you
for
looking
at
my
face
for
so
long,
and
so
what
I
did
is
I
took
this
seven
week
course
that
takes
basically
a
section
of
how
to
design
programs,
and
I
looked
through
it,
and
I
asked
if
we
went
through
how
to
design
programs
and
try
to
take
each
of
these
assignments
and
do
a
rust
version.
What
would
be
the
same?
What
would
be
the
challenges?
A
A
So
one
of
the
things
we
start
out
with
in
the
old
course
is
we
start
out
with
a
lot
of
gui
programming.
I
think
this
is
a
really
great
thing
for
for
new
programs
to
have
something:
visual,
some
immediate
feedback,
some
little
immediate
payoff,
so
that
just
in
that
first
week
of
the
class
you
said
you
know
what
I'm
going
to
stick
with
this.
I'm
going
to
I'm
going
to
check
this
out
some
more
as
a
newcomer
to
the
community.
A
I've
heard
that
maybe
guys
were
something
that
took
a
little
time
or
effort
to
get
there,
but
I
think
it's
getting
there,
so
you
know
keeping
making
sure
those
libraries
keep
maturing.
I
think
it's
important
and
then,
if
we
look
at
what
kind
of
types,
what
kind
of
programming
come
up,
we
basically
have
product
types.
You
know
your
structs
and
we
have
some
types.
We
have
your
variants
except
we
don't
even
call
them
that
yeah
right,
and
so
I
actually
want
to
go
to
so
I
think
matthew.
A
I
really
want
to
talk
about
that
comment.
This
may
be
better
fit
for
the
conversation,
but
I
have
lots
of
thoughts
on
that
and
it's
a
very
good
point.
So
you
know
we
go
through
things
that
are
basically
of
some
types,
but
the
some
types
are
done,
basically
as
dynamic
types,
and
so
what
we're
seeing
is
they're
right
now
going
into
an
untyped
language
and
they're
writing
their
types
in
their
comments
and
as
they're
developing
tests
as
they're
evaluating
their
correctness.
They
have
to
think
through
types
to
think
through
whether
this
is
correct.
A
You
know
to
know
whether
they're
code
and
rusted
in
america's
correct
they
have
to
say,
is
this
going
to
work
for
all
lists
for
all
structs?
That
look
like
this.
I
can't
check
whether
it's
a
struct,
but
I
have
to
assume
it
is,
and
so,
if
we're
already
trying
to
get
them
to
reason
in
a
very
tight
centric
way
when
they
don't
have
types
just
taking
that
same
thing,
but
now
doing
it
with
types
gives
them
an
opportunity
to
see
that
benefit.
A
One
of
the
things
that
I
lean
on
heavily
in
this
proposed
design
is
also
to
try
and
understand
in
an
intro
course.
You
know
you
motivation
matters,
a
lot,
persistence
matters
a
lot.
How
do
you
keep
people
in
the
course
and
we
want
to
approach
types
in
a
way
where
types
are
going
to
feel
like
they're,
their
friend,
not
their
enemy
and
where
it
doesn't
look
like
a
personal
failure
when
they
write
code
that
doesn't
type
check.
A
So
one
of
my
recommendations
in
here
is
to
actually,
if
you
have
a
lab
section
in
your
course,
spend
some
lab
time
intentionally
writing
code
that
doesn't
type
check
and
showing
them.
What
would
happen
if
you
ran
the
cell
type
code,
it
wouldn't
work.
Aren't
you
glad
that
you
didn't
write
this
ill-type
code
in
the
code
that
you
submitted
and
so
trying
to
really
ingrain
this
idea
that
it's
a
natural
part
of
the
process?
It's
not
a
reflection
on
them
and
that
it's
something
that
is
meeting
their
goals.
A
Then,
as
we
start
getting
into
things
that
have
like
lists
and
trees
towards
the
end,
you
know
we
can
hint
a
little
bit
at
some
of
those
more
system
level
features
right.
I
don't
think
it's
not
a
it's,
not
a
systems
class,
so
you
don't
want
to
go
into
it
too
much,
but
I
want
to
have
them
have
that
that
little
foreshadowing
of
things
that
will
come
up
later
so
when
they
start
writing
with
trees
right
well,
you
know,
if
you
have
a
tree
data
structure
represented
with.
A
If
you
have
a
mutable
tree
data
structure,
you
could
have
multiple
ways
of
representing
the
same
thing.
So
if
I
have
the
same
value
repeated
four
times,
I
could
have
that
with
three
nodes
or
with
two
and
if
you're,
just
having
them
go
off
of
intuition
almost
everyone.
Their
intuition
will
probably
be
this
tree,
but
you
could
write
functions
that
tell
these
two
apart
and
a
napping
type
system
like
we
have
in
rust.
A
Could
actually,
you
know,
help
distinguish
this
right,
help
make
sure
you're
actually
using
things
once
you're,
not
having
aliasing
in
places
where
you
didn't,
expect
it
and
seeing
their
intuition
break
down
and
seeing
the
language
kind
of
reinforce
their
intuitions.
I
think
that's
really
helpful.
For
them
there
are
some
higher
order
functions.
This
is
again
something
where
I
maybe
want
to
to
give
them
some
exposure
to
how
types
can
be
their
friends.
There's
some
sentinel
values
in
the
old
version.
A
Seeing
how
option
types
can
help
them
on
a
basic
level
is
good,
but
again
you
know
being
being
practical
about
which
which
aspects
you'd
want
to
refer
to
a
later
course.
So
you
know
if
you're
teaching
a
higher
order,
type
compilation
course
you
might
want
to
know
how
you
represent
closures
you're
in
your
class.
You
don't
want
to
know
how
you
represent
coaches
at
one
time
right
and
then
maybe
just
to,
because
I
see
them
out
of
time
just
very
quickly
as
they
get
into
mutable
stuff.
A
You
know
not
needing
a
huge
thing,
but
what
are
those
few
little
pieces
of
tooling
things
like
one
one
click
installers
that
will
really
show
up
the
most
in
the
intro
course
and
getting
them
to
view.
This
is
something
that's
relevant
and
getting
it
us
to
view
it
as
something
we
could
really
experiment
with
run.
A
That
first
version
of
the
course
do
some
edu
do
some
research
with
cs
education,
researchers
as
we're
teaching
our
course
test
it
out
in
a
rigorous
way
and
kind
of
show
other
people
that
it
can
be
done,
I'm
just
looking
at
the
time.
I
believe
that
is
the
the
end
from.
I
think
that
is
the
end,
and
I
guess
I
can
ask
the
session
chair.
Is
it
better?
A
For
me
to
answer
questions
as
you're
transitioning,
or
is
it
something
we
should
talk
about
during
the
group
discussion,
so
you've
got
about
four
minutes
left
in
your
session.
So,
okay,
I
wasn't
sure
if
that
was
all
for
for
transition,
so
I'm
gonna
start
going
to
going
through
some
of
the
comments
just
to
spark
more
of
the
conversation
later
on.
A
So
I
think
I
just
wanted
to
clarify
for
galileo.
The
question
of
like.
Is
it
helpful
to
have
a
transition
from
untyped
to
type
in
the
class?
What
I
was
actually
thinking
about
is
at
the
level
of
redesigning
the
course
so
not
a
class
where
they're
doing
both
in
the
same
class,
but
I
have
a
class
that
uses
an
untyped
language
and
how
do
we
turn
that
into
a
class
that
uses
a
type
language?
A
But
the
part
that
I
do
want
to
keep
is
not
having
them
write
code
in
an
untyped
language,
but
have
them
engaged
with
okay.
What
are
the
types
doing
for
me
right
because
we
we
spend
so
much
time
talking
about
a
well-typed
program,
but
if
you're
programming
for
the
first
time
your
program
is
going
to
be
ill-typed
right
and
so
having
them
actually
spend
time
writing
things
that
have
errors
and
saying
why?
Should
this
be
an
error?
Why
is
this
an
error
with
the
program,
not
an
error
with
me?
A
A
I
wanted
to
really
go
into
what
matthew
said,
because
again,
on
the
one
side,
like
one
of
the,
like
one
of
the
reasons
that
I
care
so
much
about
me
doing,
our
intro
curriculum
is,
I
don't
think
our
current
curriculum
is
that
good
in
terms
of
diversity
of
diversity,
of
makeup
among
the
students,
you
know
it's
in
particular,
I
think
it
was.
It
was
taught
to
a
style
that
goes
so
hard
on
intrinsic
motivation
so
hard
on
kind
of
like
rigor.
A
A
I
do
speak
to
that
a
little
bit
kind
of
in
the
intro
going
into
realizing
that
it's
intro
courses.
You
know,
I
think
another
good
thing
to
remember
in
the
group
discussion
is
that
we're
not
just
the
first
course
for
people
that
are
going
to
be
a
cs.
Majors
we're
also
going
to
be
the
only
course
for
a
lot
of
non-majors.
We're
also
going
to
be
the
course
for
a
lot
of
people
that
makes
them
decide.
Do
I
want
to
keep
this
major?
A
Do
I
want
to
take
home
the
cs,
minor
and
so
having
something
that
can
can
highlight,
I
think,
you're,
right,
different
backgrounds
in
terms
of
experience
make
it
start
start
at
a
level
that
everyone
can
get
on
board
for
sure,
but
also
show
them.
You
know
some
of
you
might
get
excited
by
the
mathematical
beauty
of
this
language.
Others
of
you
might
want
to
do
systems.