Rust Testing Challenges & Community Growth

Join hosts Joanna and Arthur in this insightful episode of Testing 1-2-3 as they dive into the evolving world of Rust programming, testing best practices, and the vibrant Rust community. Recorded live from The Brewery in London during a major tech conference, Arthur shares firsthand observations from the event, including keynote attendance, session highlights, and the growing momentum behind Rust’s adoption.

Key Discussion Points:

• Rust’s Testing Landscape: Explore the unique challenges of ensuring quality, safety, and security in Rust code. Learn why the language’s reliance on external libraries demands scrutiny and how open-source tools like code scorecards evaluate project health through code reviews, static analysis, and unit testing.
• Tooling Gaps & Opportunities: Discover why Rust’s ecosystem currently leans on open-source solutions for static analysis and coverage, and why commercial tooling is critical for scalability. Arthur breaks down the hurdles of measuring code coverage via LLVM and the community’s push for robust, enterprise-ready solutions.
• Static Analysis Beyond Bug Hunting: Unpack how Rust developers view static analysis not just as a bug detector but as a way to enforce context-specific coding standards—a paradigm shift for safer, more reliable software.
• Community Momentum: With 400+ attendees and growing interest in cybersecurity sessions, hear how Rust’s community is expanding and what this means for developers prioritizing safety-critical systems.

Featured Insights:

• Why writing custom static analysis checkers is possible but not practical for most teams.
• The role of unit testing and coverage metrics in Rust’s maturation.
• Arthur’s take on the future of commercial tooling and collaborative quality practices.

Subscribe to the Testing 1-2-3 Podcast for deep dives into software development, testing strategies, and expert interviews. 

Listen now to stay ahead in the fast-paced world of software quality! 🎧

Keywords: Rust programming, Rust testing, code quality, static analysis, unit testing, code coverage, cybersecurity, open-source tools, Rust community, software security, Embedded World, Parasoft, LLVM, software development best practices.

Transcript

Joanna: Okay. Did you get the record message? 

Arthur: Yeah. I think I clicked okay. 

Joanna: Okay. And I see it recording. 

Arthur: Okay good. 

Joanna: All right. So long pause. 

Arthur: Now we got somebody in front of the sign. 

Joanna: It's because he wants... 

Arthur: That's how it works. 

Joanna: That's how it works. All right. Hey, Arthur. We're back.... Oh, we are...pause again. 

Arthur: Okay. 

Joanna: Hey, Arthur. You're back, and it's daylight now in London. How's the show going? 

Arthur: Yeah. Hey. Yeah. It's day for me and night for you this time, so we've swapped positions. 

Joanna: Yeah. 

Arthur: The show's pretty interesting. It's at this location called The Brewery. And, automatically, I like The Brewery because they use a bowler hat. So now I wish I had brought my bowler with me... 

Joanna: I love the bowler hat. 

Arthur: Even though it's an international... 

Joanna: That's a pretty awesome sign. 

Arthur: Yeah. Yeah. So it's a very happy thing. And, I'm not doing a body count of how many people are here, but I did a rough estimate of the size of the keynote. Oh, it's roughly 500 chairs. It wasn't full, but, like, I would say 400 plus people here. And the session I just left a few minutes ago, there was maybe 75 people sitting in there for cybersecurity, and, you know, that's a wonky topic. So yeah, there's a bunch of people. There's four tracks running simultaneously so people can kinda move from room to room. 

Joanna: Cool. So that's pretty heavily trafficked, and I think I saw a number from last year where they were 400, you know, low. So if you're reaching 400 high, it's the community is slowly but surely growing. So as you've been sitting into sessions, have you seen or heard...what have you heard and seen about, the Rust community and their approach to testing? And because we had talked about, safety critical yesterday evening. So, I mean, what's the corollary for how to manage, you know, testing and quality into people's Rust code? 

