Study using the "Rust for Rustaceans: Idiomatic Programming for Experienced Developers" book

🔗 https://nostarch.com/rust-rustaceans

Go through the entire book, getting a deep(er) understanding of the advanced concepts and inner workings of them.

At the end of the book you should be able to present your own GitHub or GitLab hosted projected based on the exercises and projects of the books, where you applied all your knowledge and also put in something of yourself in it.

Questions you should be able to answer at the end of this step:

  1. Be able to answer all questions from previous sections, in full confidence and in a lot more depth than you could do before.
  2. How is memory laid out for your Rust Data structures? Can you control it? If so, how?
  3. Explain in full detail so someone new to Rust can understand it what borrowing and lifetimes are, how do they work, why are they important, how do they affect us, how do we encounter it, why do we use it?
  4. What primitive types are there in Rust and how are they laid out in memory?
  5. What is the Orphan rule? Why is it important?
  6. What is polling in the context of Asynchronous programming?
  7. List some additional testing tools beyond unit tests? Why does each one of them matter?
  8. What is Pin and Unpin?
  • Note: Crust of Rust also has a great video about it should you need some more explanations about this tricky concept;
  1. Why is Asynchronous programming more complicated than parallel programming?
  2. How can you test your Asynchronous code? And because it is Rust, what kind of Asynchronous problems do we not need to test if we structure our code right? And why not?
  3. In the context of concurrent programming, what are actors?
  • Bonus question: why do some people see this as the future?
  1. What is FFI? Why do we use it?
  2. What is Rust without the STD? How do we use it and why?
  3. What are some common patterns found in the wild and that are discussed in the book?
  4. How can you continue to learn Rust?