Summary
Disclaimer: This summary has been generated by AI. It is experimental, and feedback is welcomed. Please reach out to info@qconsf.com with any comments or concerns.
The presentation "Rust at the Core - Accelerating Polyglot SDK Development," delivered by Spencer Judge, focused on utilizing Rust to develop SDKs across multiple languages efficiently. Spencer shared insights from his experience at Temporal, where Rust serves as a core component in a polyglot SDK development architecture.
Key Points Covered
- Shared Core Architecture: Discussed the importance of having a shared core written in Rust, which supports multiple language layers built on top, thus reducing redundancy and improving consistency.
- Language Bridges: The session explained the use of Rust to create language-specific bridge layers that facilitate communication between the shared core and the SDK in various host languages.
- IDEs and Serialization: Spencer highlighted the significance of Interface Definition Languages (IDLs) and serialization for representation of shared objects across different languages.
- Asynchronous Operation Representation: Explored the challenges and solutions of representing asynchronous tasks across language boundaries.
- WebAssembly: Considered the possibilities of using WebAssembly to avoid native extension issues, providing greater portability.
- Rust's Advantages: Emphasized Rust’s safety, expressiveness, and the support from a growing community, making it a suitable candidate for this architecture.
- Limitations and Pitfalls: Addressed some challenges such as debugging across language boundaries and the need for more mature support in some languages.
Conclusion
The speaker concluded by affirming that adopting a Rust-based core for SDK development resulted in significant time savings and reduced bugs due to fewer redundancies. Participants were encouraged to consider Rust and helper libraries for developing multi-language SDKs, focusing on creating idiomatic and efficient user experiences.
This is the end of the AI-generated content.
Abstract
Developing SDKs for your users in multiple languages can come at a high cost - especially if you need to implement complex logic client side, but traditionally options for sharing logic across those languages have been quite limited.
Rust provides a means of defining shared logic usable from multiple languages, much like you could with C, without having to… write C. Combined with an IDL for representation of shared objects, you have a powerful means to keep your language-specific layer thin.
In this presentation I’ll explain the architecture of Temporal’s open source SDKs, and how we use it to centralize some extremely complex logic across 5 user-facing SDKs written in different languages.
Topics will include:
- What Rust helps us with
- IDL choices and serialization concerns
- Asynchronous task representations across language boundaries
- Compiling to WebAssembly to avoid native extension issues
- Staying idiomatic in the host language
- Limitations and pitfalls
Interview:
What is your session about, and why is it important for senior software developers?
My session is about how devs who need to work in multiple languages can leverage Rust as a safe, modern, foundation for shared logic. Thereby keeping their language-specific layers thinner. This is by no means a new technique, but Rust provides a much safer and more convenient alternative to C.
Why is it critical for software leaders to focus on this topic right now, as we head into 2026?
The language landscape slowly, but inexorably, continues to expand. Developers expect to be met where they are, in their language of choice. The techniques in my talk allow library developers to more efficiently expand their coverage to additional languages than they could otherwise. Additionally, relatively recent technologies like WebAssembly unlock new and powerful alternatives to shipping native code, and Rust is at the forefront of that ecosystem.
What are the common challenges developers and architects face in this area?
Communicating between the native code and the language layer is nontrivial, especially when many languages are involved. Supporting a large matrix of operating systems and architectures can be a challenge, as can packaging and shipping the native extensions (for related reasons). I'll cover some techniques for solving these problems.
What's one thing you hope attendees will implement immediately after your talk?
Immediately is a hard goal - but hopefully attendees will come away with some ideas for how they can either refactor an existing multi-language project to reduce its complexity, or a battle plan for any new project with such needs. They may also decide to familiarize themselves with Rust if they aren't already, which can be useful not only for the scenarios my talk covers, but possible usages of Rust beyond that.
What makes QCon stand out as a conference for senior software professionals?
QCon's long history stands out to me. It has a reliable reputation for delivering quality content, and avoids being overly marketing-heavy or trend-chasing. It appeals to senior engineers who are in search of genuinely deep technical content.
Speaker
Spencer Judge
Engineering Manager @Temporal Technologies, previously Senior Software Engineer @Transparent Systems, Senior Software Engineer @ Tableau Software
Spencer has worked on tools, libraries, and products for other Developers for over a decade. He has a longstanding interest in, and passion for, learning and developing in multiple languages.
Currently he leads the SDK team at Temporal, which develops libraries providing durable execution in 8 languages.
Spencer lives in Seattle and enjoys spending his free time on endurance sports and rock climbing.
Find Spencer Judge at:
Date
Monday Nov 17 / 03:55PM PST ( 50 minutes )
Location
Seacliff ABC
