Hands-On Systems Programming with Rust (Udemy.com)

Generally a solid introduction to using Rust in the DevOps systems programming context. It gives you everything you need to know to get started, and introduces you to some of the more idiomatic methods and approaches that you'll find in a production setting. That said, it is more of a guided tour of the foundations than a comprehensive treatment of code design for systems programming, so don't expect any deep dives into the multi-threading models supported by the Rust std library or idiomatic design of events, event handling or event processing loops, etc. TL;DR: The course will give you enough to get started with CLI projects such that you can realistically expect to write your own command line tools, but it stops well short of building the knowledge base you'll need to start designing complex software projects like a Rustacean.

This was excellently paced, gave a good amount of quick context / overview, and walked through more overall Rust concepts than I anticipated. You should have some programming experience coming in, and Rust exposure would also be extremely helpful (though you could still do this without either, you'll have your work cut out for you). Definitely recommend as a point of entry into applied Rust.

This course is a face-paced guide on how to put together a few third-party libraries to create a nice little command-line tool. I tried this course several months ago when I was an absolute Rust beginner, and it was more advanced than I could handle. I gave the course another try after learning a bit more Rust, and it helped me tie together some of what I learned. I say the course is "fast-paced" because it feels like the instructor planned out the code ahead of time. He knows which types he will use, and he types fast. Expect to pause the videos quite often. I found this to be a little disorienting at times.

Even though it's more than a year old, the course was more helpful than any other Rust course I've ever tried. Rust has an immensely steep learning curve, but Nathan Stocks, the instructor, manages to lead you through all the important concepts without getting either you or himself sidetracked with unnecessary details. Everything still works as intended which, I presume, is a result of the instructor's professionalism and Rust skills, since the language is still very young and changes a lot. That alone is worth taking the course. Fantastic effort, highly recommended.

Content is ok, but tbh this would be much better as a written tutorial. Learning goals are ill defined and all over the place. What makes the course ok is the overall solid presentation. One example about the learning goals: So in the course you first implement a rudimentary pipe viewer tool that works single threaded, in the following section you "refactor" the tool and split it into multiple loops that are supposed to run in threads. As part of the refactoring you introduce Arc bool> to check if the loop should be aborted. Now at the end of this refactoring the code compiles but does not work (and this is acknowledged) because the threads do not exchange data. In the following section the mutex gets replaced by a mpsc::channel. Why the broken intermediate step? What is to be learned here? Additionally the last 2 sections are extremely rushed and seem to be just some "left-over" content. To the author: I am sure you could improve your courses a lot if you would work on the following question: What do I actually want to teach? Would not buy again, but was an ok investment of time.

The course is very well structured and anyone with some rust knowledge should be able to understand and learn from it. I feel like the couse should be longer and go more into detail for many parts - functionality is added in large bursts and leave the student to do research on why it is done this way. It was especially irritating to see tests intruduced in a "addendum" section, while during the lecture the program is constantly tested by passing various inputs to the binary instead of making use of the extensive test capabilities of rust. All in all the course meets my expectations but feels very rushed and needs more depth.

One of the more enjoyable Rust courses I've done! It contains some videos on things other courses tend to skip such as unit testing and generating documentation, which was great to see. It would have been nice if the course included some of the more advanced and newer topics such as lifetimes and async/await but it makes for an excellent introduction to Rust.

Even if prior knowledge of Rust is assumed, it is a great course for beginners ⭐️. The content is very interesting and will even improve your terminal skills . There are many iterations over the project, so you have time to think it through. Take notes and expect a lot of debugging/problem solving/learning opportunities (I managed to chmod -x for all my Rust files by mistake while trying to do an executable , so yeah... Don't do that.). The author is great, very helpful and thorough in his replies when you need help. The one thing where the course can be improved has to do with the publisher. AC, AP-07 (and their friends R2D2 and C3P0) are lovely, but they are obviously very busy. It takes time to send questions back and forth to the author via the publisher.

I had read the "book" and found no way to keep going. This course is definitely something worth trying. The videos go through many features of the language and will give you a good understanding on how and where to use them. Having finished the course, I now feel more confident in writing Rust code, though there is still a lot more to learn.

I have taken a handful of other Rust courses. Most of the time, the courses cover the same core information about the Rust language. This one, however, covered a lot of new things that are actually very useful and completely omitted in the other courses I've done. This was fantastic. I am recommending this course to everyone.