Matthias: This is Rust in Production, a podcast about companies who use Rust to shape
Matthias: the future of infrastructure.
Matthias: My name is Matthias Endler from corrode, and today I'm excited to reflect on
Matthias: the insights from the first season paving the way for the next chapter of the show.
Matthias: When I started using Rust in 2015, there was no stable compiler or ecosystem.
Matthias: It was before Rust 1.0 and most people used nightly Rust for their projects.
Matthias: Things would break regularly. There was no question mark operator,
Matthias: no incremental compilation and no async await.
Matthias: Fast forward to 2018 when I started to create video content on my YouTube channel called Hello Rust.
Matthias: I wanted to share my excitement for Rust and help others learn it.
Matthias: The ecosystem system had matured a lot since 2015 making it a great time to
Matthias: start exploring the language.
Matthias: During that period an increasing number of companies began to use Rust in production.
Matthias: We were inspired by the success stories of companies like Dropbox,
Matthias: Cloudflare and Mozilla using Rust for critical parts of their infrastructure.
Matthias: I always found these stories exciting. I was curious to hear about the challenges
Matthias: that companies were solving with Rust.
Matthias: However, this knowledge was hard to come by. Unless you attended conferences
Matthias: or stumbled upon the occasional blog post, learning about companies deploying
Matthias: Rust in production was difficult, and to this day some of these stories remain untold.
Matthias: Later, as a Rust consultant, I had the privilege of speaking with many great
Matthias: companies about their real motivations for choosing Rust.
Matthias: These benefits go far beyond the usual Rust is fast and safe narrative.
Matthias: While there is a lot of great content about Rust these days,
Matthias: I had been waiting for someone to launch a format specifically focusing on Rust
Matthias: in production, because I felt that these stories needed to be told.
Matthias: Eventually, I decided to take the initiative and create the podcast myself.
Matthias: This episode concludes the first season of Rust in Production.
Matthias: In it, I reflect on the season and share insights gained from the interviews.
Matthias: I'll also discuss my plans for season 2 and the road ahead.
Matthias: Chapter 1. Why Rust? Throughout the interviews, a recurring theme emerged.
Matthias: As companies scale, the complexity of their systems increases.
Matthias: This complexity leads to need for ways to make systems more reliable and easier to maintain.
Matthias: This is especially true in today's world of microservices and parallel computing,
Matthias: where systems are more distributed and complex than ever.
Matthias: Robustness and reliability are key concerns for companies.
Matthias: For example, here's what InfluxData's CTO Paul Dix had to say about why they chose Rust.
Paul: Yeah, so I mentioned this before, I think like the fearless concurrency, right?
Paul: Having, you know, eliminating data races, essentially, which we had before,
Paul: like these really gnarly bugs in version one of Influx due to stuff like that,
Paul: which we just wouldn't have in Rust.
Matthias: This confidence in Rust's ability to make concurrency safe and frictionless
Matthias: is shared by many companies.
Matthias: Rust's type system and ownership model make it easier to reason about concurrency
Matthias: and write code that is both secure and reliable.
Matthias: Folkert de Vries from Tweede Golf shared a similar sentiment.
Folkert: I also think in Rust, it'll be really clear when you need a mutex, right?
Folkert: Whereas I I think in C, it might be much harder to know like,
Folkert: okay, I'm using this value over here, but is some other thread also touching
Folkert: this right now? Like you sort of have no idea.
Folkert: Whereas in Rust, a type checker will tell you, right? Like, oh,
Folkert: you're using this. Or, well, first of all, you have an immutable reference,
Folkert: so you can't mutate that thing.
Folkert: Ever. If you have a mutable reference, then you know it isn't shared between
Folkert: multiple threads, and if you do want something that is both shared and mutable
Folkert: right now, you need to wrap it in a mutex.
Matthias: As software gets more complex, companies are concerned about the maintainability of their codebases.
Matthias: For instance, PubNub CTO Stephen Blum mentioned that maintainability was a key
Matthias: reason for choosing using Rust, when they migrated some of their services from C.
Matthias: In their case, their C code was stable, but they were scared to touch it because
Matthias: of the fear of breaking existing functionality.
Stephen: And that was not great either, right? So we've got this thing that's over here, we want to read.
Stephen: And we actually the question you would ask is like, why would we choose to attempt
Stephen: to rewrite something that we have that's robust and C and it's stable,
Stephen: rewrite it in Go and the answer is maintainability because we're scared
Stephen: to touch it it's working right now and if we make any adjustments you know that's the danger zone.
Matthias: Another aspect of Rust that companies appreciate is its strong stability guarantees,
Matthias: Rust helps companies avoid making mistakes and catch bugs early, This is especially
Matthias: important for companies that are dealing with a lot of traffic where outages
Matthias: can be very costly here is Apollo's Nicolas Moutschen.
Nicolas: Most of outages come from application-level changes. Right. Not necessarily the underlying infrastructure.
Nicolas: So changes are risky, and having, making sure, having, asking people to trust us,
Nicolas: with all that traffic being the API, you know, the front-end API that's going
Nicolas: to ingest all the traffic and then route it to their microservices is a huge responsibility.
Nicolas: Safety and reliability is extremely important for us for that reason.
Nicolas: To create a cloud router for a customer, we need to provision a bunch of different resources.
Nicolas: And we need to avoid creating the same thing twice. We need to keep track of where everything is.
Nicolas: And so when we are making changes on our own code base, we are making all these
Nicolas: changes there. We need to make sure that we are not accidentally breaking things.
Nicolas: So we put a lot of emphasis on the write safety and making sure that the state
Nicolas: of our database is the state of what we know exists in terms of customer resources.
Nicolas: Was always correct. And so we've encapsulated a lot of write safety into the
Nicolas: struct and variants that we use in Rust.
Nicolas: So we actually get, by using the strong typing of Rust and the way we structure
Nicolas: that, we actually get a lot of safety guarantee from that perspective,
Nicolas: which is not something that Rust enforces, but Rust made us think about.
Matthias: Rust is renowned for its outstanding performance, But one often overlooked aspect
Matthias: of that is that better performance can lead to cost reductions.
Matthias: This is a great benefit for startups that are looking for better ways to achieve
Matthias: optimal resource utilization.
Matthias: Arroyo's CTO Micah Wylde shared this sentiment.
Micah: At a high level, a system like Arroyo doesn't really need a complex scheduler like Tokio.
Micah: As I mentioned, each of these operators essentially acts as a single thread.
Micah: It receives one event, it does all the processing for that event,
Micah: and then it sends it on to its next destination.
Micah: And all this has to happen in order to uphold the correctness guarantees of the system.
Micah: And because of that, the first version of Arroyo actually was built around threads and thread processing.
Micah: At some point, it migrated to Tokio and AsyncRust, actually pretty early on.
Micah: And the core reason for that was that so much of the ecosystem is in AsyncRust
Micah: at this point, that if you want to use common network libraries or database
Micah: drivers or almost anything from kind of network programming ecosystem, ecosystem,
Micah: you do have to deal with async at some point.
Micah: And at some point, it's easier just to move your whole system over to async.
Micah: And that was definitely a challenging migration. Actually, for me,
Micah: I had never worked with AsyncRust before.
Micah: So it involves a lot of learning, a lot of time on the Tokio Discord channel,
Micah: which is extremely helpful.
Micah: But in the end, actually, the surprise was that it ended up being a lot faster.
Micah: Just purely doing that migration made the system like 30% faster,
Micah: which was not my expectation at all.
Micah: But it turns out that the Tokio scheduler is really, really effective at this
Micah: class of problems, where even though it looks at a high level,
Micah: like all this processing is single-threaded,
Micah: there's a lot more going on under the hood, a lot more work that has to be coordinated.
Micah: Between like, you actually have threads, like in our case, like talking to S3
Micah: or talking to other systems.
Micah: We have a lot of queues involved.
Micah: So even though we have only a smallish number of actual processing threads,
Micah: there's a lot of network exchange happening on other threads, talking to...
Micah: Coordination system over gRPC. And Tokio is really good at, at,
Micah: you know, organizing all of this work efficiently and really maxing out the use of your core.
Micah: I think that the most surprising thing for us is that we're able to run the
Micah: system at extremely high utilization,
Micah: like above 95% CPU utilization,
Micah: and everything remains responsive and reactive and is able to,
Micah: to really work effectively at that extremely high level of CPU thrash,
Micah: which has never been my experience with the systems written in other paradigms.
Matthias: Startups can gain a competitive advantage by using Rust.
Matthias: But even for established companies, Rust's performance can unlock new possibilities
Matthias: for products that would be harder with other languages.
Matthias: Here is what Sentry's Arpad Borsos had to say about how Rust's performance
Matthias: is enabling them to think about services which need to scale to handle large amounts of traffic.
Arpad: And maybe I've hinted on this previously that Sentry is also working on a metrics product.
Arpad: And metrics especially wouldn't be possible without having Rust code in between
Arpad: to handle the amounts of traffic.
Arpad: And to give you some numbers as well, there's been a couple of initiatives internally
Arpad: to rewrite some parts of the whole pipeline.
Arpad: The whole pipeline is enormous.
Arpad: It has lots of moving parts. And there's tons of Python code still there.
Arpad: And we try to move little bits of this to Rust, things that are especially critical
Arpad: or things that are costing a lot in terms of cloud costs.
Arpad: And here, one team has rewritten one critical part of the infrastructure in
Arpad: Rust, and they have observed 10 to 20x improvement in throughput and eventually in cloud cost as well.
Arpad: Because you can then just scale down the number of horizontally scaled workers
Arpad: and the CPU and memory allocations they get, and that has got 10 to 20x improvement here.
Matthias: And what is the amount of traffic that this new service gets?
Arpad: Depending on the workloads, there is one specific use case where it has
Arpad: more than 100k Kafka messages in this case per second.
Matthias: And PupNub had a similar experience.
Stephen: All of our new services are typically elected to be written in Rust.
Stephen: Everything going forward will be Rust. This is due to our scale.
Stephen: And, you know, we've seen fantastic results from it.
Stephen: We actually have some real world numbers. as we have replaced some of our services
Stephen: with Rust. And it has been fantastic.
Matthias: Can you share some of these numbers? I would love to hear them.
Stephen: Yeah, yeah. Okay, so some of our services are written in Python.
Stephen: It has some performance considerations in general with Python.
Stephen: We have gotten past some of those using something called PyPy,
Stephen: which is more about memory routing and pathing, but at runtime.
Matthias: Yeah, like a just-in-time compiler for Python.
Stephen: Exactly, yeah. And there's a trade-off though because it takes
Stephen: up a lot more memory okay like a lot like
Stephen: it can go gigabytes per process but
Stephen: you know the CPU is you know five times faster
Stephen: which is in CPUs are expensive right you pay around four pennies per hour for
Stephen: CPU on Amazon for CPU and then memory is what it's like half that price right
Stephen: based on so it's like a good trade-off in terms of cost. When we replaced that service with Rust,
Stephen: we saw another 5x boost, not only in memory, but in performance as well, on top of it.
Matthias: That means you use one-fifth of the memory in Rust compared to PyPy.
Stephen: Well, actually, way less.
Stephen: It's more like 30 megabytes or something like that in Rust versus a gigabyte.
Matthias: Lastly, as yet another angle, Rust's performance can be seen as a feature,
Matthias: which translates to a better overall user experience.
Folkert: So I think you can ultimately distill this into value for users.
Folkert: A lot of this low-level stuff is really about user experience,
Folkert: if you want to think about it that way.
Folkert: Performance is ultimately user experience.
Folkert: And I think we don't really appreciate that enough, but there's a lot of research
Folkert: from Google about if a page load is this many milliseconds longer,
Folkert: then this percentage of people will just lose interest.
Folkert: This is very well established.
Folkert: In practice, a lot of software is really slow, and only people excited about
Folkert: this low-level stuff can fix that.
Folkert: And then imagine the sort of like value that that actually has,
Folkert: the sort of multiplier of this one person going really deep down into that rabbit
Folkert: hole, coming up with a more efficient implementation.
Folkert: But then all users of that tooling, and of course, that tooling,
Folkert: like its usage is spreading very quickly because 1000x improvement is ridiculous.
Folkert: You know, the sort of the amount of time saved, the amount of extra productivity
Folkert: gained is really something that is almost hard to even capture, right?
Folkert: So like that is ultimately the power of this low level stuff.
Folkert: Like, yes, it is very nerdy. Yes, it is very.
Folkert: It seems to be very distanced from sort of the real world sometimes, but it has real outputs.
Matthias: In conclusion, companies choose Rust not only for its performance,
Matthias: but also for the secondary benefits that come with it, such as improved hardware
Matthias: utilization, cost reductions and a better overall user experience.
Matthias: In combination with Rust's other advantages, such as safety,
Matthias: reliability and maintainability,
Matthias: these benefits make Rust a compelling choice for companies looking to build
Matthias: robust and reliable systems that scale to handle large amounts of requests.
Matthias: Chapter 2. Requirements for adopting Rust I wanted to hear first-hand from companies
Matthias: that have successfully adopted Rust in production about what they think are
Matthias: the requirements for considering Rust within a company.
Matthias: Which resources and expertise do you need to have in place to be successful with Rust?
Matthias: And what non-obvious challenges might you face when adopting the language?
Matthias: A recurring pattern I noticed is that engineers started learning Rust on their
Matthias: own and then brought it to their companies.
Matthias: They experimented with Rust for smaller projects and gained confidence with
Matthias: the language before using it for anything serious.
Matthias: Here's how Apollo's Nicolas Moutschen learned Rust.
Nicolas: In my case, I'm an experiential learner. I'll learn best by actually just doing
Nicolas: and writing code myself and doing experiments.
Nicolas: And the first thing I'd like to say on that, by the way, when you're starting
Nicolas: your Rust journey and you're starting to write code, it's okay.
Nicolas: I mentioned the tier one stuff where you do a lot of clone, where the broad
Nicolas: checker is still confusing, and sometimes you get a lot of compilation error
Nicolas: that you don't necessarily understand.
Nicolas: It's fine. It's totally fine to get there. By the way, even if you clone excessively
Nicolas: resources, you might still be way better in terms of performance as what you
Nicolas: would have if you're using JavaScript or Python.
Nicolas: I mean, coming from Python, Python does a lot of cloning of values under the
Nicolas: hood that you don't realize.
Nicolas: Rust just makes things explicit, right? So some people also learn better via
Nicolas: books, via tutorials and so on.
Nicolas: And there's so much great resources all over the board.
Nicolas: It's really hard for me to kind of point to one. In my case,
Nicolas: I use the official resources that you find on a Rust lang website.
Nicolas: So there is the Rust book. I think there's the Rust from Examples, I think it's called.
Nicolas: I don't really exactly remember now.
Matthias: Rust by Example, yeah.
Nicolas: Yeah, yeah, yeah.
Nicolas: These ones already helped me so much. And then I was just writing,
Nicolas: starting with CLIs, writing some libraries and so on.
Nicolas: I had a mentor, which when I started using Rust before at AWS and I had a mentor
Nicolas: there, it was very helpful.
Nicolas: We also have, because now we have a sizable number of Rust engineers,
Nicolas: We have a Rust Slack channel where everybody can ask questions,
Nicolas: but there's also the official Rust Discord.
Nicolas: People are very friendly in the Rust community, so don't hesitate to reach out
Nicolas: and ask questions to people. They will usually point you in the right direction.
Nicolas: Then as you're getting more experience, I would highly recommend the book Rust for Rustacean.
Nicolas: If you feel like you're getting more comfortable, you don't,
Nicolas: you know, you rarely get compiler error nowadays or something like this, right?
Nicolas: Go with the Rust for Rustacean. It's a great book to really level up your Rust knowledge. Yeah.
Nicolas: So that's kind of my, yeah, like six to 12-month recommendation journey,
Nicolas: if you're looking at learning Rust or where you might feel yourself to be in
Nicolas: terms of Rust experience.
Nicolas: But to be honest, like a lot of people on our team were able to make PRs in
Nicolas: Rust after a few weeks, right?
Nicolas: Back when I was at AWS, I was a solution architect. My job was to talk with
Nicolas: a lot of companies, and I had people reaching out to me saying, hey,
Nicolas: that company wants to start using Rust, but they're a bit afraid to be honest
Nicolas: they're a bit afraid of starting of not finding the talents and so on. Well that's
Nicolas: fine you can train people to to learn Rust and they can start to be productive,
Nicolas: in a few weeks.
Matthias: Or here's the story of Paul Dix.
Paul: Was just like you know what I haven't given this language a fair chance. I've
Paul: been kind of judgmental based on no actual knowledge so I'm going to like commit
Paul: to actually really trying to learn it.
Paul: And then in, I think it was in the fall of 2019, the async await stuff finally landed, right?
Paul: And obviously that stuff had been in the works for a while, but it landed in
Paul: a way that you could actually use it for real.
Paul: At least I thought. People who were in Rust probably had already been doing it for a while.
Paul: But fall of 2019 is when I remember saying like, oh, now that that's landed, Rust is going to become,
Paul: basically like maybe the language of first choice for building high performance
Paul: server side software, right? System software of all kinds.
Paul: And we had some big things we had to do with InfluxDB.
Paul: And I thought, well, maybe I should try writing this next, at least this core
Paul: of the database piece in Rust.
Matthias: Once you start to consider using Rust for critical parts of your system,
Matthias: consulting can help hit the ground running by speeding up the learning process
Matthias: and helping make the code more idiomatic.
Paul: So we ended up bringing in Integer32, which is a consulting company,
Paul: Jake and Carol, to help us out.
Paul: One with like code, writing code and doing code reviews and like helping us out there.
Paul: But we've also had them, they run like a
Paul: multi-day class training session and we've run
Paul: had them run people through that a few times. L
Paul: ike different groups of engineers within our company
Paul: through that so that I think that's really really helpful like what the experience I
Paul: didn't have in the first like six months I was personally writing Rust was
Paul: I had nobody I could ask really basic dumb questions to which I think would
Paul: have helped my learning process a lot more,
Paul: but we always do code reviews, right?
Paul: So pull requests with code reviews to change stuff.
Paul: And we brought Carol and Jake in pretty early to do that specifically because,
Paul: I knew that we didn't have the expertise in-house, and I was like,
Paul: I want to make sure that what we're creating isn't a complete mess.
Matthias: Chapter 3. Integration with existing codebases. No project exists in a vacuum.
Matthias: Companies typically run a mix of different languages and technologies.
Matthias: Fortunately, Rust can be brought in for performance-critical parts of the system
Matthias: by keeping the rest of the codebase untouched, which allows for gradual migration.
Matthias: This is made possible by Rust's excellent support for interoperability with
Matthias: other languages, either through FFI or other mechanisms like WebAssembly.
Matthias: For example, Arpad from Sentry mentioned that Python integration was pretty straightforward.
Arpad: Just recently, one of the things I did specifically was to pioneer PyO3.
Arpad: So we created a new Python package written using PyO3 and Maturin.
Arpad: And I'm actually really, really satisfied with how this turned out to look eventually.
Arpad: There were some really arcane ways of how to write Python extension modules
Arpad: previously where you had to use bindgen to generate C headers and then from there use,
Arpad: I don't know what the Python module is that actually consumes C headers and
Arpad: CFFI bindings and then just have tons more Python glue code on top of it.
Arpad: And PyO3 just does all of this for you.
Arpad: And that's really liberating. And I believe doing this one project now and actually
Arpad: these last couple of weeks, we've demonstrated that this actually works and
Arpad: it works really well and it's productive.
Arpad: And you can use this to write even more code in Rust that's been used from Python directly.
Matthias: You don't have to rewrite everything in Rust to benefit from it.
Matthias: Chapter 4. Hiring Rust Engineers. Going in, one major concern of companies is
Matthias: that it might be hard to find Rust developers.
Matthias: In fact, the interviewees have found that hiring Rust developers is relatively
Matthias: easy, because many developers are excited to use Rust for work.
Paul: I announced that we're working on this new core of the database in November of 2020 in a talk I did.
Paul: And I said we were hiring and basically like we got a bunch of inbound interest
Paul: because of the fact that it was written in Rust.
Matthias: Arroyo had a similar experience.
Micah: Because as a small company, you can attract people because they want to work in Rust.
Micah: And that's a big incentive to work for you.
Micah: And I think that's working in like maybe a slightly obscure language.
Micah: You get those people who are really excited about it. And that can be a big
Micah: boon to you. But for big companies,
Micah: they kind of just see the risk side of that equation.
Matthias: Micah Wylde touches on a critical point here. The size of the company matters.
Matthias: For smaller companies, using Rust can be a competitive advantage as it can attract
Matthias: better talent who might otherwise go to larger companies.
Matthias: For larger companies, though, the risk of not finding enough talent could be a concern.
Micah: And if you're Google and you need to hire 10,000 engineers, I think you should
Micah: be rightly concerned about hiring 10,000 Rust engineers.
Micah: I doubt there are that many Rust engineers in the world.
Micah: But for a smaller company, that's not an issue at all, right?
Micah: Hiring three Rust engineers is pretty easy.
Micah: And I think especially for a small company, it's an advantage in a way that
Micah: it maybe isn't for a big company to be using Rust.
Matthias: That also means that bigger companies might have to invest more in training
Matthias: their own engineers and have a long-term mindset for investing in Rust.
Matthias: Chapter five. On Rust's complexity
Matthias: and learning curve. One aspect developers must
Matthias: adapt to when learning Rust is its approach to complexity. R
Matthias: ust doesn't conceal complexity, rather it makes it explicit, compelling you to
Matthias: confront it directly. This explicitness in handling complexity can be both unfamiliar
Matthias: and challenging but at least for me this transparency was the very reason for learning Rust,
Matthias: to gain a deeper understanding of lower-level concepts and have more control over hardware.
Matthias: However, this means Rust might present a steeper learning curve compared to other languages.
Matthias: There is another side to this coin though. By making complexity explicit,
Matthias: Rust not only demystifies the inner workings below the surface but also enriches
Matthias: your understanding of programming fundamentals without obscuring important details.
Matthias: Here's Folkert De Vries' perspective on the matter.
Folkert: I think with regards to how things work, I think it's also something that is
Folkert: sort of valued in the Rust community, that this sort of low-level detail is sort of appreciated.
Folkert: Like in a lot of other languages, people will say, oh, don't worry about that.
Folkert: The runtime will take care of it. Perhaps even the compiler will take care of it.
Folkert: But of course, in Rust, we know if you actually build the compiler or are quite
Folkert: close to it, you will know exactly what limitations it has.
Folkert: And also, you will know how fun it is to actually put a bunch of bytes in the
Folkert: right order and have that constitute a program, right?
Folkert: The sort of like hacking around with and really playing with computers,
Folkert: really commanding the machine, I think is something that you can certainly find in the Rust community.
Folkert: ou know, a couple of other communities as well at this point,
Folkert: like, it's something you don't see all that often.
Folkert: But that excitement about really commanding your hardware is that is really cool.
Matthias: One often neglected advantage of Rust is that you can start to learn about systems
Matthias: programming concepts by reading the standard library and the source code of popular crates.
Folkert: And in Rust, you can actually just go to source and like it's right there.
Folkert: It's a it's a bunch of like more primitive values and
Folkert: you actually can understand how it works like
Folkert: most other languages don't have this like even in C
Folkert: or C++ if you go to the source code of like the libc or the standard
Folkert: library it is incredibly arcane it looks very different from sort of standard
Folkert: C source code in in my view anyway as not a very experienced C programmer.
Folkert: Like that stuff just looks really weird.
Folkert: And in Rust, you can just find something, find an implementation that makes sense.
Matthias: This ability to understand the
Matthias: implementation of the language and its libraries can be very empowering.
Matthias: It can help you understand how things work under the hood and to make better
Matthias: decisions when writing your own code.
Matthias: However, it's crucial to keep an eye on the complexity that Rust can introduce.
Matthias: Especially in a team setting, understanding the learning curve for newcomers
Matthias: and steering clear of making things more complicated than they need to be is key.
Stephen: Rust comes with all sorts of fancy bells and whistles, doesn't it?
Stephen: What are these generics and traits and all these fun things?
Stephen: And it's really easy to be attracted to those because they look appealing.
Stephen: And they do bring some benefits. They add a huge amount of overhead
Stephen: for bringing new people into the team.
Stephen: And as we're training on the job, that level of complexity just adds a huge barrier to entry.
Stephen: And Rust is massive for that. That's probably the biggest downside.
Stephen: Can I have like an easy Rust?
Stephen: I want like a simple Rust. That's what I want.
Matthias: On a related note, I was surprised to learn that AsyncRust isn't as hard to
Matthias: use as it seems, particularly for end users who just utilize these abstractions,
Matthias: the complexity of AsyncRust appears to be overstated.
Nicolas: So on that end, the AsyncRust part simplifies a lot of things.
Nicolas: I will actually go back a step and talk about what I've seen in terms of Rust
Nicolas: developer experience, and that will be quite important for this, I promise.
Nicolas: So what I've found, if you look at a lot of Rust developers' journey,
Nicolas: there's kind of three main phases.
Nicolas: There's the first phase where you're starting out, you're still a bit
Nicolas: confused by the borrow checker and other things from the compiler,
Nicolas: and you clone a lot of things and so on.
Nicolas: Then there's a point when you start to be comfortable with a lot of these systems
Nicolas: and so on, and you might start using AsyncRust and you're able to be quite productive.
Nicolas: And then there's a third phase when you start to have mastery over some of the
Nicolas: more intricate systems, like in-depth knowledge of how Tokio works,
Nicolas: for example, and how some of the more more complex async stuff work.
Nicolas: And so if you're in the second category, if you are people that are able to
Nicolas: be proficient in Rust, but you don't necessarily know all the details of the
Nicolas: libraries and so on, AsyncRust is already a great tool there,
Nicolas: because you're just able to make something that works, it's going to be highly
Nicolas: optimized, it's going to be able to handle a lot of traffic without you having
Nicolas: to put much thought into making it work nicely.
Nicolas: Even in the first category, even if you clone a lot of data,
Nicolas: You know, it's still working great.
Nicolas: There's so many great libraries nowadays that are just available, have a great API.
Nicolas: So you can get started in AsyncRust and just already just by using AsyncRust,
Nicolas: you need to have systems that are going to be very performant when you think
Nicolas: about like microservices that need to handle potentially thousands of RPS of
Nicolas: traffic or something like this.
Nicolas: But then when you get to do the third tier and you start to dive really deep into AsyncRust,
Nicolas: then you can start to do some pretty clever optimizations,
Nicolas: some pretty clever thinking in terms of how to optimize your asynchronous communication,
Nicolas: to avoid cross-system race conditions, distributed race conditions,
Nicolas: to make sure that you actually fetch multiple data systems, multiple pieces
Nicolas: of data at the same time, and so on, all in one go.
Nicolas: So there's kind of this journey of growth into the kind of Rust async ecosystem,
Nicolas: where you already get a lot of benefit just being able to make async calls and
Nicolas: having libraries like axum and so on to just write a server that's already going
Nicolas: to be able to handle a lot of traffic without you having to think too hard about it.
Matthias: Chapter 6. A Broader Look at Rust's Adoption. A common concern I frequently encounter
Matthias: is the belief that Rust isn't widely adopted in the tech industry.
Matthias: Yet, based on my conversations with numerous companies, it's evident that this
Matthias: perception is outdated.
Matthias: Rust is actively being used in production across a broad spectrum of industries,
Matthias: including databases, cloud infrastructure, IoT, web services,
Matthias: security, and finance, to address real-world challenges.
Matthias: What's also remarkable is the convergence on certain patterns and libraries among these companies.
Matthias: Many have embraced AsyncRust alongside libraries like Tokio, axum, SQLx and others.
Matthias: This consensus indicates Rust maturity as a language, offering a robust suite
Matthias: of libraries and patterns that effectively tackle issues across various sectors.
Matthias: The reason behind the misconception of Rust's limited use might be the lack
Matthias: of public discourse about its adoption.
Matthias: While Rust continues to advance in the tech industry, not all companies are
Matthias: vocal about the use of the language, contributing to a skewed perception of its usage.
Matthias: They say produce the content you want to consume, and that's what I tried to do with this podcast.
Matthias: Inspired by The New Rustacean and On the Metal, I wanted to contribute my tiny
Matthias: part to make Rust more visible and advocate for its use in the tech industry.
Matthias: It took me by surprise to see how much positive feedback I got from the listeners.
Matthias: Seems that many people are curious about Rust in production and are looking
Matthias: for more information about it.
Matthias: With regard to the companies I reached out to, many agreed to talk about their use of Rust.
Matthias: It leads me to believe that there are many more success stories out there that are yet to be told.
Matthias: However, I don't want to paint a too rosy picture. Getting companies to commit to an interview is hard.
Matthias: It's difficult to get the approval from the right people and to schedule interviews,
Matthias: because people are generally busy and have long lead times.
Matthias: That's why I'm grateful for the guests who have been on the show and took the
Matthias: time out of their busy schedules to share their experiences with Rust.
Matthias: On that note, it's important to handle the trust of guests who do agree to an interview with care.
Matthias: I want to make sure that every episode is a good representation of the guest's
Matthias: experience with Rust, and that it is presented in a professional way.
Matthias: This is why I'm grateful for the work of Simon Brüggen, who has been editing
Matthias: the show from the beginning to make it sound great. Thank you for all your effort, Simon!
Matthias: One tradition of the show is to ask our guests what message they would like
Matthias: to send to the Rust community.
Matthias: As we conclude this season, I'd like to share my own message with the Rust community,
Matthias: highlighting a few items on my wishlist for Rust.
Matthias: Firstly, I'm eager to see an expansion of learning resources covering intermediate Rust topics.
Matthias: While it's relatively straightforward to get started with Rust,
Matthias: there's a noticeable gap in materials for those looking to advance beyond
Matthias: the basics and deepen their understanding of the language.
Matthias: Secondly, while Rust's tooling is exemplary in many respects,
Matthias: I believe there is room for improvement, especially in features that would benefit
Matthias: companies in a production environment.
Matthias: For instance, enhanced support for private crate registries would be highly beneficial.
Matthias: Thirdly, and perhaps most importantly, I'd like to encourage more companies
Matthias: to share their experiences with Rust publicly.
Matthias: Doing so not only increases Rust's visibility, but also draws more people to the language.
Matthias: It fosters stronger connections between companies and the community,
Matthias: thereby enriching the ecosystem.
Matthias: If you're using Rust in production, or know someone who would be an excellent
Matthias: guest for the show, I'd be curious to hear from you.
Matthias: With that, I hope you enjoyed the first season of Rust in production.
Matthias: We'll return for season two in eight weeks, and we we already have some fantastic guests lined up.
Matthias: Now is the perfect opportunity to catch up on any episodes you might have missed
Matthias: and to subscribe to the show so you don't miss out on future episodes.
Matthias: If you'd like to support Rust in Production, consider leaving a review on Apple
Matthias: Podcasts or Spotify. It really helps spread the word about the show.
Matthias: I'm also keen to hear from you directly. Feel free to reach out on Mastodon or via email.
Matthias: For more content on Rust in Production visit our website at corrode.dev to all
Matthias: the amazing guests who have shared their insights on our show and every listener
Matthias: for tuning in. Your continued support is the driving force behind the show. Thank
Matthias: you for listening to Rust in Production!