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. […]
When you’re writing Rust functions, it’s tempting to bake specific behaviour directly into the implementation. But what happens when requirements change? You end up with duplicate functions or sprawling conditional logic. There’s a better way: separate the mechanism from the policy. The Problem: Hardcoded Behaviour Consider a simple event processor that extracts payloads from a […]
Understanding Handlers, Dispatch Tables, and Function Pointers If you’re learning Rust and you keep seeing the word handler, here’s the plain truth: A handler is just a function that gets called in response to something happening. That “something” could be: The key idea is you don’t call the handler directly.Some other part of the program […]
If you’ve ever looked at Rust MCP server code and seen ToolRouter<Self>, you might have been like “wtf, how can a struct contain itself? Isn’t that circular?” Let’s break down this elegant pattern that’s actually simpler than it looks. This does involve function pointers, which leads on to “why do we even want to use […]
What You’ll Learn By the end of this tutorial, you’ll understand how to build a Model Context Protocol (MCP) server in Rust that exposes tools AI assistants can use. We’ll build a simple calculator service with four operations. Prerequisites What is MCP? The Model Context Protocol (MCP) is a standard that allows AI assistants to […]
Zero-Sized Types in Rust, Explained Through the Facade Pattern One of Rust’s most surprising features is the Zero-Sized Type (ZST): a type that occupies no memory at runtime, yet still behaves like a real value. This seems paradoxical at first—how can something that takes no space still exist? The answer lies in understanding that in […]
This article explains why and how to use wrappers (like Parameters<T>) in Rust, and why destructuring is so powerful when working with them. Example Setup Here: Why Use Destructuring? 1️⃣ Easy Access to Inner Value Without destructuring, you’d need .0: Destructuring gives a named variable immediately: 2️⃣ Works Generically for Any T Your wrapper can […]
If you’ve worked with Serde deserialization in Rust, you’ve probably seen code like this: You might be wondering: Why use a function? Why not just a constant? Well I did anway! This tutorial explains the reasoning behind this pattern and when to use it. The Problem: Missing Fields When deserializing JSON into Rust structs, you […]
Regardless of whether AI is a bubble or not, it might be wise to build systems that are not dependent on AI for them to be able to function. My jobstr.work site is one such concept. Sure AI can query the relays and answer questions about the jobs listed, but equally you can use the […]
