If you’re learning Rust, few things feel more confusing at first than the difference between Self and self. They look similar, they sound similar, and they often appear right next to each other. But once you internalize one simple rule, the confusion almost completely disappears. The Rule of Thumb (Memorize This) If a function does […]
2025 was when MCP and RAG made some headlines in the ‘AI’ world, but despite the hype and the counter-hype, we just got on with building. This design performs RAG with Qdrant and Rust. This article shows and gives an overview of a highly usable, and useful solution semantic similarity search Find highly relevant results […]
When learning Rust, it’s tempting to memorise snippets of code the way you might memorise incantations: copy, paste, hope it works. That approach fails quickly in Rust. What does work is memorising patterns of thought, and one of the most useful early patterns is the dance between Result, Option, .ok() and .ok_or(). A good example […]
aka “part 2” 🙂 So in part 1 we got the basics working, we set up a connection to Qdrant, made a new collection, and then checked the collection exists. We also wired up the code for FastEmbed to produce embeddings, so what next? How do we actually make it usable for a real project? […]
If you’ve written Rust for more than five minutes, you’ve met this error: At first glance, it feels nitpicky. You know both values are “basically the same thing”. Rust disagrees—and it’s doing so for a very good reason. Let’s break down what this error actually means and how to think about it like a Rustacean. […]
https://gist.github.com/rust-play/83b8b2bde4da2e392c42aab4482394d5 error[E0308]: mismatched types a Vec<T> must have one concrete type Try generics: This works only if all elements are the same concrete type. Generics require: But here: This is runtime polymorphism, not compile-time polymorphism. But our problem is: We want different concrete types in the same collection. Generics cannot express: “Many types, same interface, […]
If you’ve worked with Rust closures, you’ve probably encountered a peculiar problem: how do you return one from a function? The answer lies in understanding one of Rust’s clever features: the impl keyword in return position. The Hidden Complexity of Closures Here’s something that might surprise you: every closure in Rust has its own unique, […]
One of the most important design lessons in Rust is this: you rarely want to choose between generics or dyn Trait globally. The strongest Rust systems use both, deliberately, at different layers. This approach is often called the hybrid trait pattern, and it’s the sweet spot between performance and architectural sanity. The Problem: Generics Don’t […]
If you have ever looked at the code for a Rust web framework like Axum or Actix Web, you’ve seen the “Handler Pattern” in action. You define a function that does specific business logic, and somehow the framework knows exactly when to call it and what data to feed it. Often, this seems like magic. […]
