Rust handles errors differently from many other languages: instead of exceptions, failures are represented explicitly in the type system using Result<T, E>. This encourages developers to model errors as real data, making programs easier to reason about and maintain. In practice, this often means defining custom error types that describe what can go wrong in a particular domain. The thiserror crate simplifies this process by removing the boilerplate normally required to implement Rust's error traits, allowing developers to focus on designing clear and expressive error models.

In this post, we walk through the fundamentals of structured error handling in Rust, explore how thiserror works, and show how to design practical error types for real applications.

Modern data exchange relies on the translation between language-specific memory structures and portable wire formats, a process dominated by the JSON standard. In the Rust ecosystem, this is handled by Serde, a framework that utilizes a unified data model to decouple data logic from format syntax. By leveraging compile-time code generation and zero-copy deserialization, the serde_json crate provides a high-performance implementation that bridges JSON's flexibility with Rust's strict requirements for type safety and memory efficiency.

This post explores the technical specifications of JSON, the three-tier architecture of the Serde framework, and the implementation details of serde_json that make it the industry standard for high-performance serialization.

HashMaps are one of the most common data structures in Rust, and also one of the first places where ownership, borrowing, and references really start to matter.

This post walks through 10 progressively more complex exercises that cover almost every practical HashMap pattern you'll use in real Rust code. Each exercise focuses on one idea, uses idiomatic Rust, highlights ownership and borrowing decisions, and builds on the previous ones.

If you can write and understand all of these, you're no longer "learning HashMap". You're using it fluently.

Hello, world! 👋

Welcome to my corner of the web, where I share experiments with code, and the occasional reflection on the intersection of logic and software engineering.

I'm Iago Bozza — a philosopher-turned-software engineer. I specialize in building sites with Hugo, Next.js, and Supabase, and I’m currently diving deep into Rust as I progress through the OSSU curriculum.

What You’ll Find Here

This blog is a space where I write about computer science and software development. Whether it’s design principles, programming languages, or tools I love (like Rust), you'll find posts that aim to inform and inspire.

A Little About Me

Before venturing into the tech industry, I taught philosophy at the University of Miami, where I dealt with topics like logic, metaphysics, and epistemology. These experiences shaped my approach to problem-solving and structured thinking—skills I now apply to software engineering.

Feel free to connect with me via GitHub or check out my "About" page for more details about my work and background.

Thanks for stopping by, and cheers to learning together! 🎉