Alright, C++ has a ton of features. And most likely everything that Rust also has. And if it doesn't, there is somewhere a proposal out there dealing with exactly one problem that Rust also solves. But you know what, while coding it's not only about which features you have, but more about how effectively you can use them. What are the constraints that lead you to be a better developer? In this talk, we look at the expressiveness of Rust. We look at a central feature -- traits -- and see how it helps us write better and more robust code, and how it fosters communication and collaboration in teams.

Macros are the primary mechanism for metaprogramming in Rust, either to perform code generation or enforce constraints at compile-time that are not easily captured by the type system (e.g. sqlx). Macros are also limited: their input is a stream of tokens, with no type-level information. Up until last year, you had to hook directly into the compiler internals to get a more featureful representation. This is no longer the case, thanks to Rustdoc's JSON format: an information-rich representation of your Rust API in a machine-parsable format (with a versioned schema!). We will introduce the feature, look at the structure of the data and cover a few of the usecases where it shines. You will leave the talk with a basic understanding of the format and ideas on how you could leverage it to build tools that enhance your own Rust workflows.

Creating your own framework is always interesting and challenging. When you craft one, it is essential to think about the end-user and how they will use it in their daily programming life. Will it be intuitive for them, or will they need to read a lot of documentation to write some simple examples? All these questions are crucial.

In my presentation, I will talk about the process of crafting a framework using Rust and Procedural Macros, and the kinds of problems it might cause during development. I will discuss which libraries are better to use and the challenges they bring for the end-user. This will be useful for people who love Rust and crafting their libraries or frameworks using Rust. We will delve into procedural macros — what they are, how to use them, and their advantages and disadvantages. After the presentation, you will have a basic understanding of how to use procedural macros and how to apply them to libraries or framework APIs.