17 ms·

Learning Rust

137 points by rogual 12y ago

rogual 12y ago
I thought it might be useful to document my experiences starting out with Rust, in the same vein as Artyom's "Learning Racket" series (http://artyom.me/learning-racket-1 http://artyom.me/learning-racket-1), which I got a lot out of. I really liked the style of that series when investigating Racket myself. That is, little to no preparation, and writing down everything you try, even if it doesn't work. Hope someone finds it useful.
- th0br0 12y ago
  I'd strongly recommend using Rust's nightlies. http://www.rust-lang.org/install.html http://www.rust-lang.org/install.html - they've even got pkg installers for Mac.
  - rogual 12y ago
    Thanks! I'm on the nightlies now, and things are going a lot more smoothly :)
  - sanderjd 12y ago
    You can also get the rust and cargo nightlies using homebrew-cask[0], which I find a bit easier (though I'm not exactly sure why). [0]: http://caskroom.io/ http://caskroom.io/
    - bjz_ 12y ago
      I've been using my own `rustup` script, but this is much nicer!
      - sanderjd 12y ago
        I actually use it with a `rustup` alias, because homebrew-cask isn't great at upgrading nightlies: alias rustup='brew cask fetch --force rust cargo && brew cask install --force rust cargo && git -C ~/.vim/bundle/rust.vim pull'
- krat0sprakhar 12y ago
  Thanks a lot for sharing this. Its going to be a lot of fun to follow. Sorry to throw feature requests at you but it would be great if you could add email subscription for this series. Also, although I'm a big fan of plain-text, I believe that serving .txt files might not be best for readability. If your blog / series is on github, I'd happily send PRs for above. Let me know :) Thanks a lot! Edit: If you prefer staying away from styling your blog then even writing the content in Markdown would do the trick
  - rogual 12y ago
    Hey, thanks for reading. I agree that I definitely need to improve the presentation — plain-text is a stopgap, really, so I could get something up there before I talked myself out of the whole thing :) I'm not a regular writer and don't have a blog, so it's not as easy as hitting 'new post' but I'll be sure to get something a bit more usable up soon. Edit: Converted to Markdown-generated HTML for now.
- sanderjd 12y ago
  This is neat. I really admire the willingness to document the type of stumbling around that characterizes lots of real programming, but which you rarely see. I think it's a bummer you can't do `LevelMap::new()` like you want, but here are two things that work that I think are improvements on your `mklevel` function: fn mklevel() -> LevelMap { HashMap::new() } That works because once the compiler knows that the return type is `LevelMap`, which it knows is really `HashMap<Coord, int>`, it can infer which variant of `HashMap::new` to call. Using this same idea, you can get closer to what you originally wanted without the function, like this: let mut map: LevelMap = HashMap::new(); There are also a couple things that I think are good syntactic improvements over the `Coord{x: 0, y: 0}` syntax that you made the `xy` function to avoid. First, you can just use a tuple: type LevelMapTuple = HashMap<(int, int), int>; let mut maptuple: LevelMapTuple = HashMap::new(); maptuple.insert((0, 0), 0); If you still want to give it a name, which I think is pretty nice, you can use a struct with anonymous members, like this: struct Coord(int, int); let mut map: LevelMap = HashMap::new(); map.insert(Coord(0, 0), 0); Here's a rust playpen link illustrating some of these things: http://is.gd/latFCh http://is.gd/latFCh. Enjoy!
- bjz_ 12y ago
  Would you be able to put your `rustc -v` at the top of the page?
  - rogual 12y ago
    Good idea. I switched versions partway through, but I'll list both.
- gwillen 12y ago
  sanderjd: Your comment (sibling of this one) appears to have been moderated. I suspect it's because of your use of is.gd.
  - sanderjd 12y ago
    Yeah, that has happened before - it's too bad because is.gd is just the shortener that play.rust-lang.org has built in. I suppose I could use a different shortener myself, but I suspect they are all similarly problematic.
