I agree with the fact that, while the explanations in the tutorial are
fine, they're way out of order. Even an experienced programmer needs time
to digest the material in its entirety.
Rust would make a really good first-to-learn-language, unfortunately that
material is not available yet.
On Mon, Apr 6, 2015 at 4:53 PM, Ryan Hiebert r...@ryanhiebert.com wrote:
Thanks Wesley, for your writeup. I’m still learning Rust, and I think your
post here is likely to give me some direction as I learn about some of the
unique features of Rust.
On Apr 6, 2015, at 8:55 AM, Wesley W. Terpstra wes...@terpstra.ca
wrote:
Yes, I discovered this, thanks.
I signed up for http://internals.rust-lang.org/c/documentation and
posted it there.
On Mon, Apr 6, 2015 at 3:34 PM, Oleg Eterevsky o...@eterevsky.com
wrote:
Hi Wesley!
That's a very cool analysis. This sounds very much like my thoughts
about
the tutorial.
I think you'd better post it on http://users.rust-lang.org/, since it
is the
main place for Rust discussions now. The mailing list is almost dead.
--
Oleg
On Mon, Apr 6, 2015 at 4:23 PM Wesley W. Terpstra wes...@terpstra.ca
wrote:
Good afternoon and happy easter,
I am a newcomer to Rust and recently finished working through your
tutorial. Before I get too much further into reading the standard
library, I wanted to share my experience as a complete Rust newbie
starting out only with your documentation, before I forget it. I
regret that I did not start taking notes immediately, but it was not
yet clear to me how much I was going to like Rust, so a lot of this
will be me recalling my experience, without notes.
First, my background. I've been programming in C++ for 20 years and
used MLton (Standard ML) heavily for about 5 years, 4 years ago. I
have dabbled with Haskell, but not seriously. So, as far as beginners
to Rust go, I suspect I would be the sort of person who should
definitely have been able to go through your tutorial and come out at
the other end with a clear mental model of the language, as I've been
exposed to almost all of the concepts before.
1- I had heard about Rust through the odd talk at ML workshops via
youtube, although the last ML workshop I attended in person was ~6
years ago. The main thing that raised Rust to my attention was your
v1.0 release which was mentioned on Slashdot. A few days ago, I saw a
comment posted somewhere that reminded me about it and contained these
two keywords: functional + no-GC. That got me interested enough to
head over to your main page.
2- I really liked how on the front page there was a feature list that
summarised what I could expect from the language. I was surprised not
to see a bullet point reaffirming that there was no garbage collector
necessary. I then started reading the Rust tutorial book in order.
3- Installing Rust on Mavericks worked perfectly and I was happy to
see it supported all three major platforms. I almost made the mistake
of installing the old rust package in macports instead of running the
macports version (0.12.0). From what I've read since, this would have
been a critical mistake since Rust has evolved so quickly in the near
past. Perhaps this package should be either removed or updated.
4- I was a bit annoyed that I had to wade through Cargo stuff before
getting to the details of the language, since I was still in the
evaluating if Rust is interesting phase and had very little interest
in packaging minutia in the introduction.
5- Coming from an ML background, I only needed to skim most of the
basics, taking note of which features were slightly different.
6- The moment I saw for x in 0..10, I immediately wanted to know if
I would be able to use the .. notation on my own types.
7- I was again annoyed by the crates/modules/testing sections at the
start of Section 3. I had completed reading the Basics section and
had yet to see why I should care about Rust. The key Rust feature,
resource management was still nowhere to be seen.
8- Finally I reached the Pointers section I had been basically
waiting to get to this whole time. Then I had to wade through pointer
problems that any C programmer already knows intimately, before
getting to how Rust does things. These two sections, 3.3 and 3.4, are
probably the MOST important sections in the entire tutorial, but they
come very late and are not well described. I would have expected to
see a top-down approach to explanation. A here is how Rust deals with
memory and THEN here is how this solves these problems. Instead, I
got a here are problems you already know and then a here's how Rust
does stuff. Due to this presentation approach, section 3.3 is very
disjointed and I didn't come away from it with a clear idea of how
this all works. It is also very jarring, because the rest of the
tutorial is pretty Micky-Mouse and then suddenly
