Hello, Outreachy! Introducing Myself

Hi everyone, my name is Olamiposi and I'm one of the Outreachy interns for the May 2026 cohort. I'll be contributing to a-mir-formality, an early stage experimental formal model of Rust's MIR and type system, maintained by the Rust types team. Over the next few months I'll be working with my mentors (nikomatsakis, tiif, lqd, and Jack Huey) to help push the project forward.

Honestly, it still feels a bit unreal typing that out.

What motivated me to apply

I first came across Outreachy as a program that opens doors for people who don't always get a seat at the table in open source. That description hit home for me right away. I'm from Nigeria, I'm still fairly new to Rust, and the idea that I could spend an entire summer learning from people who actually build the language (not just use it) felt almost too good to pass up.

What kept me going through the application stages was honestly just stubbornness, mixed with how welcoming the a-mir-formality community turned out to be. The contribution period is hard. You're trying to understand a codebase you've never seen, in a language you're still learning, while juggling everything else in your life. There were days I stared at one function for hours and got nowhere. But every time I opened a PR, my mentors actually took the time to teach me, not just merge or close it. That kept pulling me back in.

What I learned during the contribution period

a-mir-formality is not a "good first issue" kind of project. It's a formal model, so there are proc macros, judgment systems, De Bruijn indices, trait solving, and a bunch of patterns that don't really exist anywhere else (#[term], judgment_fn!, fixed point computation, etc.). I had to pick up Rust idioms and formal semantics concepts at the same time, which was a lot.

A few things I learned beyond Rust syntax:

• Read before you write. My early PRs got noticeably better the moment I started reading the surrounding code instead of guessing.
• Verify, don't assume. It's tempting to say a change works just because it compiles. My mentors taught me to actually trace through the logic and back up every claim with evidence.
• Smaller PRs win. A focused 30 line change with a clear reason gets reviewed way faster than a sprawling refactor.
• Be concise. Mentors are busy. If I don't have something useful to add, silence is fine.

Contributions I'm proud of

By the end of the contribution period I had 14 merged PRs. A few that stand out:

• Coverage tracking infrastructure. I added positive test coverage tracking so the project can see which rules of the formal model are actually exercised by tests. This is also what my internship project builds on top of.
• Test macro refactor to a builder pattern. A quality of life change that made writing new tests less painful.
• Precedence related fixes. Small but real contributions on the parser side of the model.

Each of those felt impossible the day before I started them, which is probably the best sign that I was learning something.

What I'm expecting from the internship

My main project for the internship is a new formality-coverage crate that scrapes judgment rules using a regex, reads test coverage JSONL output, and produces a markdown coverage report. Eventually it will plug into the project's book (Niko is bringing an mdbook preprocessor for that part). The goal is that anyone, contributors, reviewers, or just curious people, can see at a glance how much of Rust's formal semantics is actually covered by tests.

Beyond the project itself, I'm expecting to:

• Get genuinely fluent in Rust, not just functional.
• Learn how an open source community at this level actually operates day to day.
• Make mistakes in public and live through them.
• Finish the summer feeling like I belong in this kind of work.

Thanks for reading, and big thanks to Outreachy and my mentors for making this whole thing possible. See you in the next post :)