hahainternet 12y ago
Rust is one of those languages I'm excited to learn, in about 2 years time. It's a shame there are so many comparisons between Go and Rust because it does both a disservice. Rust is still very much unfinished and still being developed, but despite this it is achieving its goals of complete safety and compile time checking. It's an admirable project, but it's got a lot of syntax fiddling and redesigning to go before I think it's 'prime time' ready.
- jbranchaud 12y ago
  http://blog.rust-lang.org/2014/10/30/Stability.html http://blog.rust-lang.org/2014/10/30/Stability.html
  - hahainternet 12y ago
    This is exactly what inspired my post. It's going to be some time before 'just use the nightlies' isn't common. I don't even mean it insultingly, there's nothing wrong with instability. I'm a big Perl 6 fan too.
    - Argorak 12y ago
      1.0 will be the time. The reason for using nightlies currently is that there is no stability guarantees over the releases (sometimes, your code broke just 2 days after release). So, release doesn't give you benefits, and you are learning an unreleased language, so nightly is the way to go. I'm pretty sure a lot of libraries will move to stable once there is something that can have the name.
- pcwalton 12y ago
  > It's an admirable project, but it's got a lot of syntax fiddling and redesigning to go before I think it's 'prime time' ready. We aren't doing much syntax fiddling and redesigning anymore. 1.0, which is very soon, will have a stability promise and will be backwards compatible.
  - 12y ago
