Hi, I'm Franz. I work in the Applied Bioinformatics group at TH Bingen. I write scientific software, look after our compute server, and spend a lot of time asking whether a result really means what we think it means.

Good UX is half the point. Whether you click through an interface or call a function I wrote, you're my user. The developer on the other side of an API deserves the same care as anyone looking at a screen, because things are more fun when they're good to use. So I care about the details people notice without knowing why: a help text that fits on one screen, a menu that only offers what makes sense right here, an error message that tells you what to do next.

It's stupid if it could work better. "It works" is where I start, not where I stop. I'd rather find the solution that still holds up in five years than patch today's symptom. And I'd rather redesign something so a problem can't happen than guard against it case by case.

Everything is possible until proven otherwise. I like unconventional routes, and I don't accept "that can't be done" at face value. When something really does hit a wall, I want to know exactly where the wall is, and then build the strongest thing that still fits inside it.

I take the hard way when the reasoning holds. Rust is my favourite language because it fits me: strict, sometimes a pain, and still a pleasure to use. The compiler actually helps, and clippy, formatting and tests come built in. The language itself nudges you toward good design: match, traits, &mut making an in-place change part of the type, Result and Option making errors impossible to ignore. I trust it because it's strict.

• I distrust results that flatter me. A good number isn't evidence until I know why it's good. Often the most useful question is the one that could break a result I like.
• I hunt the case nobody tests. Changing the theme, renaming the file, reloading halfway through an edit. The bugs that make it into a release hide there. My repos even live under a path with a space in it, on purpose.
• I design before I build. I write down what I decided and what I rejected, so nobody later has to wonder why it isn't the other way round.
• Names matter. A good name explains itself to someone new to the topic. A great one also sounds right.
• One source of truth. If two places must agree, I'd rather make disagreement impossible than remember to check.
• Reproducible, or it didn't happen. Every result should trace back to what went in, what ran, and what came out.
• I run AI agents like a team. One builds, another reviews with its own evidence, and a design gets attacked before it gets built. The most valuable finding is still the one that proves me wrong.

• 🧬 Scientific computing: turning research code into something other scientists can use and trust
• 🛠️ Tools for developers: editors, terminals, documentation, code generators, build scripts that run anywhere
• 🔤 Languages and their rules: modern Fortran to the letter of the standard, Rust, and how a language's rules shape the code people write in it
• 💻 Operating systems: Windows day to day, WSL for everything in a terminal, and Linux distros tried side by side. Qubes OS is the most interesting one so far. What's missing is a Mac, and with it macOS and Swift.
• 🔢 Maths for fun: I once set out to find an O(1) primality test, because why not assume it's possible?
• 🎵 Music: I play the bassoon and I'm teaching myself to play by ear
• 🎨 Making things look right: from a colour scheme to a whole website painted on a canvas

I'm curious and direct, and good evidence changes my mind faster than a good argument. I build things for more people than just me. I'd rather ship a smaller finished thing than a bigger half-designed one. English or German, whichever comes easier to you.