Rust Dortmund Meetup - From Segfault to Safety @DiWoDo

We go #DIWODO
Register here: https://www.diwodo.de/events/diwodo26-from-segfault-to-safety-conciso

From Segfault to Safety
An evening about migrating legacy code to modern tech stacks
Target audience
Developers, tech leads, architects, and CTOs. Especially if you maintain aging legacy systems, and feel the pain of velocity tax or security/compliance risks, and want to weight solutions. No Rust experience required.
The evening
Teams don't migrate for fun. They migrate because maintenance costs climb, features take longer, CVEs turn into bad publicity, and performance ceilings turn into scaling bills. Three talks: why you'd migrate at all, why Rust is the target so often, and one team's case study.
Talk 1 — Migrating Away From Legacy Code: From Pains to a Cure
Jan Vaorin
What actually makes code "legacy," and which pains justify the effort: rising maintenance and feature costs, security exposure through CVEs, and performance ceilings that turn into scaling bills. Then the practical part — which migration strategies exist and when each one fits.
Talk 2 — Rust Migrations for Fun and Profit
Tim Janus, Janus IT
Teams typically migrate for scaling economics, security and compliance, or time to market. Rust addresses each case, backed by industry security reports and performance case studies that do not sacrifice safety or reliability.
We explore migration scenarios to determine the possible scope of migration projects, and why migrating to Rust is widely regarded as more enjoyable, and how that helps your software project downstream.
Talk 3 — Wrapping Legacy SuperLU vs. Rewriting It in Rust
Henrik Stromberg
Economics of a Rewrite with Agentic Programming
Henrik Stromberg, Dr. Q
We wanted SuperLU — a mature sparse solver from Lawrence Berkeley National Laboratory — in our Rust stack, and followed the conventional advice: keep the battle-tested implementation, wrap it in a narrow Rust interface, defend the boundary with tests. After ~18 developer-months, we changed course and rewrote it. The rewrite took under six.
Owning it natively also made the solver far faster to understand and improve. We'll cover how we did it, where agentic coding changed the economics, and what it means for a decades-old assumption: "Wrapping mature dependencies is safer and cheaper than rewriting them."
Schedule
17:00 Doors open
17:30 Talk 1 — Migrating Away From Legacy Code: From Pains to a Cure, Jan Vaorin
17:45 Talk 2 — Rust Migrations for Fun and Profit, Tim Janus
18:00 Talk 3 — Wrapping SuperLU vs. Rewriting It, Henrik Stromberg
18:45 Q&A and networking
20:15 End