kaoD 12y ago
I understand the frustration while learning Rust. As a Rust beginner myself, I suggest not to follow guides (except the ones at http://www.rust-lang.org http://www.rust-lang.org) since most are outdated. My way to learn Rust: I spend 90% of the time in Rust's std docs, 9% of the time watching the type/borrow checker spit at me and 1% of the time in IRC when I'm out of ideas. Google was useless most of the time. I found revisiting http://doc.rust-lang.org/index.html http://doc.rust-lang.org/index.html (specially the spec and the first four guides) as I was getting insights from experimenting with the language allowed to me to understand what was going on. For me the most important parts to understand to get up to speed were: - The module system (understanding `mod` vs. `use`). - The concept of ownership. References. Lifetimes. Borrows. Copies. Moves. Moving out of. `ref` on tuples. - Getting used to rustdoc's format. Docs hard to navigate not knowing the language idiosyncrasies. Trait methods are often not textually documented. - Understanding rustc error reporting. IMHO the worst part of rustc is the cryptic lifetime error messages (though they're getting better). Good luck in your journey! I'm loving Rust so far. --- Some concrete feedback: > This probably isn't right (I'm sure empty maps must be supported somehow), but it will do for now. Indeed. I see you joined the IRC (great idea, people are very helpful there) and got the correct syntax, but to fix the ~str problem, the answer is: let mut map = HashMap::<Box<str>, uint>::new(); Box<A> is the resulting type of an expression "box a" where `a` is of type A. I guess an example will make it more clear: let owned_three: Box<uint> = box 3; But Box<str> is actually just String, so the final line should read: let mut map = HashMap::<String, uint>::new(); By the way... why do you need to box the str? Local bindings (args, let bindings...) are allocated on the stack and must have a fixed size. A string has variable size by definition, but a box has a known size (the size of a reference to your heap-allocated str), so can can wrap the str (on the heap) on a box (on the stack). That's why you'll never see a sole `str` as a type: you either see the (boxed) String or &str (reference to a string slice). > Ah, OK. So I think this means Rust has no built-in way of determining if two int-arrays are equal. Actually the problem is Rust currently doesn't implement traits for static-sized arrays because the size is part of the type signature and each size would need to be implemented separately. https://github.com/rust-lang/rust/issues/7622 https://github.com/rust-lang/rust/issues/7622 Though the Coord solution you implemented is in my opinion better for a typed language.
- 12y ago
amelius 12y ago
I'm interested in Rust also. But I'm wondering, does it have these features, and to what extent? * coroutines * pure functional programming (enforcing it in an isolated subset of the code) * laziness * (clean) meta-programming * introspection * garbage collection Especially for stream-based programming (essential for internet applications), you'd need something like coroutines, to keep things manageable. I'm wondering if there is example code for a well-performing Rust-based web-server out there already. Also, how does Rust compare to other modern languages, like Scala?
- delluminatus 12y ago
  I can comment on a few of those. I'm not a Rust expert but I've been following it some. One thing I don't know about are coroutines. I know Rust has iterators but I don't think those are quite the same? Rust uses lazy iterators for everything (including functions like map, and datatypes like arrays). Rust actually has a full hygenic macro system (metaprogramming). IMO this is one of the coolest things about Rust. Rust does not use reference-counting GC. Instead, it has a fairly unique borrow checking system for garbage collection, which not only handles cleaning up memory but also cleaning open sockets, file handlers, etc. There is a generic type implementation of a reference counted variable you can use, though. Although there are no "pure functional" (i.e. side-effect free) guarantees in Rust AFAIK, the borrow checker actually catches a lot of issues that pure functional programming is meant to fix (i.e. issues from unexpected state mutation). Also, variables in Rust are immutable by default, you have to use the "mut" keyword to make them mutable.
  - veddan 12y ago
    >Rust does not use reference-counting GC. Instead, it has a fairly unique borrow checking system for garbage collection, which not only handles cleaning up memory but also cleaning open sockets, file handlers, etc. There is a generic type implementation of a reference counted variable you can use, though. Rust does not have garbage collection, unless you count using types like Rc<T> garbage collection. It has destructors, just like C++, and uses them for cleaning up resources like file handles and memory. Lifetimes do not really interact with destructors. They're part of the type system and do not have any effect on the generated code.
_random_ 12y ago
Syntax colouring would greatly improve readability. I completely understand author's frustration. Modern language is done once there is something like ReSharper for it. Rust is far from being done.
- Argorak 12y ago
  As a multi-lingualist, I don't agree. Languages should stand for themselves without tooling.
  - marvy 12y ago
    Some languages should, some should not. Probably a language like Rust should. Asking that of Smalltalk may be too much. But every language can benefit from tooling, even if it doesn't need it. For instance, do you know of any language more 15 years old that still has no debugger, let alone syntax highlighting?
    - Argorak 12y ago
      ReSharper and a debugger a completely different pair of shoes. I agree that you need a debugger (and Rust has one, gdb), but I don't agree that it needs refactoring tools.
      - BrandonM 12y ago
        Good IDE support is the difference between constantly hunting through (or thoroughly memorizing) documentation and having a program help you with it. It's also great for merging the edit and compile steps so that you can correct errors in realtime. Refactoring tools are nice but are not the strongest selling point for IDEs. I recall reading old Rust design considerations where they decided to stick with the `foo.bar` syntax because they like the way IDEs can autocomplete with documentation after typing the dot.
      - jbergens 12y ago
        I think a good refactring tool is one of the best ways to improve productivity for a developer. When you have a strongly statically typed language it should be possible to create really good refactoring tools. They don't have to exist at the same time 1.0 is released but I think they should be created as soon as possible after that point.
msie 12y ago
I love it! I'm sure everyone has had the idea of logging all their troubles but this guy has the fortitude to do it. It is troubling to see that Rust still has a way to go in terms of learning it. I was trying to learn Rust 1.5 years ago and ran into enough problems that I gave up. I will try again this week...
- bjz_ 12y ago
  > It is troubling to see that Rust still has a way to go in terms of learning it. Have no fear! Rust 1.0 is not far off and things will become a lot better then. Just be aware that google is pretty useless with now. You are much better off with the official docs: - http://doc.rust-lang.org/guide.html http://doc.rust-lang.org/guide.html - http://doc.rust-lang.org/std/index.html http://doc.rust-lang.org/std/index.html Also, be sure to use `irc.mozilla.org #rust`. We are very friendly and would be glad to help you out if you are stuck.
alkonaut 12y ago
This is exactly why a language needs to come with good IDE support. Compiler, libraries and documentation are only 3 of the 4 bits you need.
- bjz_ 12y ago
  Racer is looking pretty great - would be good to see it working with some IDEs: https://github.com/phildawes/racer https://github.com/phildawes/racer
Animats 12y ago
Rust is a potentially important language with weak, and badly organized, documentation. The "30 minute introduction" starts by introducing the package manager, manifests, crates, and lock files. But it's easy. It says so, twice! "You should feel right at home if you've used tools like Bundler, npm, or pip." Rust is the best hope we have of fixing the legacy mess at the bottom left from C/C++. I really hope the Mozilla crowd doesn't fuck up.
- dbaupp 12y ago
  > The "30 minute introduction" starts by introducing the package manager, manifests, crates, and lock files. But it's easy. It says so, twice! "You should feel right at home if you've used tools like Bundler, npm, or pip." Presumably you're implying something is not easy... But I don't understand why? That is, why does introducing the package manager (I.e. allowing people to jump straight in with nicer tooling) make the language not easy?
  - tormeh 12y ago
    Because beginners generally don't care about tooling, external libraries etc. They want a compiler (and preferrably a REPL) and some language pointers and then write a program that searches for primes or whatever.
    - shadowmint 12y ago
      There are lots of tutorials; if you want to dive straight into the code look at 'rust by example'. You dont even have to install rust to use it. Also, REPL is a cute toy, but absolutely not important and hard to do for compiled languages. If you want one, you can run your own copy of play.rust-lang.org; its actually pretty good.
      - ketralnis 12y ago
        I get that it's hard for compiled languages and I've learned to live without one for many of them. But "a cute toy, but absolutely not important" is way, way off the mark. When available, a REPL is a godsend and has saved me personally enormous amounts of time. Besides, there do exist compiled languages with REPLs (Haskell, Scheme, Common Lisp). Even Python has to compile the textual code into bytecode and execute that.
Fede_V 12y ago
This was really helpful - it's nice to see that he takes the same steps that I do when learning a new language. Interestingly, this highlights just how incredibly important up-to-date and authoritative tutorials/docs just are. Julia/scikit-learn are both absolutely amazing in this regard.
- bjz_ 12y ago
  The official docs are much better - they are under tests and you can't make a change to the compiler/libraries without updating them. http://doc.rust-lang.org/guide.html http://doc.rust-lang.org/guide.html
nkcpiytdhauwuhc 12y ago
Please stop using 0.11. It's a really old dialect or rust. Just work out of rust nightly, and use the docs on the http://rust-lang.org/ http://rust-lang.org/ to learn.

137 points by rogual 12y ago

I thought it might be useful to document my experiences starting out with Rust, in the same vein as Artyom's "Learning Racket" series (http://artyom.me/learning-racket-1 http://artyom.me/learning-racket-1), which I got a lot out of. I really liked the style of that series when investigating Racket myself. That is, little to no preparation, and writing down everything you try, even if it doesn't work. Hope someone finds it useful.

th0br0 12y ago
I'd strongly recommend using Rust's nightlies. http://www.rust-lang.org/install.html http://www.rust-lang.org/install.html - they've even got pkg installers for Mac.
- rogual 12y ago
  Thanks! I'm on the nightlies now, and things are going a lot more smoothly :)
- sanderjd 12y ago
  You can also get the rust and cargo nightlies using homebrew-cask[0], which I find a bit easier (though I'm not exactly sure why). [0]: http://caskroom.io/ http://caskroom.io/
  - bjz_ 12y ago
    I've been using my own `rustup` script, but this is much nicer!
    - sanderjd 12y ago
      I actually use it with a `rustup` alias, because homebrew-cask isn't great at upgrading nightlies: alias rustup='brew cask fetch --force rust cargo && brew cask install --force rust cargo && git -C ~/.vim/bundle/rust.vim pull'
krat0sprakhar 12y ago
Thanks a lot for sharing this. Its going to be a lot of fun to follow. Sorry to throw feature requests at you but it would be great if you could add email subscription for this series. Also, although I'm a big fan of plain-text, I believe that serving .txt files might not be best for readability. If your blog / series is on github, I'd happily send PRs for above. Let me know :) Thanks a lot! Edit: If you prefer staying away from styling your blog then even writing the content in Markdown would do the trick
- rogual 12y ago
  Hey, thanks for reading. I agree that I definitely need to improve the presentation — plain-text is a stopgap, really, so I could get something up there before I talked myself out of the whole thing :) I'm not a regular writer and don't have a blog, so it's not as easy as hitting 'new post' but I'll be sure to get something a bit more usable up soon. Edit: Converted to Markdown-generated HTML for now.
