►
Description
Vitaly Bragilevsky describes a JetBrains project that integrates: exercises inspired by the Rustlings Rust learning exercise suite; references to exercise-relevant documentation; and a playground for exploring solutions. These are made simultaneously accessible via a novel UI within the JetBrains IntelliJ IDEA and CLion tools.
The project is freely available at https://plugins.jetbrains.com/plugin/16631-rustlings.
A
Yeah,
so
I
will
talk
about
just
one
way
to
learn
rust.
Of
course,
there
are
many,
many
others,
and
it's
not
it.
Maybe
it's
not
the
best
one,
but
still
here's
what
we
have
so
we're
going
to
talk
about
self
learner
first,
so
it's
just
a
person
who
wants
to
learn
rust
and
we
presume
that
this
person
knows
one
other
programming
language
and
otherwise
it's
a
little
bit
different.
A
So
I'm
not
going
to
talk
about
trust
as
the
first
programming
language,
so
there
are
so
basic
ways
to
learn
a
new
programming
language
like
you
can
read
a
book.
You
can
look
at
examples,
especially
if
you
like
know
some
other
programming
language.
Sometimes
you
don't
want
to
read
a
long,
long
text.
You
just
look
at
examples
and
get
ideas
and
go
with
that
and
of
course
you
can
solve
problems
and
usually,
when
we're
talking
about
solving
problems,
it's
good
idea
to
have
some
tests
just
to
check.
A
A
We
also
have
great
resource
trust
by
example
like
for
several
areas
of
things
like
common
line
arguments,
iterators
ownership
and
examples
for
all
those
topics,
and
we
have
rustlings
rustlings
is
a
collection
of
small
exercises
not
to
learn
the
whole
rust,
but
just
to
get
your
hands
wet
in
rust
features.
A
But
in
this
situation
something
is
missing
and
when
I
say
that
I
mean
tooling
and
three-edged
brains,
where
I
just
do
tools
for
things
like
that.
So
I
want
to
present
one
tool
from
our
educational
content
team,
which
is
called
wrestling's
adaptation,
so
we
adopt
wrestlings
and
we
made
something
new
of
it.
So
here
is
an
example
of
a
window.
A
A
The
most
important
example
in
this
fragment-
and
here
you
can
see
this
code-
you
can
work
with
it
as
usual
in
ide.
You
can
run
it.
You
can
explore
errors,
you
can
do
whatever
you
like
in
in
with
this
window
and
then,
of
course,
there
are
problems
that
you
can
solve
and
for
problems.
You
can
write
your
solution.
A
For
example,
this
is
a
problem
which
goes
about
ownership,
which
variable
own
value
at
which
moment-
and
you
just
have
to
do
something
with
that,
and
then
you
write
some
code
and
then
you
check
it
and
then
you
get.
Is
it
correct
or
not?
I
I
think,
with
rust.
A
In
most
cases,
one
can
find
himself
or
herself
with
looking
at
these
errors,
and
you
can
do
that
because
it's
ide,
you
can
look
at
errors
at
this
moment
of
course,
and
then
with
you,
can
explore
something
how
some
output,
if
you
did
it
correctly.
A
So
what
is
this
wrestling's
things
wrestling's
by
dead
brains,
our
adaptation?
So
we
take
texts
and
examples
from
the
book.
We
also
take
problems
from
rustling's
original
course
and
then
you
can
add
usual
rust
tool
chain
we
have
you
have.
You
should
take
some
ide
from
jetbrains,
any
of
them
like
by
charm
or
whatever
cli
and
intelligent
idea,
and
then
you
have
this
intellij
ras
plugin,
and
once
you
have
all
that
you
need
educational
platform,
which
is
which
comes
as
a
plug-in
and
this
rustlings
plug-in,
which
is
a
course
developed.
A
Using
this
platform,
we've
made
a
new
release
of
this
course
this
august,
so
it
it's
not
a
new
course,
but
we've
updated
we've
revised
it
very
significantly
like
this
week
and
it
covers
14
chapters
out
of
20,
so
not
all
of
that,
but
just
some
part
of
it.
We
have
210
theory
steps
like
every
theory,
step,
small
part
of
theory,
and
example
210.
A
Examples
like
that.
So
it's
quite
a
lot,
but
it's
it's
all
about
small
chunks.
So
if
you
like,
learning
through
growing
small
chunks,
that's
that's
something
that
you
may
find
useful,
and
then
we
also
have
more
than
100
problems.
So
every
step
is
just
some
small
problem
which
was
adopted
from
wrestling.
A
So
it's
not
about
writing
a
big
program.
So
it's
not
something
that
could
cover
all
needs
of
some,
professor
at
the
university.
Of
course.
A
No,
it's
just
for
self
learners
to
make
you
acquaint
it
with
language
features,
and
then
we
also
have
several
steps
for
id
how
to
learn
ide,
how
to
do
things
there
like
how
to
do
refactoring
rename
a
variable
extract
function,
how
to
set
some
options,
some
preferences,
how
to
use
it,
but
mainly
it's
all
about
rust
and
how
to
solve
problems
in
rust
and
how
to
use
ide
for
programming
in
rust.
A
So
this
is
quite
a
large
course
and
we
suggest
one
particular
scenario
for
using
it.
So
you
just
look
at
example,
and
from
my
experience
I
always
recommend
to
look
at
the
example.
First,
there
is
a
chance
that
you
understand
everything
and
in
that
case
it's
not
necessary
to
understand
everything.
It's
not
necessary
to
read
something.
You
just
look
at
the
example
and
get
the
idea,
and
then
you
go
trying
to
solve
exercises.
A
Okay,
so
sometimes
you
don't
need
to
read
anything,
but
of
course
you
can
because
it's
all
here
just
don't
have
to
go
anywhere,
so
you
can
read
corresponding
book
fragment
and
we
try
to
make
it
small,
really
small.
So
just
you
don't
have
to
read
for
an
hour
to
get
to
this,
but
that's
why
we
have
so
many
steps.
Of
course,
then
one
extremely
important
thing
like
I
was
working
in
high
education
for
20
years
and
they
know
if
you
just
look
at
example.
A
If
you
just
read
something
it's
almost
useless,
you
have
to
play
with
the
code
you
have
to
edit
it.
You
have
to
run
it.
You
have
to
explore
errors,
otherwise
it
it
will
never
work.
So
you
have
to
change
something
and
see
how
compiler
react.
How
rust
react
to
what
you
are
trying
to
do
so
it's
very
important
and
then,
after
working
with
this
example,
theory
step.
A
You
just
go
to
the
next
step
and
it
can
be
anything
can
be
another
theory,
example
or
it
can
be
task,
and
if
it's
tasked
some
some
learners
prefer
trying
to
first
task
to
solve
tasks.
First,
they
just
go.
Oh
nice
task,
let
me
solve
it
and
then
they
get
into
a
lot
of
troubles
and
then
trust,
it's
very
easy
to
get
into
trouble
and
once
they're
in
trouble
they
can
get
back
to
examples
and
read
text
and
whatever.
So
so,
it's
okay
not
to
follow
the
specified
path.
A
So
when
I
say
adaptation,
so
we've
adopted
rustling
exercises.
I
should
say
that
we
are
not
in
one-on-one
correspondence.
So
when
I
go
through
wrestling's
original
wrestlings
myself,
I
sometimes
see
that.
Well,
there
can
be
some
problems
with
the
problem
descriptions,
maybe
sometimes
they're,
not
very
good,
at
checking.
If
it's
correct,
if
the
solution
is
correct
or
not
so,
we've
tried
to
mates
made
it
a
little
bit
different.
A
So
we
have
specific
karga
project
for
each
task
and
that's
why
we
can
learn
more.
We
can.
We
can
teach
more
with
this.
We
can
teach
module
system,
we
can
teach
all
this
stuff
about
library,
create
binary,
create
and
we
can
teach
about
cargo
thermal
files,
so
sometimes
you're
allowed
to
see
tests
to
check
them
to
change
them
somehow,
so
you
can
just
learn
real
rust
software
development
with
that,
and
I
have
to
say
that
all
that
we're
doing
about
that
is
free.
A
Well,
not
all
our
ids
are
free,
but
everything
for
wrestling's
course
is
available
for
free.
It
works
an
hour
in
the
free
editions
of
our
ids.
So
all
our
plugins
rust
edit
tools
and
trust
links
work
for
free,
so
anyone
can
use
it
no
need
to
pay.
So
we're
not
selling
that
well,
because
jetbrains
works
in
education
for
many
years
and
we
try
to
deliver
everything
for
free
and,
of
course,
if
you're,
a
student
or
a
faculty
you
can
even
buy,
you
can
even
take
professional
ids
for
free
too.
So
it's
also
possible.
A
So
that's
it.
Thank
you
very
much
and
yeah.
I
was
a
little
bit
quick
here.
I
think
so
here
is
a
link
to
this
course,
but
it's
easy
to
find
anyway,
if
you
write
wrestlings
and
jet
brains.
B
Yeah
thanks
vitelli
for
the
great
talk
and
we'll
run
straight
into
some
questions,
so
I
can
just
narrate
them
so
yuri
asks
how
many
people
worked
on
making
this
tool,
I'm
asking,
because,
probably
in
the
future,
the
same
kind
of
course
could
be
done
for
other
languages.
What
do
you
think.
A
Well,
this
course
is
special,
so
we
are
not
doing
it
from
scratch,
so
it
is
just
parts
of
wrestling's
from
original
courses
parts
from
something
from
the
book,
so
it
was
relatively
easy
like
this.
This
course
exists
for
I
think
four
years
and
I've
made
this.
I've
made
a
loan,
this
major
refactoring
for
a
couple
of
months,
so
but
usually
developing
a
course
is
just
one
or
two
person
like
for
several
months,
so
I
wouldn't
say
that
it's
very
difficult.
Of
course,
it
takes
time
to
to
write
tests.
A
We
have
several
sorts
kinds
of
tests
for
that,
but
it's
it's
not
so.
Edutools
is
a
good
platform.
You
can.
You
can
write
courses
in
in
that
platform.
It's
quite
easy.
There
are
good
documentation,
so
you
don't
need
many
people
to
for
doing
courses.
Of
course
it's
not
about
doing
plugins,
but
doing
courses
is
relatively
easy.
Everything
is
ready
for
that.
B
All
right
next
questions
from
bart
is:
can
you
or
are
you
contributing
back
to
wrestlings?
I
think
folks
be
grateful
for
that,
although
it
might
pose
challenges.
A
Absolutely
absolutely
so:
we've
added
several
exercises
new
exercises
and
we
want
to
add
them
to
rustlings
too,
unfortunately,
for
it
takes
a
lot
of
time
for
wrestling's
maintainers
to
keep
keep
along
with
all
pull
requests.
So,
of
course,
we'll
add
our
exercises
there.
Truly,
that's
that's
important
and
we
own
that.
A
No,
I
don't
think
so.
So
we
we
have
some
experience
of
other
courses
for
other
languages
like
for
kotlin
for
python,
and
I
should
say
that
this
wrestling
adaptation
is
not
very
popular.
It's
it's
less
less
popular
than
kotlin
or
python
course,
but
we
are
not
trying
to
explore
that.
So
I
wouldn't
say
this
is
a
mainstream
direction
for
our
educational
department.
So
we
don't
spend
resources
on
researching
that.
B
Got
it
well,
there's
another
question
similar
to
user
studies
from
galileo
who
asks:
how
do
you
integrate
feedback
into
the
courses?
I
could
imagine
this
being
a
super
valuable
tool
for
other
contributors
for
wrestling,
given
the
potential
for
tight
integration
of
the
feedback
system
into
the
ide,
slash
course,
functionality.
A
Well,
yeah,
first
for
for
every
task
we
have
a
special
button
for
sending
some
feedback.
So
you
can.
You
can
just
write
whatever
you
think
about
this
task
and
what
is
more,
this
course
is
published
openly
on
github.
So
anyone
can
add
a
task
to
it
can
just
fix
something
just
send
pull
requests
and
we
are
looking
at
that.
So
we
are
trying,
so
everything
is
open
source.
So
it's
it's
quite
easy
to
contribute.
B
B
It
seems
like
an
unstructured
process
like
how
do
I
tell
a
student
go
play
with
this
example,
and
so
I'm
curious
if
you've
seen,
I
don't
know
certain
patterns
of
interactions
or
if
there's
any
kind
of
methodology,
you
could
say,
helps
students
more
effectively
interact
with
examples,
so
they
learn
the
underlying
concepts.
A
A
I
don't
know
just
remove
this
and
see
what's
going
on,
so
you
just
show
them
first
and
then
they
know
what
to
do,
but
but
it's
important
that
they
are
not
working
by
some
predefined
steps,
because
predefined
steps
is
different,
so
they
do
need
to
start
learning
by
themselves
anyway.
So
I
just,
I
think,
it's
a
good
idea
to
show
them
examples.
First,
how
you
do
that
and
then
they
quite
quickly
pick
up
your
idea.
B
Great
rose
asks
a
follow-up,
which
is,
I
agree
with
the
idea
of
playing
in
lecture.
Is
there
a
way
to
replicate
that,
for.
A
Self-Studiers,
oh,
that,
that's
that's
a
hard
question.
I
don't
know.
Actually
maybe
it's
a
good.
Maybe
it's
a
good
idea
for
us
to
promote
this
course
just
to
regular
video.
How
should
we
work
through
this
course
and
show
that
so
maybe
thank
you
part
there
I'll
think
about
it.
Maybe
it's
a
good
idea
really
yeah,
so
just
just
just
to
show
how
to
work
just
by
some
recording
some
video.
Thank
you.