<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"><channel><title>Jana&apos;s Blog</title><description>Talking about random things, often Rust related</description><link>https://donsz.nl/</link><language>en-us</language><item><title>Arenas</title><link>https://donsz.nl/blog/arenas/</link><guid isPermaLink="true">https://donsz.nl/blog/arenas/</guid><description>Sometimes you just really need an arena. Sometimes for performance reasons, other times for lifetime-related reasons.
In their most basic forms, they&apos;re just a vec with some extra guarantees. However, it&apos;s those extra guarantees that matter.
I&apos;ve found myself looking for the right kind of arena too many times, so here&apos;s an overview of literally everything there is.
I think, let me know if I forgot something.
</description><pubDate>Thu, 15 Aug 2024 00:00:00 GMT</pubDate><category>rust</category></item><item><title>It&apos;s the people that matter</title><link>https://donsz.nl/blog/externally-implementable-items/</link><guid isPermaLink="true">https://donsz.nl/blog/externally-implementable-items/</guid><description>Over the past two years,
I&apos;ve been involved with designing and implementing a new feature of rustc,
called &quot;externally implementable items&quot;.
This is not a finished feature, though if you&apos;d like you can try it on nightly already!
This is the story of how externally implementable items were invented, implemented,
and how some day they might be stabilized.
I&apos;m sure that is interesting to some of those who read this.

That&apos;s not the main thing this blog post is about, though.
Instead, I&apos;m using it as an example, to show you how the Rust project operates.
To show how many people are involved with a change, how they learn from each other, how I&apos;ve learned so much from them myself.
An example of how important _social_ interaction is to open source.
Much more than writing the code itself.

This is a written-out version of a talk I gave at Rust in Paris 2026.
</description><pubDate>Mon, 16 Mar 2026 00:00:00 GMT</pubDate><category>rust</category></item><item><title>Global Registration</title><link>https://donsz.nl/blog/global-registration/</link><guid isPermaLink="true">https://donsz.nl/blog/global-registration/</guid><description>You might not have considered this before, but tests in Rust are rather magical.
Anywhere in your project you can slap `#[test]` on a function and the compiler makes sure that they&apos;re all automatically run.
This pattern, of wanting access to items that are distributed over a crate and possibly even multiple crates, 
is something that projects like bevy, tracing, and dioxus have all expressed interest in
but it&apos;s not something that Rust supports except for tests specifically.
</description><pubDate>Wed, 10 Jul 2024 00:00:00 GMT</pubDate><category>rust</category></item><item><title>Incremental Compilation</title><link>https://donsz.nl/blog/incremental-compilation/</link><guid isPermaLink="true">https://donsz.nl/blog/incremental-compilation/</guid><description>Over the past week I&apos;ve been trying to understand rust&apos;s incremental compilation model
by implementing it myself. The one inside [rustc](https://rustc-dev-guide.rust-lang.org/queries/incremental-compilation.html) is already very
well documented, but the implementation lives inside of a giant compiler. Maybe this is a little more accessible to you!
</description><pubDate>Mon, 12 Aug 2024 00:00:00 GMT</pubDate><category>rust</category></item><item><title>Maintaining the Rust compiler</title><link>https://donsz.nl/blog/maintenance/</link><guid isPermaLink="true">https://donsz.nl/blog/maintenance/</guid><description>The rust compiler is a giant project. Hundreds of contributors help maintain it.
I consider myself quite lucky that this maintenance work has become my full time job.
Most of that time though, isn&apos;t spent to work on new language features, though there is a bit of that.
In fact, most maintenance is barely visible to users of the language.
So what does maintaining the compiler look like?
</description><pubDate>Tue, 28 Oct 2025 00:00:00 GMT</pubDate><category>rust</category><category>maintenance</category></item><item><title>Deprecated on re-exports</title><link>https://donsz.nl/blog/deprecated/</link><guid isPermaLink="true">https://donsz.nl/blog/deprecated/</guid><description>Deprecated is an attribute you can put on items to mark them as, well, deprecated.
Any use of that item will give a warning, telling you that you&apos;re using something that&apos;s deprecated.
The thing is, it doesn&apos;t always work...
</description><pubDate>Tue, 28 Oct 2025 00:00:00 GMT</pubDate><category>rust</category><category>maintenance</category></item><item><title>A small adventure in the standard library</title><link>https://donsz.nl/blog/exactly-once/</link><guid isPermaLink="true">https://donsz.nl/blog/exactly-once/</guid><description>While writing some machinery for dealing with spans on built-in attributes last month,
I was slightly bothered by a missing method on `Iterator`.
I usually work on the compiler, not the library, but I decided to write a little proposal, which was then accepted,
so today it was time to try and implement it.
In fairness, that implementation itself was mostly trivial, and yet right now there&apos;s no way to stabilize it.
What I actually want to share is the incredible compiler work going on as we speak that will unblock it. 
</description><pubDate>Mon, 24 Nov 2025 00:00:00 GMT</pubDate><category>rust</category><category>maintenance</category></item><item><title>Testing the crate root</title><link>https://donsz.nl/blog/test-crate/</link><guid isPermaLink="true">https://donsz.nl/blog/test-crate/</guid><description>I woke up last weekend, and someone assigned me to a PR to review.
That&apos;s quite common.
It fixed a crash with attributes, something I&apos;ve worked a lot on.
Some code crashed the compiler,
but the code to reproduce it used a specific nightly feature called &quot;contract attributes&quot;,
and I didn&apos;t believe that that was the only way to reproduce the crash.
So, I tried to see if any currently stable attribute would the same so the reproducer was more general.
It turned out: I was wrong!
But playing with it I found a complely new way to crash the compiler in a single line of code.
</description><pubDate>Tue, 28 Oct 2025 00:00:00 GMT</pubDate><category>rust</category><category>maintenance</category></item><item><title>A window to the past</title><link>https://donsz.nl/blog/a-window-to-the-past/</link><guid isPermaLink="true">https://donsz.nl/blog/a-window-to-the-past/</guid><description>My guitar tab of &quot;a window to the past&quot;, by John Williams
</description><pubDate>Thu, 22 Jan 2026 00:00:00 GMT</pubDate><category>music</category></item><item><title>The turn of a friendly card (instrumental)</title><link>https://donsz.nl/blog/turn-of-a-friendly-card/</link><guid isPermaLink="true">https://donsz.nl/blog/turn-of-a-friendly-card/</guid><description>My guitar tab of &quot;The turn of a friendly card&quot;, by the Alan Parsons Project
</description><pubDate>Thu, 22 Jan 2026 00:00:00 GMT</pubDate><category>music</category></item><item><title>Pipes in Python</title><link>https://donsz.nl/blog/pipethon/</link><guid isPermaLink="true">https://donsz.nl/blog/pipethon/</guid><description>A feature I&apos;ve always liked in languages, is the pipe operator.
Some version of this can be achieved in haskell, elixir has it, and nix has a preview feature for it.
And, most well known I think, bash has a pipe operator, though the way it operates on io streams is somewhat unique.
Especially in interactive REPLs, like bash, the operator is super useful.
So, this week I created a patch to cpython, that you can try out, that actually adds that!
Though, to explain this, I think it&apos;s cool to talk a little about good syntax design, and what I call syntax that &quot;goes with the direction of thought&quot;!
</description><pubDate>Tue, 06 Jan 2026 00:00:00 GMT</pubDate><category>python</category></item></channel></rss>