Arthur: Yeah. It's a unique challenge because the Rust language doesn't provide a lot of things in a standard library, and so people include lots of things from other places. And if you care about quality, safety, security, reliability, you kind of should care a little bit about what you're putting in your application. And so there's various things people do. There's an open source project that produces an open source scorecard, and you probably can take that with a grain of salt. I wouldn't simply look at the score and say yes or no. But it's certainly people are thinking about not just what's the quality of my code, but what's the quality of the things that are really included in my application. And it comes down to the scorecard does a normal set of best practices. Right? Like, is the code being reviewed? Are code changes being reviewed before they're merged into the code base? Are people doing fuzzy? Are people doing static analysis? Are people doing unit testing? What's the coverage for the project? And so it's pretty interesting. There's a blend of tooling right now for Rust. It's much more at the moment on the open source side than it is commercial tooling. There's certainly need for commercial tooling. Like, code coverage right now is it's tricky to measure and has to be measured using LLVM, meaning that there are implications for the coverage, but there will be commercial tools. There's some open source static analyzers, but, again, they do a limited amount of things. And some of them are kind of roll your own static analysis. So there's an engine, and in there, you describe like, when you're creating a unit test, you describe what pattern or anti pattern you're searching for in the code, and then you go off and run it. But it's not like what we're used to in the commercial static analysis world where there's a bunch of checkers ready to go, and maybe some of them are parameterizable because they're unique to my circumstance. Like, how does this thing, you know, access memory or how does it handle input validation or things like that that you can tweak? But yes, I know people do write some of their own checkers. Most of the time, they're writing a checker that already exists in another tool. Like, we should be past the point that people are writing checkers mostly because while anybody can write a static analysis checker, it's not easy to write a good one that doesn't produce lots of false positives. So we're at that point in the community now. A lot of people do recognize the value of static analysis, and I'm encouraged by the fact that they recognize that static analysis is not just a bug finder... 

Joanna: Right. 

Arthur: ...but has a role as enforcing proper behaviors based on the context that the application is in. And that's a very positive movement for a language to have that kind of a thing. But, yeah, the tooling needs to come along to make these people's lives better. Not everybody should have to knit together their own tool set, and people should be able to know that the results are somehow analogous if someone's using a different toolset to know what the quality is. So people definitely interested in unit testing. People are definitely somewhat interested in static given the fact that there are multiple options for it. Coverage looks like it's more of a nascent thing at the moment. And, again, it's starting to be provided somewhat by the kernel, not the coverage itself, but the core Rust C compiler is now allowing coverage to be gathered. And that's a...it's a sort of thing that you don't think about in other languages. Right? Like, you just take it for granted that we can measure what we tested. So it's a very interesting time to be, you know, dabbling in Rust. 

Joanna: Yeah. And to be on the, you know, the feet on the street and watching the ground floor sort of approach to, you know, the idea, the project, and now the momentum. So that's pretty... So, well, I think that wraps up this episode for the two of us. I know you have two more days of exciting...or a day and a half more of exciting content. But for our podcast, I think we're gonna say goodbye to you while you're completing your adventures in London. So, thanks, Arthur, for spending the time with us this afternoon. And, we'll probably have another episode for those of you who are interested in talking a little bit more about what Rust is and what it means to our developers and, more of a deep dive around some of these other questions that I'm sure you might have for Arthur. So if you have questions for us on Rust and then in the future and how we should approach it, send in your questions, and Arthur and I will gladly have a conversation about that. So I'm gonna say goodbye to Arthur. And, Arthur. 

Arthur: Yeah. Thank you. Thanks everybody for joining us, and I hope you join us again. And, I'll be at Embedded World in Nuremberg, Germany in a couple of weeks. So, you know, if you're in Germany, stop by the booth and say hi, and, look forward to our broadcast from that event as well. And if you have questions that you want us to cover, again, please send them to us, put them in social media, send us an email. Whatever it is, you can reach us. 

Joanna: Yep. Well, Arthur, we're signing off and safe travels home. 

Arthur: All right. Thanks. Bye bye. 

Joanna: Bye now.