Oh, and there's at least one more book in the pipe, and this one in particular is being developed by members of the Rust community... expect an announcement soon. :)
Packt books used to be good, their paper and cover quality aren't good.
Nowadays, it seems like they're trying to output as many books as possible regardless of the qualities. Most of the books are around 100-150 pages ugh.
On the other hand, Manning Publishing keep on taking my money, I really hope they start putting out book quality similar to Packt so I can stop spending money on them.
O'Reily have some really good book too like wise with No Starch Publishing. No Starch Pub have some of the best book material I've ever encountered minus web design books. Pragmatic Bookshelf have some quality books too and classic.
I've found O'Reily has maybe a ~70% hit rate. Everything they produce is generally at least Okay, but everything I've read from Nostarch has been worthwhile.
Manning is also great. Pragprog is also pretty great.
The Rust Programming Language Book has been a fantastic resource.
I was recently complaining to myself about some style and grammar issues (e.g. "Book" is redundant in the title of a book), but I realized I'm complaining about style and grammar issues of comprehensive documentation for a recently released programming language!
I respect the effort Rust and Steve have invested in documentation and hope their effort is replicated elsewhere.
Generally speaking, I would love complaints about style and grammar issues, to a point anyway. It's important to me that the informal / conversational tone remains, but generally speaking, I try to get the details right.
(We don't have 'book' in the title of the book, that's just the HN title.)
I read the book last week - thank you for writing it!
I really hope you reconsider your stance on the conversational tone, which made reading the book difficult at times. Being informal or conversational is not bad per se, but it leads to verbosity that obscures the content. Cutting out some of the current verbosity would make the book a lot clearer and easier to digest, and I think you can do this without sacrificing the friendliness and approachability of the book.
You're welcome. And understood, though as my siblings here mention, not everyone feels that way. I've heard a lot of things similar to what you're saying, but I've also heard a lot of "Thank you for not writing minimalist, dry prose."
I've been messing around with Rust since 0.4, but I've never really gotten super into it. Part of it stems from lack of time to invest in it (I have other priorities), but I've realized that my biggest struggle is that I've spent the last several years invested in a web background with OOP tendencies, and I have the hardest time elucidating my ideas into the Rust imperative language.
It would be awesome if there were more/better documentation on how to think about things in the Rust-style, as opposed to the OOP way that Ruby or Python or PHP (or to a lesser extent, Javascript) tend to espouse.
Coming from a dynamic languages background, it's great to see that systems details are introduced so those of us without C can get the hang of Rust. Great to see such a nice resource available.
And for my part, I'm glad that I will probably be able to read about higher-level[1] system programming concepts like custom allocators eventually, without having to grok C++.
[1] C isn't really crazy on the generic/meta-programming compared to C++, it seems.
Examples in Chapter "Mutability" are kind of difficult for newbies like me. With no prior knowledge given, It's very difficult to understand what `std::sync::Arc` is used for, and why it represents some kind of "interior mutability".
There are many other similar problems throughout the book. More work needs to be done.
Agreed. I've been focusing on getting the absolute basics in place, and it's already taken over 250 pages. I'm working on putting some muscle on that skeleton now.
I may just be not very bright but I've read both of those plus the coverage in the aforementioned book and I still regularly find myself banging my head against the borrow checker when writing code myself. I think at least part of the problem is the use of trivial examples.
I don't seem to have any problems with any of the other concepts used by the language except where they overlap with the borrow checker (e.g. destructuring a Box using).
I personally prefer the Rust documentation as a comprehensive reference than the cover-to-cover design of a book such as The C++ Programming Language. (As much as I prefer cppreference.com rather than Stroustrup's book.)
The Rust book is intended to be a quickstart to reading and writing Rust code. However it's when you start perusing the std crate docs that you really learn how to efficiently use the language.
Bonus points for the "src" link in the Rust docs. It always hurts when I have to read C++ stdlib implementation -- but I find Rust's stdlib source a quite pleasant read and a good source of examples.
the Cargo example fails to build.
Simply highlite copied to a src dir and it fails with:
failed to parse manifest at `/home/john/data/projects/rust/hello/src/Cargo.toml`
What's odd is that for me, even if I am in a `src` directory, cargo will keep going up the path until it finds a Cargo.toml. Maybe in this case, there is an extra Cargo.toml inside the `src` directory itself?
Packt also has a book on Rust which should be available soon, though I've never heard of the author and so I can't speak as to the quality: https://www.packtpub.com/application-development/rust-essent...
There's also this draft of a Kickstarter for a book on Rust, though again I've not heard of the author before: https://www.kickstarter.com/projects/1712125778/1409335994?t...
Oh, and there's at least one more book in the pipe, and this one in particular is being developed by members of the Rust community... expect an announcement soon. :)