sanderjd 12y ago
This is neat. I really admire the willingness to document the type of stumbling around that characterizes lots of real programming, but which you rarely see. I think it's a bummer you can't do `LevelMap::new()` like you want, but here are two things that work that I think are improvements on your `mklevel` function: fn mklevel() -> LevelMap { HashMap::new() } That works because once the compiler knows that the return type is `LevelMap`, which it knows is really `HashMap<Coord, int>`, it can infer which variant of `HashMap::new` to call. Using this same idea, you can get closer to what you originally wanted without the function, like this: let mut map: LevelMap = HashMap::new(); There are also a couple things that I think are good syntactic improvements over the `Coord{x: 0, y: 0}` syntax that you made the `xy` function to avoid. First, you can just use a tuple: type LevelMapTuple = HashMap<(int, int), int>; let mut maptuple: LevelMapTuple = HashMap::new(); maptuple.insert((0, 0), 0); If you still want to give it a name, which I think is pretty nice, you can use a struct with anonymous members, like this: struct Coord(int, int); let mut map: LevelMap = HashMap::new(); map.insert(Coord(0, 0), 0); Here's a rust playpen link illustrating some of these things: http://is.gd/latFCh http://is.gd/latFCh. Enjoy!
bjz_ 12y ago
Would you be able to put your `rustc -v` at the top of the page?
- rogual 12y ago
  Good idea. I switched versions partway through, but I'll list both.
