
A 30-minute Introduction to Rust - aabelha
http://doc.rust-lang.org/master/intro.html
======
mattdw
I've only ever used GCed (and largely dynamic) languages up until now (Python,
JS and Clojure primarily); C is alien and C++ is frankly terrifying. With all
that, I've been having a ball using Rust to solve Project Euler problems, with
astonishing speed compared to what I'm used to.

It doesn't quite have all the libs you might want for general development yet,
but for the things it's currently equipped for it's a lot of fun, and
surprisingly easy. (Up until I find myself in a quagmire of lifetime problems
of my own making. Looking forward to the coming lifetimes inference
enhancement.) It's a surprisingly reasonable functional programming
environment too.

~~~
Pacabel
Why do you see C++ as "terrifying"?

Yes, it is a very powerful language and there can be a lot to it, but it
shouldn't "terrify" you.

These days, it's generally quite easy to avoid much of its C heritage
(including potential security pitfalls) if using the so-called "modern C++"
techniques, but the extra power and flexibility is still there if you do ever
need it. There are numerous ways of easily avoiding manual memory (or other
resource) management, too. The STL and Boost, among numerous other libraries
that are out there, offer lots of convenient, high level functionality. The
portability of C++ code is often quite excellent, the language and its
standard libraries are quite stable, and there are multiple commercial-grade
implementations from numerous vendors/projects. You probably won't find
anything else that gives you a high degree of performance along with high
level abstractions, while also giving you the peace of mind that your code
will still compile just fine years or even decades from now.

While it's certainly possible to to overboard and misuse C++ to a point where
it causes serious problems, one of the best things about C++ is that it
doesn't force you to do that. You generally don't pay for what you don't use,
and it's certainly possible to use a very effective subset of the language
much as one might use Java or C#, or even Python and JavaScript.

I'd say that C++ is even easier to use than JavaScript is. C++ is much more
sensible in so many ways, and nowhere near as quirky or just outright broken
in fundamental ways like JavaScript, while also providing at least some type
safety and other compile-time checks.

If you want a stable, portable, safe, well-supported language that offers high
level functionality without the performance tradeoffs of other languages, then
I think that a modern subset of C++ could very well be exactly what you're
looking for.

~~~
pcwalton
C++ is not safe in the same sense that Rust is. Without the use of "unsafe",
Rust is designed to never segfault or have undefined behavior, ever. Even a
modern subset of C++ cannot make the same guarantees (consider iterator
invalidation, etc.)

~~~
Pacabel
I'll gladly use modern C++ techniques and a bit of care, even if that means
only getting say 90% or 95% of the safety that Rust potentially offers offers,
if it also means that I can get my code written today, and I can trust that
it'll still compile unchanged tomorrow, next week, and probably a decade from
now.

I think it's great what Rust could potentially offer software developers. But
it's still pretty theoretical at this point. The language and standard
libraries aren't sufficiently stable enough for serious, long-term use,
currently. I hear we may start to see the beginning of such stability at the
end of the year, but until it actually happens, Rust isn't very useful, while
C++ is.

~~~
klibertp
Long-term stability is not exactly needed for Project Euler solutions, don't
you think?

I think you're overreacting here - somebody barely mentions a language and you
immediately start praising said language for features not even needed in this
particular person use cases.

~~~
Pacabel
I doubt that working on small casual programming puzzles is his only use for
programming languages. I read his comment as saying that that's merely all
he's used Rust for, so far.

Short-term and long-term stability are needed for just about any serious
software application or system. They're useful to have even for short scripts
that might be reused later on.

And he said he was "terrified" by C++. I explained why he shouldn't be. I'm
not sure why you're getting worked up over that.

~~~
klibertp
> I'm not sure why you're getting worked up over that.

I'm not! And I agree with all your points here. It's just that this is not a
thread about C++, but about Rust, and about solving small puzzles with it for
that matter. Which makes both original mention of being "terrified by C++" and
your explanation a bit off-topic. I won't downvote you or anything, I just
wanted to point this out.

------
steveklabnik
I wrote this a while back as a blog post, it ended up being the actual intro.
I hope to go over it again soon, and make it better. There's nothing super
wrong with it, but you can always improve! Feedback welcome.

