Swatinem

This will be a personal opinion piece, as well as the thoughts behind an AI contribution policy I am working on for my personal projects.

Error handling in Rust is a complex topic.

Ich beschäftige mich schon seit sehr langer Zeit mit dem Thema Finanzielle Freiheit.

In my last blogpost about State Machine Replication, I discovered the interesting property that you can think of a state machine replication (SMR) protocol as a state machine itself.

About two months ago, I was joking with colleagues that I wanted to build service X, which should be a fault tolerant, highly available service.

I have been working on a usecase recently where I wanted to do some streaming uploads an downloads, both on the client- and the server-side.

Last week, I have written about the Dataloader pattern commonly used within GraphQL servers to avoid 1 + N problems that can pop up with a naive implementation of GraphQL resolvers.

It has been a few years that I have last touched GraphQL, but I am digging into it once more these recent weeks.

The short answer is: yes.

What do I mean by this clickbait-y title?

I have had a couple discussions around the topic of testing philosophy and what a good test is recently, and I want to dive deeper into this. # Background Let me give a bit of background first.

Today I went down quite a rabbit hole.

Investing and managing my finances is one of my hobbies.

I have already blogged about the surprisingly slow Rust thread_local!

Recently I was taking a look at benchmarking various approaches to small string optimization, and you can read up on that here.

Sometimes I really like to go down a rabbit hole and obsess about some tiny details.

One of the things I’m trying to drive recently at Sentry is introducing some form as strictly typed RPC.

These last couple of weeks, I have been obsessing over “the cost of observability”, specifically metrics.

It’s been a while that I wrote a proper rant, but today is the day.

This week, I have been profiling and measuring the overhead of the Sentry Rust SDK, as another team has reported a large overhead in their testing.

This weekend is the start of my week of chill at home and do nothing vacation.

# TLDR My phone was draining unreasonable amounts of battery lately.

Scope guards in Rust are awesome!

An alternative clickbait title for this could be: “Read + Seek considered dangerous”.

Interestingly, the same theme has come up multiple times recently within Sentry.

I have recently discovered that Rust Futures, or rather, async fn calls can lead to surprising performance problems if they are nested too deeply.

I started writing a series a blog posts explaining various debug formats, specifically formats that allow you to recover the original source locations.

It is the end of the year, and a lot of people are writing end-of-year posts, and outlooks for the new year.

Last week I was looking at the implementation details of async.

I have been looking at a lot of Rust async stack traces lately.

Before going on a slight rant about why rustdoc / doctests are broken, I first want to highlight that rustdoc / doctests are amazing !!!

In my opinion, one of the most important, but also very underappreciated skills is to think outside the box.

I have recently investigated a very interesting performance problem in Sentrys symbolication infrastructure.

Following up my last post about SourceMaps, this one here is about Portable PDB Sequence Points.

In my last post I committed to the idea of doing a deep dive series into a couple of debug formats, or more specifically, how their line mappings / line programs work.

If you want to parse binary formats in Rust, you have a few crates to chose from apart from rolling your own.

Before going into the details of my recent discovery, lets define the term Ossification, as likely a lot of people have never heard that word before.

Snapshot testing is quite popular.

I wanted to write about this topic quite some time ago, but it seems my tendency to procrastinate won in the end.

Today I want to talk about the need for better tools to work with self-referential structs, and also (safe) alternatives that alleviate that need for certain use-cases.

Both at work, and also personally, I do think about efficient parsers and data formats a lot.

As an engineer by heart, I sometimes think of social engineering challenges.

Now that I got your attention with the clickbait title, let me explain what I mean by it.

I realize I might be a bit late to the party, considering tmandrys blog post is already a month old, and there is now even an initiative focused on contexts.

With the recent talk about “Contexts” in the Rust community, and some other thoughts I had recently, I want to explore in a bit more detail what the difference between Futures and Tasks is in Rust.

Update: I updated the code examples now that GATs have been stabilized.

# Don’t do it Well first off the bat, I want to repeat something that I read some time ago: Don’t create your own bespoke binary format!

A quick note first: The "howto" does not mean I present a solution here, but rather that I am searching for a good solution.

There is an interesting TED-talk called The mathematics of weight loss which explains with chemical formulas and maths how bodyfat will be turned into \( CO_2 \) and Water.

I was recently investigating a customer issue where I got stuck at the point where I simply couldn’t seem to find any kind of unwind information for a specific piece of code, while the rest of the code had such information.