gwillen 12y ago
sanderjd: Your comment (sibling of this one) appears to have been moderated. I suspect it's because of your use of is.gd.
- sanderjd 12y ago
  Yeah, that has happened before - it's too bad because is.gd is just the shortener that play.rust-lang.org has built in. I suppose I could use a different shortener myself, but I suspect they are all similarly problematic.

hahainternet 12y ago

Rust is one of those languages I'm excited to learn, in about 2 years time. It's a shame there are so many comparisons between Go and Rust because it does both a disservice. Rust is still very much unfinished and still being developed, but despite this it is achieving its goals of complete safety and compile time checking. It's an admirable project, but it's got a lot of syntax fiddling and redesigning to go before I think it's 'prime time' ready.

jbranchaud 12y ago
http://blog.rust-lang.org/2014/10/30/Stability.html http://blog.rust-lang.org/2014/10/30/Stability.html
- hahainternet 12y ago
  This is exactly what inspired my post. It's going to be some time before 'just use the nightlies' isn't common. I don't even mean it insultingly, there's nothing wrong with instability. I'm a big Perl 6 fan too.
  - Argorak 12y ago
    1.0 will be the time. The reason for using nightlies currently is that there is no stability guarantees over the releases (sometimes, your code broke just 2 days after release). So, release doesn't give you benefits, and you are learning an unreleased language, so nightly is the way to go. I'm pretty sure a lot of libraries will move to stable once there is something that can have the name.
pcwalton 12y ago
> It's an admirable project, but it's got a lot of syntax fiddling and redesigning to go before I think it's 'prime time' ready. We aren't doing much syntax fiddling and redesigning anymore. 1.0, which is very soon, will have a stability promise and will be backwards compatible.
- 12y ago

kaoD 12y ago