Oh, and we had a big discussion last time:
[https://news.ycombinator.com/item?id=7051835](https://news.ycombinator.com/item?id=7051835)

~~~
letstryagain
I knew this was your work!

EDIT:

    
    
        concurrency.rs:12:20: 12:27 error: use of moved value: 'numbers'
    

Is this a compile-time or a run-time error?

~~~
pcwalton
Compile-time.

------
XorNot
I gotta say, reading this actually made me really excited about Rust. C++
without the annoying memory management but no GC-overhead sounds like a dream.

~~~
bjz_
Just to temper your enthusiasm, the compiler errors can sometimes be
irritating, especially when you want to do something the you are pretty sure
will be safe. But on the whole if you work with it the pay-off is well worth
the minor annoyances. Having the compiler always check your code for memory
safety is a huge win for refactoring - C or C++ code bases get really brittle
over time as developers forget what is actually going on. I would also say
that the number of errors you encounter over time reduce as you gain an
intuition for the rules.

~~~
dbaupp
_> especially when you want to do something the you are pretty sure will be
safe_

(It's worth noting that often the compiler is complaining because it
_actually_ isn't safe.)

~~~
chrismorgan
Indeed, I’ve been _certain_ that something that it’s not letting me do is
safe, only to realise a bit later that actually it was right in a subtle way.

There are certainly some valid things that the compiler will forbid which you
then need to work around instead, but by and large I trust the compiler to be
right more than I trust myself.

(Bear in mind, still, that these sorts of arguments of Rust’s superiority in
such things are frequently only applicable for comparisons with languages like
C++; often they are the sorts of things that a managed language would not have
a problem with, though also not infrequently it would lead to things like data
race.)

------
blub
Out of curiosity I implemented the two examples in C++11.

For the number add I used a unique_ptr (although returning by value would be
better in every way).

For the shared state I used async with a lamba that calls transform and
returns the modified vector through a future. This doesn't execute in parallel
for each for loop though. I think something like Arc can be coded in C++ too -
template wrapper that returns a RAII lock whick unlocks on scope end.

I think the only big difference is that some errors in Rust are happening at
compile time. In the first case the original buggy code was triggering only a
warning in C++.

Right now the extra compile-safety of Rust is IMO not worth giving up the
other benefits of C++, especially now that C++11 with some extra static
checking and good guidelines can go a long way.

~~~
pcwalton
> Right now the extra compile-safety of Rust is IMO not worth giving up the
> other benefits of C++

I can't speak to everyone's use case, but for ours memory safety is extremely
important. C++ is not safe, and we still see tons of memory safety issues,
many security-sensitive, in practice, despite using modern C++ for all new
code.

Even if safety isn't as important to you, there are other reasons you might be
interested in Rust: a module system, pattern matching, a standard library
which offers better performance than STL for many tasks, ADTs, concepts, a
package manager, etc.

~~~
Donwangugi
What kind of issues do you see still with modern C++11 code?

~~~
pcwalton
All kinds of memory safety issues. Heap use-after-free is very common. You can
go to Bugzilla and search for sec-critical to get a list of the ones Mozilla
has disclosed.

------
Demagog
Frankly, probably the best introduction to Rust is "Rust by example" [1]

This is much more in depth + possibility of running code on site. I don't
understand why rust site doesn't have links to this project.

[1] [http://rustbyexample.com/](http://rustbyexample.com/)

~~~
steveklabnik
> This is much more in depth

This is Hacker News, so I'll explain it to you this way: this is specifically
_not_ in depth. Have you ever done sales? The idea is that you need to figure
out if your customer wants to buy as quickly as possible, and if they don't,
move on. If they do, _then_ you move into the longform stuff. If your customer
isn't going to buy, it wastes both you and their time.

The idea of this short introduction is to split you into one of two camps: "I
want to know more about Rust," or "ewww." If you're in camp one, heading over
to the tutorial or Rust by Example is great!

~~~
AnimalMuppet
Yeah, an "in 30 minutes" article is probably _not_ going to give you "in
depth". It's not meant to.

------
pkulak
Wow, is Rust ever changing quickly. I think I read some docs a few months ago
and most of this was different. It's gotten better though. All that
punctuation for different pointer types was a bit too much. And this way of
using mutexes as accessors that unlock automatically when they leave scope is
brilliant.

I can't wait for Rust to be "done" (and get some kick-ass HTTP support).

~~~
steveklabnik
Thanks! We have slowly been removing the sigils. As a quick reference:

    
    
        let x = ~5;
        let y = @5;
    

is now

    
    
        let x = box 5;
        let y = box(Rc) 5;
    

(though obviously, boxing an integer is silly)

> and get some kick-ass HTTP support

[http://arewewebyet.com/](http://arewewebyet.com/)

------
shawkinaw
Is the language stable enough to learn yet (given that I won't be really using
it immediately)? I've been putting off looking at it because it seemed very
much in flux.

~~~
bjz_
For learning I would say it is. The biggest thing at the moment is API
changes. But the team is now pushing to put stability attributes on all
modules and marking deprecated items as such for a time before their removal
(these emit warnings if used).

I would highly recommend using the nightlies from [http://rust-
lang.org/](http://rust-lang.org/). A list of the docs can be found here:
[http://doc.rust-lang.org/index.html](http://doc.rust-lang.org/index.html)
Reddit is also good for keeping up to date on news:
[http://www.reddit.com/r/rust](http://www.reddit.com/r/rust) Also, IRC is your
friend! Join #rust at irc.mozilla.org, and feel free to ask questions. The
community is very friendly and willing to help.

------
zimbatm
How much cognitive overhead is it to think about ownership all the time once
you get used to it ? Coming from a GC-languages background I had a hard time
thinking in those terms last time I played with it. I ended up having .clone()
littered all over the place :)

~~~
pcwalton
I find that it's no more mental overhead than it is in C. The nice thing is
that the development cycle ends up being faster than C for me because I don't
have to spend as much time in front of the debugger.

------
zwieback
I like this a lot, the right level to get an idea of what Rust is about.

The last example illustrates that concurrency is complex no matter what
language you use - the code ends up reflecting the scaffolding enabling
concurrency and the actual work ends up buried inside.

That said, I like what I see.

------
njharman
Who is "behind" Rust? A company, consortium, academics, BDFL?
[http://www.rust-lang.org/](http://www.rust-lang.org/) doesn't have an about
page. Didn't see answer listed in the FAQ.

~~~
steveklabnik
Mozilla is behind most of it. The original creator has already left the
project, so we don't have a BDFL. There is a core team, mostly of Mozilla
employees. Tilde has been contracted to do the package manager, I have been
contracted to do documentation. There's a pretty significant community for a
language so young, our IRC channel has ~600 people in it.

------
peaton
As someone fairly new to systems programming, I can still see why you'd want
to pick a language like Rust over C. But can someone explain to me the
difference between Rust and Erlang? They are both system languages, no? Erlang
is much more established. But what are the key differences? And I'd ask,
"which should I learn?", but that is generally not a great question...

~~~
aidenn0
"Systems programming" is a broad term, so you are painting in too-broad
strokes.

I'm not super familiar with Erlang, so I may get some things wrong, but heres
a few differences:

Erlang prefers GC, wheras Rust tends to eschew it (it's available in a
library).

Erlang is dynamically typed where rust is statically typed.

Erlang is single-assignment where rust uses a somewhat more nuanced lifetime
system (though that is still changing).

Erlang prefers communication over channels, while rust has immutable types
that are safe to share.

~~~
peaton
Are there specific implementation models or areas or systems programming that
favor (or have come to use more exclusively) Rust or Erlang?

~~~
steveklabnik
A significant one is that Rust has no GC, while Erlang does. This can matter
if you're trying to build software that's very sensitive to random pauses, or
embedded development.

Another significant one is that Erlang has been used to make some of the most
reliable software ever for the past few decades, and Rust is still pre-1.0.

~~~
peaton
I don't mean to sounds skeptic when I say this: could you list some of the
software (or teams) that use Erlang?

~~~
bqe
An Erlang system has been created which has nine nines of uptime[1]. That is a
stunning achievement.

Riak, CouchDB, RabbitMQ, and SimpleDB are written in Erlang. These are mission
critical, mature projects.

[1]:
[http://stackoverflow.com/questions/8426897/erlangs-99-999999...](http://stackoverflow.com/questions/8426897/erlangs-99-9999999-nine-
nines-reliability)

~~~
ddamko
Also Facebook uses Erlang it for the back-end of their messaging tool and
Whatsapp uses it on the back-end as well.

------
geoffroy
I enjoyed reading this !

