The lectures don't really teach you but just zip through code and explain what the code is doing. The learning is entirely self guided based on links provided and digging into the documentation. The instructor seems qualified as a technical expert but teaching and helping students understand isn't his strong point. For example one lecture talks about Dijkstra algo, its few minutes long zipping through the code but no explanation about how Dijkstra's algo works, motivations for when/where to use it outside of the given example. Same with other topics, like finding the most connected UFC fighter, which is sped run and nothing provided for how the algo works or generalized applications for it. Also parts of the videos are just deleted, with leaps of logic that you have to figure out what he did. Also, this part might be just me but the specialization seems to focus on the GitHub copilot and GitHub code spaces technologies and how Rust fits into it. However, in my experience, these tools might be useful for personal projects or open source work, however in a professional setting with proprietary code, these services are not permitted. So far any company that I'm familiar with doesn't want their code bases fed into a LLM outside the walls of their firm and prohibit their use.

This course is just useful as very general collection of keywords, one has to research on his own. Concepts are barely explained, sometimes in an extremely trivial way (security concepts in week 2, no real-world example, no guide through). In most videos the instructor just shows in 2-3 min a bunch of lines of code, without coding with you or explaining the choices made, potential errors, alternatives.... The whole thing with github codespaces is just adding unneeded overhead. Very sorry to say, but absolutely useless. Watching a couple of youtube videos or surfing through a couple of github repos would give the same learning experience...

too focused on prompt engineering, repetitive, repetitive videos

This is the first time I have seen such a disorganized course. It was excruciating to step through the "lessons". The authors copy-pasted material from other classes that they own and tried to pretend it was relevant. There was a lot of emphasis on using Github Copilot and others, honestly, that would explain why the course is so bad, 90% done by LMMs or something. Makes you wonder if this course was sponsored. Many times the concepts were not explained but they were mentioned, other times, concepts were explained but had no relationship to the lesson or were never talked about. Sometimes you would watch a video of the instructor going over copy-pasted code from a rust book and then see the instructor type comment suggestions to copilot and he would read whatever random string Copilot produced as if it was actual wisdom. The lessons that they borrowed from other courses sometimes were in pure python, sometimes they borrowed videos from random software security lessons, but very simplified in childish drawings. Some lessons were borrowed from their MLOps course, just to increase the lesson count of this incomplete course. Anyone thinking of taking this course is better off reading any of the free rust books. I can't believe I paid for this.

The level of depth here is underwhelming. All the important topics are referred to in the rust-lang book - you'd be better of just reading that. Different file formats should at least be covered - not just csv files. I was expecting much more, and wishing I didn't pay for this.

Many videos lack a direct relevance to Rust, or their intended explanations are unclear.

The content about the actual course's topic is very thin. Going through the material you see that the vast majority of the content was in fact reused from somewhere else and added there as padding, hiding the fact that material actually relevant for the topic at hand is scarce at best. Several quality issues also plague this course: - Same video used for multiple chapters, including an instance of having the same video on two consecutive chapters! (had to go back to make sure I wasn't hallucinating) - Typos even in name of chapters (LinkedinList ...) - Factually incorrect answers in quiz. In addition to quiz questions/choices not using precise vocabulary leading to confusion (a very common issue), some expected answers are just plain wrong. To give you a telling example, one of the question is "What enables Rust to prevent buffer overflows?", possible choices are "Runtime bounds checking", "The borrow checker", "Compile-time verification", and "Safe Rust". The expected answer is "The borrow checker", which is plain wrong. Worse, when selecting "Runtime bounds checking", the feedback says that Rust performs no check at runtime and relies on compile-time checks, which is also plain wrong. The rust compiler does insert bound checks that will be evaluated at runtime specifically to prevent buffer overflows, as many other languages do. You get the feeling that quiz where actually generated using an LLM without an afterthought. The insistence on AI companion tools and cloud-based environment throughout the course is also concerning, adding no value, just padding the course with meaningless "content" and creating confusion on a topic which is already quite complex and indeed could have been fascinating. Other reviews already give you an idea of what to expect from this course.

Astonishingly poor. Almost no actual data engineering, certainly not at anything resembling scale. Instructor uses bizarre "fruit salad" examples to demonstrate data structures, leaving the student with no intuition of when you'd use one or another (unless, I suppose, you had some tricky fruit salad-related work task). As an educator of sorts myself, I couldn't imagine putting something like this in front of students.

Too little Rust learning/usage in this course.

The course incorporates both basic and applied uses of rust. While they are both helpful, in the context of specialization I feel that some components of the course could be moved in the "Rust fundamentals" while this course focsues on more code based labs and assessments.

Thank you, it was a very good course. Nevertheless, I was hoping to contain also relevant examples for accessing Google Cloud resources with Rust, like BigQuery and Cloud Storage. Especially using Google recommended authentication methods using attached service accounts. Only AWS examples are provided.

Honestly, I can see that the instructor is highly knowledgeable, and I truly believe he is passionate about teaching and confident in the material. However, in this particular course, that expertise didn’t translate into an effective learning experience. A large portion of the course feels more like self-study than guided instruction. Many quiz questions refer to concepts that were never properly covered in the course content — for example, topics related to using C in Rust (or vice versa) came up unexpectedly without prior explanation or inclusion in the reflection questions. In some cases, a quiz topic was only explained in a later module, which created confusion rather than reinforcing learning. There’s also a noticeable focus on showcasing many advanced technologies like GCP, AWS, or Torch, but these are only touched on briefly — often just for a few minutes. While it’s impressive to see the instructor’s range, these segments feel superficial and didn’t help me understand the tools in a meaningful way. Another point of concern is that some sections are written in Python. While I understand this may be meant to illustrate a point, this is a Rust course, and introducing complex concepts in a different language assumes prior knowledge that not all learners may have. One of the most serious issues, however, is that the course content feels very outdated. In a language like Rust that evolves quickly and where ecosystem changes are frequent, keeping material up to date is absolutely critical. Unfortunately, this course doesn't reflect that pace of change, and much of it feels misaligned with the current state of Rust development and tooling. This is actually the first time I’ve left a course review, and it’s because I struggled a lot to get through it. I put real effort into researching the reflection questions and challenge exercises, yet I still walked away feeling like I didn’t gain much lasting knowledge. The course dives into too many advanced or edge-case details that might be more relevant to someone with a few years of Rust experience, rather than someone just beginning to learn.

I completed this course hoping to deepen my understanding of Rust in the context of data engineering—but unfortunately, it didn’t deliver on that promise. The focus is heavily skewed toward showcasing cloud technologies from Amazon and Google, along with online environments like GitHub Codespaces. Rust is used primarily as a wrapper around these services, with very little explanation of how the language itself works. The instructor frequently highlights Rust’s strengths in systems programming, but without offering meaningful examples or demonstrations. Key language concepts such as ownership and concurrency are briefly mentioned but never adequately explained. The course material is often limited to reflective questions rather than concrete instruction or useful explanations. If you're looking to actually learn Rust, this is not the right course.

by mistake u had taken this course , which s not in line for my leanring

date material; disconnected labs; poor coverage

Love how the content is not watered down. Videos are very efficient at conveying information.

This course helps me to up skill during my career break

Very interesting contents and material.

Amazing Corce I really enjoing it.

Exceptional Material and teacher!