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 the main new concept >> of Rust is explained with only surface detail in two tiny >> sections---completely inadequately. >> >> 9- I entered the "Ownership" section quite annoyed from the terrible >> preceding section. I *still* don't really understand lifetimes, even >> after having sorted out the way Rust ownership works. These two >> sections are the worst in the tutorial, while also being the most >> important! >> >> At this point, I played around with Rust to try and understand the >> calling convention, move, copy, and borrow. I am pretty sure I >> understand it now, but I did *NOT* come away from the tutorial with >> this understanding. I would have presented the concepts in this order: >> >> 1. Rust moves objects by default. Include example showing that "let y >> = x" makes "x" invalid afterwards. Explain that this ensures that >> there is exactly one release to each allocate---something that can >> easily be understood even without explaining C pointers. Show that >> this applies to function calls as well; let x = Foo; f(x); >> println!("{:?}", x); // <-- Bad >> >> 2. Explain that some types can be copied instead. Mention that this is >> indicated by the "Copy+Clone" trait and show that "let y = x" and >> "f(x)" leave "x" valid afterwards. Mention that all basic types work >> this way, but that it is an opt-in feature. >> >> 3. Show the "#[derive(Copy,Clone)]" syntax which is AFAICT nowhere >> mentioned in the tutorial. You can understand this even without >> knowing the details of how traits are actually implemented. This shows >> a user that he controls the choice between move/copy semantics. >> >> 4. Now introduce Box::new(). Explain that it keeps its contents on the >> heap, but the pointer on the stack. Trust that programmers already >> know what heap/stack are without a bad recap. Demonstrate that move >> semantics mean that the heap object is freed exactly once. Perhaps >> mention that this is like C++'s unique_ptr. >> >> 5. Explain that Box needs a destructor to do the free. Introduce the >> concept of Drop. Explain Box can never be marked Copy due to needing >> Drop. Perhaps mention that Copy+Drop are the only two special traits >> in Rust (is this right?). >> >> 6. Maybe demonstrate another, more expensive, type of resource managed >> this way in Rust. Mention this automatic drop is something a GC >> language can't give you due to the lazy collection of finalizers. >> >> 7. Only now introduce borrowing. The existing explanation is fine, >> just out-of-sequence. >> >> 8. Now explain lifetimes as being a way to promise that the borrow is >> shorter than the life of the object or the borrow it came from. I am >> still unclear about which use of 'a defines the containing lifetime >> and which the contained. So, this definitely needs to be explained >> better, but I think it is WAY less important to understand the details >> of lifetimes than it is to understand the key concepts of: move vs. >> copy and RAII. >> >> This explanation (at least #1-#7) needs to come much sooner. >> Definitely still in the Basics sections. Anyway, back to my >> first-impression timeline: >> >> 10- Sections 3.5-3.7 were easy. One and done. >> >> 11- Associated Types (3.8). Why does this come before Traits (3.12)? >> >> 12- The closures section was very cool. *After* I understood Traits. >> Traits are so important in Rust they need to come first! I was missing >> an explanation of what the syntactic sugar of "Fn(int) -> int" is all >> about. I only sort-of understood the point about why a closure has >> undefined size when returned, but it is fine when used as an argument. >> My gut feeling was that it is somehow because you left the scope of >> the monomorphized function that produced it. >> >> 13- By the time I read "Static and Dynamic Dispatch" (3.13) I was >> hooked on Rust. At this point I'd already played around with rustc to >> understand the memory ownership concept. The static+dynamic dispatch >> is just so elegant, I was sold completely and totally at this point. >> MLton has to do escape analysis to determine which closures it can >> monomorphize away. That you put this directly under my control and >> completely side stepped this issue is just so elegant. Wow. >> >> 14- I skimmed over the rest of the sections without any problems. >> >> I have yet to write serious code in Rust, but the confluence of "Just >> the Right Ideas" (TM) has pretty much convinced me. The documentation >> of the 'std' library looks pretty good, a clear upgrade of the >> Standard ML basis library it is came from. ;-) At the moment I am very >> hopeful that Rust is the language I've been waiting my entire >> professional career to learn. >> >> Thank you for your work on Rust! >> I hope my user report can help you improve the experience for the next >> newbie. >> _______________________________________________ >> Rust-dev mailing list >> Rust-dev@mozilla.org >> https://mail.mozilla.org/listinfo/rust-dev _______________________________________________ Rust-dev mailing list Rust-dev@mozilla.org https://mail.mozilla.org/listinfo/rust-dev
