Matthias: Another season done.
I truly can't believe how quickly time has passed, and to some extent
that's a good thing because I truly enjoyed this recent set of interviews.
It might have been my favorite one so far.
We saw a well-rounded group of Ians talk about their experiences with the language
guests ranged from developer tooling with estro over web backends with s vix, all
the way to operating systems and cloud infrastructure with Microsoft, and
a truly inspirational interview with Nico Makis from the Rust Core team.
In Nico's interview in particular, which we recorded at Rust Week in the
Netherlands, he said something that truly changed the way I see Rust.
He said that the goal of Rust is to help build foundational software, and
that inspired me so much that I even wrote an entire blog post about it.
I'm not gonna repeat everything that I said in that blog post, and
I will link to it in the show notes.
but I wanted to take the opportunity to reflect on the recent season in light of
this new understanding of the language.
First, let's hear it from Nico himself.
Niko: Foundational software.
It's the software that everybody else builds on, and that could
be many different things, right?
I think sometimes that's like the kernel that's very literally the
thing that everyone else runs on.
But other times it's a CLI tool that's super widely used and it's
part of the scripting setup you use.
That kind of software has particular characteristics.
It needs to be really reliable because if it breaks everybody else's
stuff breaks, it needs to be fast because everyone's building on it.
And so whatever performance hits you take there, everybody has to to work with, and
it has this long-term maintenance story.
Matthias: Foundational software is different from systems
programming software in a sense that it's wider in scope.
What foundational software is largely depends on the
organization writing the software.
It can be as varied as a package manager, a storage layer, or a rust backend.
I think rust is excellent for this type of work where correctness and
stability are of utmost importance instead of following the worst better
approach that we know from systems like Unix or other programming languages.
Rust is very much an MIT like language.
It wants you to do the right thing and do the thing right, the right thing.
Designers are equally concerned with simplicity, correctness,
consistency and completeness.
And I truly believe this is where Ross is amazing.
In some of my consulting calls, people ask me if Ross is the
right choice for their project.
It typically comes down to is the software that you build foundational?
That means do you expect to run it for many years to come?
Does it serve as a platform for other tools and software in your organization?
Do you care about robustness, stability, and long-term maintenance?
If you can answer all of these questions with, yes, there's a
high chance that rust is indeed the language that you're looking for.
But if you are just looking for a quick solution or you want to build a
prototype or you care more about fast results than a healthy co base, then Rust
might not be the right choice for you.
The companies that were guests in the season all build
foundational software with frost.
Let's take one password, for example.
The core abstraction is to handle passwords for millions of users, and
that definitely needs to be rock solid.
Undoubtedly, they build foundational software.
Or take Ksat controlling hundreds of satellites with rust or swix
handling millions of webhooks.
All of these things must not fail.
They must work with the highest criticality, and I think that's what
Rust should focus on, , or at least focus their marketing efforts on in the future.
But isn't foundation software just systems programming?
I believe that systems programming has its place, but the term is so overloaded
by now that it's lost much of its.
It's difficult to say that Rust is a systems programming language
without being lumped into the same category as c plus plus.
In that regard, I think systems programming is also limiting.
It feels elitist somehow, whereas Rust aims to be very inclusive and enables
everyone to learn how systems work.
Here's Charlie Marsh from Astral, the team behind uv.
Charlie: I never considered myself to be like a systems programmer, quote unquote.
In most of my career, I was writing TypeScript Python.
I mean, I did some Java professionally, but like I had never, except for like
a course in college done, NECI really hadn't done DC plus plus and like
in the span of a few years, I like learned to build this kind of software.
Matthias: And here's Andrew Burkhart from One Password.
Andrew: I also have no computer science background.
I was a construction worker before, and I worked at, you know, a
drugstore before I became a developer.
So I had no idea about binary trees and sorting.
I, I still really don't, to be honest, but it's, rust has a way of bringing
those things out in you, which is hard at first, but it also helps you to shore them
up because you see where your gaps are.
Matthias: People are able to do systems level work without noticing.
Thanks to Rust.
They just learn things as they go, and before they know it, they
manage to write critical software components for their organizations.
Often without formal training, while they can still be confident
that their code is memory safe.
And you know what's funny?
The way people see rust from the outside is totally different
from what's actually happening.
People think it's this hipster language that only hobbyists mess around with
on weekends, or they think it's some over-engineered thing that only Google
and meta use for crazy complex stuff, or that it's just an academic research
language, but that's just not true at all.
I see companies all over the place using rust.
Small teams, big teams here in Germany, everywhere.
They're solving real problems with it.
Let's hear from some of the guests from this season about
how they use rust in production.
First, Nik Makis
Niko: Most people I talk to are not aware of how much rust is in in production
at Amazon, like every S3 request.
Every EC2 VPC, you can tell my ignorance of even our own product line.
Uh, uh, every lambda and vocation, these things all go through rust.
They also go through other languages.
So I'm not saying that the exclusively written in rust by any means, but
more and more the, the hot path of a lot of these big services that
you know is, is being rewritten and rust or re-architected and rust.
Matthias: Andrew Burkhard out from one password.
Andrew: But there's, there's probably, I think we have a couple hundred
developers now working across all the different products that one password
and, you know, collide and Passage and Trca and so forth have, but we probably
have, I don't know, I'd say a hundred people that work pretty heavily in Rust
or, or, or maybe 50% or more in Rust.
Something like that.
Matthias: Charlie Marsh from Astro
Charlie: I think last I checked, it's like a little over 12.5% of
all requests to the Python index come from uv, which is like over 200
million requests a day, which is wild.
Right?
And you know, I spend a lot of my time talking to companies.
There are tons of like 1 billion, 10 billion, even a hundred billion dollar
companies that are using this thing in production and have been for a long time.
Matthias: Victor URA from Microsoft.
Victor: I think we reached an inflection point in the company where it's sort
of we're all in on rust, as in we're committed to being, making rust succeed
at Microsoft because we've seen so many successes in various projects and teams
are no longer sort of treating it as a hobby experiment to happy accident
that this thing works great in rust.
Matthias: Not everything has to be webscale, though.
It's not just systems programming either.
This encouragement and its inclusivity is what makes the community so great.
And as someone who's part of the Rust community, you should also reflect
those values and be supportive of newcomers on their journey to discover
their true potential with frost
as Adam Handel from Timbo noticed.
The developer experience is great at any scale, you can just
start small and grow from there.
Adam: Yeah.
Most of, most of the time, if I'm building a web server today, I, I'll
just grab aps and, and run with it.
You know, if I'm working with Data and Postgres, I'm gonna grab SQL X.
10 years ago it would've been like flask or Fast API, or maybe not 10
years ago for Fast API, but you know, I have the equivalent of everything
that I would, you know, five years ago would've gone to something in Python.
I have, you know, for me, I like, I'd just pick rust.
It's just easier.
It's a better experience.
Matthias: Developer experience is not just about the language itself, but also
about the tooling and the ecosystem.
Rust has cargo, which is a game changer.
Adam: I came from Python and it was like, how do I get my environment
set up to, to run my application?
And at the time it was like, do I use virtual end?
Do I use poetry?
Do I just install everything with pip?
You know, it's just, it's a mess.
Like there's some projects that are making it better in Python today,
like UV is doing a really great job cleaning up that, solving that problem.
But when I was learning Rust, it was like, Hey, how do I run this?
How do I run this application?
Oh.
Cargo run.
That's it.
You know, how do I test it?
Cargo test, you know, it, uh, it was just so intuitive.
Matthias: And once you get the hang of it, you can build really
powerful stuff really quickly.
Suddenly you find yourself writing extensions for your database in no time.
Adam: To go from like nothing to a Hello World example, it was like an
hour or less to create an extension that, you know, you write some function
in rust turn that function into a SQL function that you could call.
That was like super easy.
So it was kind of, you know, like we didn't have to, it it, we were, we
were up and running really quickly.
Matthias: Adam's journey is not unheard of in the Russ community, and all of
this is to prove that Rust is enabling people to reach further, further
than they themselves thought possible.
You can build stuff that you never thought you could build before,
and that's what I love about Rust.
If you're an old timer, you might still remember the great series
of blog posts about rust being like a fire flower or a chat pack.
something that sort of unreasonably makes you extremely powerful.
Here's Charlie Marsh
Charlie: I do feel like I'm constantly guided by the compiler, and actually more
and more I think the way I write code is that I try and make it such that I will
be guided by the compiler in the future.
Matthias: and here's Tom Koen from svi.
Tom: I think rust really got it right, uh, in the, in how to do error
propagation, which is, you don't, you can't just like willingly throw random
exceptions all the way up to the stack.
Like you have to catch them at every step and define the, you know, like properly
define the, the signature and kind of like the contract that you have with the color.
And with rust, you spend more in the beginning, but actually that then later
on you don't have to spend as much energy.
Uh, and I think now we move fast.
Matthias: And that metaphor still holds true today, but I think there's
something deeper going on when you look at all the companies I talked to
in this season, they're not just using rust to feel powerful or to show off.
they're using it because they need something that's going
to last something reliable.
Gradin wrote a nice blog post about 10 years of stable rust, and I
highly recommended in this post.
He also talks about rust for writing software that underpins other software,
and I think that's the thing about Rust.
It's really a language for decades when you're building foundational systems,
you're betting that this stuff is going to pay off in the long run that organizations
and society will benefit from what you're building for decades to come.
We are building systems that people will use every day and they might
not even know they're using them, but they still depend on them.
That's what critical software is all about.
Here's Tom Hackman
Tom: So really I think when it comes to infrastructure, like really the
best you can do, even if you do everything perfect is just have a
neutral effect on your customers.
Your customers won't notice that you spend all of this time on it.
So, and this is part of what we hope you do to do, is really just like give your
customers a state of the art experience.
They don't think about it, they don't worry about, it just works.
And for you, you don't have to maintain it and worry about any of that.
, Matthias: and Ru lets you do all this with really great ergonomics.
for example.
Let's hear it from Virga, sanding in from Ksat.
Vegard: The one thing I miss every time I go to any other language is just the enum.
I think this I could model very well in an enum, and I don't have
this capability and it saddens me.
Matthias: It's like Ru took the pragmatism from c plus plus and the Purism from
Hasco you can build software that's sustainable, that doesn't waste resources
where precision and correctness actually matter stuff that works across different
languages and up and down the stack.
Vegard: So we are resource constrained in the fact that we don't want to
overprovision every data center around the world near to all our antennas on
our ground station sites, because first of all, we don't necessarily have the
resources to do that, and we don't have the ability to do it at some point.
So it's nice to use something that doesn't hogg all the resources
. Matthias: I don't want to dwell on it for too long, but have
you heard that rust is fast?
I mean really fast.
The fastness itself is not the point, but the fact that it
allows you to run more with less.
You can run fewer instances of your service, which means fewer
servers, which means typically less ops work and therefore less
money spent on infrastructure.
The numbers keep coming in and they always tell the same story.
Let's hear it from Tom.
Tom: I think it was, I don't remember the exact numbers, but like, I think
it was like probably 40 x or something.
The difference between like the amount of Python runners that we ha needed
to run compared to the rust ones.
And the thing about that is that it actually compounds.
So if you go from, let's even go for the basic, uh, case of just like two
rust runners and like 80 Python ones.
All of a sudden, like the two runners, they hit.
In memory cache like all the time because there's just two of them, right?
So let's say 50% of the time, but probably more than 50% because like the moment
they flip it gets to the other one.
That one now has it cached.
So like in-memory caching is actually extremely effective.
Matthias: If you've ever worked with a larger c plus plus code base,
you know how hard it is to refactor the spooky action at a distance.
The fear of breaking something, the lack of confidence that you actually did it,
rust changes that if it compiles, it runs.
And that gives you a level of confidence that you just don't get with C or c plus.
Plus,
in rust.
You can refactor with ease knowing that the compiler will catch your mistakes.
Here's V Guard.
Vegard: Youngs ago, I was a c and c plus plus developer, and I did a
bit of that and bit of that and just trying to refactor a c plus plus
code base and having confidence that you've actually done it correctly.
I have never had that, but trust like the, it's, if it compiles, it works.
It basically is that.
Matthias: I believe rust is a language for decades.
A language which allows us to build software that lasts software that
doesn't need constant handholding and doesn't go belly up when we stop looking
. Again, I fully agree with Viot here when he shares his experience
with a critical service at Ksat,
Vegard: I have a good example of that because.
A couple of months back, we needed to do some changes in a few of our
services running, and I went into the repository for that service to actually
fix it, and I saw the last commit was one and a half year ago, and it's just
been running one and a half years.
I haven't touched it and I have never had that experience in my professional career.
That service was the main.
Authentication authorization service that authenticated and managed
every API key, uh, principle.
So it'll used on every request.
It's really chugging along, so it's, it's amazing.
Matthias: 10 years of rust.
It's surreal how much we have accomplished in such a short time.
Well short for a new programming language, at least
rust has come a long way.
The community is strong.
The ecosystem's growing, and the language is maturing.
It's exciting to see where Rust will go in the next 10 years.
I think there's still a lot of work to do around using rust to its full potential.
Now that we have a stable language and a solid ecosystem, we can focus on design
patterns and best practices . For example, how do you structure code and how do you
work with very large rust code bases?
Here's Andrew again,
Andrew: So we are, I think I just looked the other day and we were at
like five or 600,000 lines of rust in the core across like 600 ish crates.
I think we're just shy of 600 crates, internal plus dependencies.
So it's, it's a pretty big code base.
Right.
And like I said, that that core makes up as much of the business
logic as we can get it to.
What we found teaching people is the issue is not learning the rust syntax.
It tends to be that rust, good rust requires a bit of engineering knowledge,
and that's not maybe engineering knowledge that the book is covered.
Right.
And you and I talked about this a little bit, right?
Like, how do I know when I make a new crate?
Well, the Rust book doesn't, I mean, it's not gonna tell you that that's
not really a rust problem, right?
That's a, your code based problem.
It's an engineering problem.
Matthias: Here's Victora from Microsoft.
Victor: We have hard data that shows that components that have been rewritten
are much solid, much more solid, and we can actually even formally prove some
of them that to be memory safe, both in terms of spatial and temporal safety.
So it's the no bullshit about it.
It's literally what we're calling it inside, at least on my team.
Who's responsible to drive.
This is 2025 is the year of Microsoft, uh, the year of Frost at Microsoft.
So literally, this is what we're calling it.
Matthias: I want to end this season with words from Nico that capture
both what makes Rust special and what makes the community great.
Niko: So the fact that Rust has versatile enough, versatile enough
to be optimized for those sort of foundational low level applications and
yet be usable all the way up is pretty important and a little surprising.
I think a cool, a cool outcome.
Matthias: And finally, his message to all of us.
Niko: Yeah, be excellent to each other.
I think Bill and Ted put it best and I can't do better than that.
Matthias: I want to thank all the guests who took the time to
share their experiences with Rust
I learned a lot from each of you, and I hope our listeners did too.
And I also want to thank you, the listener for tuning in and supporting the podcast.
Your feedback and encouragement is what keeps us going.
We don't say this often, but if you enjoyed this season, please
consider leaving a review on your favorite podcast platform.
It really helps us reach more people and share our passion for us.
And perhaps you have a colleague or a friend who might be interested in this
podcast, maybe you can send them your favorite episode and help spread the word.
And finally, a heartfelt thanks to Simon who tirelessly works in the background
and is the only reason why you can even enjoy listening to this podcast.
And with that, thanks for listening to Rust in Production.
Rust In Production is a podcast by Corrode.
It is hosted by me.
Mattias Andler, and produced by Simon Bruen.
For show notes, transcripts, and to learn more about how we can help your company,
make the most of Rust visit corrode Dev.