I understand the frustration while learning Rust. As a Rust beginner myself, I suggest not to follow guides (except the ones at http://www.rust-lang.org http://www.rust-lang.org) since most are outdated. My way to learn Rust: I spend 90% of the time in Rust's std docs, 9% of the time watching the type/borrow checker spit at me and 1% of the time in IRC when I'm out of ideas. Google was useless most of the time. I found revisiting http://doc.rust-lang.org/index.html http://doc.rust-lang.org/index.html (specially the spec and the first four guides) as I was getting insights from experimenting with the language allowed to me to understand what was going on. For me the most important parts to understand to get up to speed were: - The module system (understanding `mod` vs. `use`). - The concept of ownership. References. Lifetimes. Borrows. Copies. Moves. Moving out of. `ref` on tuples. - Getting used to rustdoc's format. Docs hard to navigate not knowing the language idiosyncrasies. Trait methods are often not textually documented. - Understanding rustc error reporting. IMHO the worst part of rustc is the cryptic lifetime error messages (though they're getting better). Good luck in your journey! I'm loving Rust so far. --- Some concrete feedback: > This probably isn't right (I'm sure empty maps must be supported somehow), but it will do for now. Indeed. I see you joined the IRC (great idea, people are very helpful there) and got the correct syntax, but to fix the ~str problem, the answer is: let mut map = HashMap::<Box<str>, uint>::new(); Box<A> is the resulting type of an expression "box a" where `a` is of type A. I guess an example will make it more clear: let owned_three: Box<uint> = box 3; But Box<str> is actually just String, so the final line should read: let mut map = HashMap::<String, uint>::new(); By the way... why do you need to box the str? Local bindings (args, let bindings...) are allocated on the stack and must have a fixed size. A string has variable size by definition, but a box has a known size (the size of a reference to your heap-allocated str), so can can wrap the str (on the heap) on a box (on the stack). That's why you'll never see a sole `str` as a type: you either see the (boxed) String or &str (reference to a string slice). > Ah, OK. So I think this means Rust has no built-in way of determining if two int-arrays are equal. Actually the problem is Rust currently doesn't implement traits for static-sized arrays because the size is part of the type signature and each size would need to be implemented separately. https://github.com/rust-lang/rust/issues/7622 https://github.com/rust-lang/rust/issues/7622 Though the Coord solution you implemented is in my opinion better for a typed language.

12y ago

amelius 12y ago

I'm interested in Rust also. But I'm wondering, does it have these features, and to what extent? * coroutines * pure functional programming (enforcing it in an isolated subset of the code) * laziness * (clean) meta-programming * introspection * garbage collection Especially for stream-based programming (essential for internet applications), you'd need something like coroutines, to keep things manageable. I'm wondering if there is example code for a well-performing Rust-based web-server out there already. Also, how does Rust compare to other modern languages, like Scala?

delluminatus 12y ago
I can comment on a few of those. I'm not a Rust expert but I've been following it some. One thing I don't know about are coroutines. I know Rust has iterators but I don't think those are quite the same? Rust uses lazy iterators for everything (including functions like map, and datatypes like arrays). Rust actually has a full hygenic macro system (metaprogramming). IMO this is one of the coolest things about Rust. Rust does not use reference-counting GC. Instead, it has a fairly unique borrow checking system for garbage collection, which not only handles cleaning up memory but also cleaning open sockets, file handlers, etc. There is a generic type implementation of a reference counted variable you can use, though. Although there are no "pure functional" (i.e. side-effect free) guarantees in Rust AFAIK, the borrow checker actually catches a lot of issues that pure functional programming is meant to fix (i.e. issues from unexpected state mutation). Also, variables in Rust are immutable by default, you have to use the "mut" keyword to make them mutable.
- veddan 12y ago
  >Rust does not use reference-counting GC. Instead, it has a fairly unique borrow checking system for garbage collection, which not only handles cleaning up memory but also cleaning open sockets, file handlers, etc. There is a generic type implementation of a reference counted variable you can use, though. Rust does not have garbage collection, unless you count using types like Rc<T> garbage collection. It has destructors, just like C++, and uses them for cleaning up resources like file handles and memory. Lifetimes do not really interact with destructors. They're part of the type system and do not have any effect on the generated code.

_random_ 12y ago

Syntax colouring would greatly improve readability. I completely understand author's frustration. Modern language is done once there is something like ReSharper for it. Rust is far from being done.

Argorak 12y ago
As a multi-lingualist, I don't agree. Languages should stand for themselves without tooling.
- marvy 12y ago
  Some languages should, some should not. Probably a language like Rust should. Asking that of Smalltalk may be too much. But every language can benefit from tooling, even if it doesn't need it. For instance, do you know of any language more 15 years old that still has no debugger, let alone syntax highlighting?
  - Argorak 12y ago
    ReSharper and a debugger a completely different pair of shoes. I agree that you need a debugger (and Rust has one, gdb), but I don't agree that it needs refactoring tools.
    - BrandonM 12y ago
      Good IDE support is the difference between constantly hunting through (or thoroughly memorizing) documentation and having a program help you with it. It's also great for merging the edit and compile steps so that you can correct errors in realtime. Refactoring tools are nice but are not the strongest selling point for IDEs. I recall reading old Rust design considerations where they decided to stick with the `foo.bar` syntax because they like the way IDEs can autocomplete with documentation after typing the dot.
    - jbergens 12y ago
      I think a good refactring tool is one of the best ways to improve productivity for a developer. When you have a strongly statically typed language it should be possible to create really good refactoring tools. They don't have to exist at the same time 1.0 is released but I think they should be created as soon as possible after that point.

msie 12y ago

I love it! I'm sure everyone has had the idea of logging all their troubles but this guy has the fortitude to do it. It is troubling to see that Rust still has a way to go in terms of learning it. I was trying to learn Rust 1.5 years ago and ran into enough problems that I gave up. I will try again this week...

bjz_ 12y ago
> It is troubling to see that Rust still has a way to go in terms of learning it. Have no fear! Rust 1.0 is not far off and things will become a lot better then. Just be aware that google is pretty useless with now. You are much better off with the official docs: - http://doc.rust-lang.org/guide.html http://doc.rust-lang.org/guide.html - http://doc.rust-lang.org/std/index.html http://doc.rust-lang.org/std/index.html Also, be sure to use `irc.mozilla.org #rust`. We are very friendly and would be glad to help you out if you are stuck.

alkonaut 12y ago

This is exactly why a language needs to come with good IDE support. Compiler, libraries and documentation are only 3 of the 4 bits you need.

bjz_ 12y ago
Racer is looking pretty great - would be good to see it working with some IDEs: https://github.com/phildawes/racer https://github.com/phildawes/racer

Animats 12y ago

Rust is a potentially important language with weak, and badly organized, documentation. The "30 minute introduction" starts by introducing the package manager, manifests, crates, and lock files. But it's easy. It says so, twice! "You should feel right at home if you've used tools like Bundler, npm, or pip." Rust is the best hope we have of fixing the legacy mess at the bottom left from C/C++. I really hope the Mozilla crowd doesn't fuck up.

dbaupp 12y ago
> The "30 minute introduction" starts by introducing the package manager, manifests, crates, and lock files. But it's easy. It says so, twice! "You should feel right at home if you've used tools like Bundler, npm, or pip." Presumably you're implying something is not easy... But I don't understand why? That is, why does introducing the package manager (I.e. allowing people to jump straight in with nicer tooling) make the language not easy?
- tormeh 12y ago
  Because beginners generally don't care about tooling, external libraries etc. They want a compiler (and preferrably a REPL) and some language pointers and then write a program that searches for primes or whatever.
  - shadowmint 12y ago
    There are lots of tutorials; if you want to dive straight into the code look at 'rust by example'. You dont even have to install rust to use it. Also, REPL is a cute toy, but absolutely not important and hard to do for compiled languages. If you want one, you can run your own copy of play.rust-lang.org; its actually pretty good.
    - ketralnis 12y ago
      I get that it's hard for compiled languages and I've learned to live without one for many of them. But "a cute toy, but absolutely not important" is way, way off the mark. When available, a REPL is a godsend and has saved me personally enormous amounts of time. Besides, there do exist compiled languages with REPLs (Haskell, Scheme, Common Lisp). Even Python has to compile the textual code into bytecode and execute that.

Fede_V 12y ago

This was really helpful - it's nice to see that he takes the same steps that I do when learning a new language. Interestingly, this highlights just how incredibly important up-to-date and authoritative tutorials/docs just are. Julia/scikit-learn are both absolutely amazing in this regard.

bjz_ 12y ago
The official docs are much better - they are under tests and you can't make a change to the compiler/libraries without updating them. http://doc.rust-lang.org/guide.html http://doc.rust-lang.org/guide.html

nkcpiytdhauwuhc 12y ago

Please stop using 0.11. It's a really old dialect or rust. Just work out of rust nightly, and use the docs on the http://rust-lang.org/ http://rust-lang.org/ to learn.