The lectures are very poorly prepared and full of errors. This makes them difficult to follow and understand. On the other hand, the quiz in week4 is extremely easy to pass, because no effort has been made to offer plausible incorrect multiple choice answers.

Do yourself a favour: If you dare to take this course, save yourself the entire first week: It is only advertisement about GitHub Copilot and GitHub Codespaces throughout. There is no relevant explanation of Rust itself in the first week and the advertisements are disturbing as this is supposed to be a course ABOUT Rust. The teacher rushes through the code countlessly mumbling "that is fine", which also comes in the variant "this is perfectly fine". Also popular are "we can pass [x, y, z] no problem", and "we can pass [x, y, z] for sure". Not, it is NOT FINE, if you introduce syntax that IS NOT EXPLAINED. Also not explained are instantiations of structs via implementations, the creation of options and the choices available and pretty much else beyond primitive loops. Also, data types are not explained AT ALL, and just pop up in the sample codes from nowhere. The teacher is not able to explain the code he wrote himself in a coherent, structured, way and is constantly mumbling and stumbling over his own code to pass runtime. It seems these were one-shot takes recorded hasty without any testing in the classroom. Unfortunately, I want to go as far saying this course is annoying and one of the worst ones I ever took on Coursera. This is a shame, as Rust is certainly worthwhile to be studied, and compared to C++.

The course spends too much time on knowledge that should be gathered before the course (e.g. VS Code specific information, GH Copilot information, etc). There are a number of assessments in the labs that occur prior to information from the lectures or are repeated.

The first lecture of this course is simply a product presentation for GitHub Codespaces and GitHub Copilot, with some explanations of VSCode, which are very basic. I guess JetBrains has not payed the same amount of money for product placement as Microsoft did ;-) From my point of view the first lector can be completely skipt. The later lectures are more focused on actual Rust. However, many explanations are very superficial, with silly examples. The labs are boring with the same silly example code and often there is not really a coding challenge but just a task like trying out all possibilities to ignore and select certain tests. On top of this, Rust analyzer did not work correctly inside the lab containers, so even basic code completion is not available. Take one week of time and read through the official and free Rust ebook and you get much more and deeper knowledge about Rust and especially the borrowing rules, than you can get it from this course. Sorry.

The course was a good intro into the rust ecosystem for Python/JavaScript devs but I would say it does miss the spark of the rust ecosystem. Instead of makefiles, justfiles or cargo xtask should've been portrayed. The specialization doesn't have an intermediate rust course, that only focuses on the language's features. So, probably this intro course should've catered more into the advanced features? Thread safety, multithreading, async, WASM, unsafe/FFI/linking with C libs are all missed out. I intend to learn about Tokio's (a rust async crate for tasks) task management and WASM platform support. The state of web frameworks(https://www.arewewebyet.org/), gaming frameworks(https://arewegameyet.rs/), machine learning frameworks(https://www.arewelearningyet.com/), and support for WASM and WASM's scope should've at least been mentioned in the intro. Also, linking to Microsoft learn and parts of the rust book is alright, but there should've been a proper walkthrough of the rust website, covering the rustlings course and rust by example apart from the book. The first look given to the viewers into the rust ecosystem should've been much better. I am planning to take up the whole specialization, so my views might change about the intermediate/advanced features of rust not being discussed. But I strongly feel the intro course, at least in the first week should've given a much better peek into the rust ecosystem.

The main purpose seems to be to push the AI copilot

Awful. Would not recommend. Emphasis on learning Copilot and other code assistants instead of teaching the language. Unstructured, missing content. Very low quality, any rust book is better than this course.

Save your time and rather do the MS Learning Course on Rust. It is far more comprehensive as well as comprehensible than this course. I understand that not all people are native speakers, but the instructor could at least script his videos before stumbling over terms for what seems like agonizing minutes.

Honestly disappointed. Too much beating around the bush instead of just explaining things.

Very poorly explained and there are no programming exercises to learn with. Better just go to: Official documentation and lear rust by example https://doc.rust-lang.org/rust-by-example

- A whole module dedicated to VS Code, Copilot, and other paid GitHub features is just ridiculous. It feels like watching a sponsored part of a YouTube video. I signed up to learn Rust, not Microsoft products. I'm a senior engineer, but I feel that even if I were a junior, learning about all these tools and services can be overwhelming and absolutely not necessary for the main topic. - I got a perfect score on the first 2 modules without watching a single video because the questions were so generic, even with my zero Rust knowledge, I could still answer without hesitation. That's enough to tell me this course has nothing to offer me. I was so excited to learn about ownership and borrowing.

While this course introduces Rust to some degree, the overall structure feels quite chaotic. If you're new to programming, you'll often find yourself wondering, "Did I make a mistake or is the training material off?"—unfortunately, it’s often the latter. Key concepts are either introduced without explanation or referenced long before they’re properly covered. I wouldn’t recommend this course for absolute beginners. If you're serious about learning Rust, the official Rust documentation is far more coherent and very well written—even if it doesn’t come with a certificate.

Its not what i expected

Alfredo Deza Is an Excellent Instructor Who knows his way through Rust and How to correctly express it to Beginners. I'm Glad I took this course. Left a really positive Impact on me.

Course is very good for this how start to learn Rust. It give essential knowledge that you can start to coding.

There are no graded programming assignments

The course does teach something, but it’s painful to get through—even for experienced programmers. Its structure is weak, and it’s unclear who the intended audience is. In the end, it covers some very basic programming concepts but fails to dive deeper into Rust-specific ideas. So, my feelings are mixed. I did take away a few things from the course, but it required far too much effort. I’ve completed other courses before, so I know what a well-structured and well-designed one looks like. This is not one of them. For less experienced programmers: look elsewhere. For experienced programmers: consider yourself warned.

The coverage is ok and the video lectures get you through a reasonable amount of material. Unfortunately the course is not well organized, even for an experienced developer. The labs expect concepts which are explained in later lectures. Lectures use examples (e.g. generics) with no explanation. Too much introductory time is spent on Copilot and odd Rust idiomatic usage. All links to external Microsoft material are stale.

Why questions regarding Codespaces and Copilot are mandatory? I don't want to use these features and spend time learning them. In my opinion they are interfere with learning Rust and they are depriving me of the opportunity to understand language deeper. These quizes should be optional and even better if they be removed from modules to 'additional materials' or something.

Pretty okay, but the lecturer is a bit fuzzy in his explainations. Quite often I've got a better explanaination from google or the rust doc for certain topics