book VS too-many-lists

In my experience working with newbies, the alterations Brown makes to the chapters on borrowing are strictly worse. It is very focused on ramming the difference between the stack and the heap down your throat, which has nothing to do with ownership and borrowing, and newbies will frequently say that they are extremely confused by the chapter, then sigh in relief upon reading the original version. Just use the official guide, nobody has improved upon it yet. https://doc.rust-lang.org/book

Two decades ago, I learned HTML and CSS from the official W3C specifications. While I would not go as deep as learning from the language and compiler specifications, I chose the deepest option among the three, "the book".

The Rust Book the official, actually-readable Rust guide

Learning Rust is more alike to learning a new programming paradigm (e.g. functional when you only know imperative) than a new language with different syntax only. If you ignore that and try to jump directly to writing code more or less the same way as you used to, it will be painful. So take it slow and follow along with The Book (https://doc.rust-lang.org/book/). It all makes sense eventually and is very much worth it!

The Rust Programming Language (The Book) — Libro oficial gratuito, punto de partida recomendado para aprender el lenguaje.

Finish again The Book. ✅

I read The Rust Programming Language to get a basic understanding of Rust and its tools.

The Rust Book - Start here for Rust fundamentals Rust by Example - Hands-on examples Effective Rust - Best practices and idioms

I think they are likely referring to Linked lists in Rust, specifically.

See, for example:

https://rust-unofficial.github.io/too-many-lists/

https://news.ycombinator.com/item?id=22390662

> It's not easier in C++. Nothing is.

The implementations of sort in Rust are filled with unsafe.[0]

Another example is that of doubly linked lists.[1] It is possible to implement a doubly linked list correctly in C++ without much trouble. In Rust, it can be significantly more challenging.

In C++, pointers are allowed to alias if their types, roughly said, are compatible. In Rust, there are stricter rules, and getting those rules wrong in an unsafe block, or code outside unsafe blocks that code inside unsafe blocks rely on, will result in breakage of memory safety.

This has been discussed by others.[2]

Based on that, do you agree that there are algorithms and data structures that are significantly easier to implement efficiently and correctly in C++ than in Rust? And thus that you are being completely wrong in your claim?

[0] https://github.com/rust-lang/rust/blob/main/library/core/src...

[1] https://rust-unofficial.github.io/too-many-lists/

[2] https://chadaustin.me/2024/10/intrusive-linked-list-in-rust/

Efficiently implementing a linked list in C or C++ is easy. In Rust, less so.[0]

And the prevalence and difficulty of unsafe means both that Rust is not memory safe [1], and that Rust sometimes is less memory safe than C or C++.

[0]: https://rust-unofficial.github.io/too-many-lists/

[1]: For an example of memory unsafety in Rust: https://materialize.com/blog/rust-concurrency-bug-unbounded-...

Have you read https://rust-unofficial.github.io/too-many-lists/?

Too Many Lists - A fantastic deep dive into implementing various list types in Rust

As soon as you get into this you need to understand borrowing and Box/Rc/Arc which you will struggle with as a beginner. Once you feel comfortable with the basics, then dive deeper into these advanced data structures. There is even a whole book about writing many flavours of linked lists: Learn Rust With Entirely Too Many Linked Lists which I'd recommend reading only after you learn at least some of the core rust pointer types.

The borrow checker rejects loads of sound programs - just read https://rust-unofficial.github.io/too-many-lists/

Aliasing rules can also be problematic in some circumstances (but also beneficial for compiler optimisations).

And the orphan rule is also quite restrictive for adapting imported types, if you're coming from an interpreted language.

https://loglog.games/blog/leaving-rust-gamedev/ sums up the main issues nicely tbh.