Building a Culture of Safe and Performant Systems with the Rust Programming Language
This talk focuses on how the Rust language has approached the design and implementation of safe and performant systems through two major focuses: building tools that enforce strong, fundamental guarantees; while also ensuring that the human aspect of systems design is fulfilled through robust teaching material for developers of all backgrounds, error messages that serve as a system of teaching rather than a system of reprimand, and guiding developers towards robust engineering practices by making reliable design choices straightforward (and making shortcuts ‘noisy’).
Although the systems that are being built today are becoming more complex, from timing critical embedded systems to massively distributed cloud applications, systems are often constrained by how straightforward they are to understand by the engineers and scientists building them. Rust has succeeded by developing a language that focuses on consistent, understandable, and composable abstractions, that allow for reasoning about systems both at a macro and a micro level. While this benefits the humans building these systems, it also allows for powerful opportunities for static analysis and compile time optimizations.
Rust has also set the standard for what it means to support the humans that are developing these systems. This approach starts from a culture of free, open source, and high quality teaching materials, from everything including the language, the compiler, the standard library, and even widely used third party libraries. The Rust compiler, while unforgiving in enforcing soundness and correctness in code constructs, counters this edge by providing literate error diagnostics, often recommending a correct fix, or a reference towards conceptual information required to understand WHY code is incorrect, instead of allowing the user to disable a correctness check.
These core foundations, both technological as well as cultural, have set Rust on a path towards being a language of choice for systems programing for the next decades, and as a tool that empowers everyone, including those not from a traditional systems background, to building safe and performant systems at scale.
My aim is that participants leave this workshop with a better understanding of the design choices, effort investments, and language concepts that have been applied by the Rust Programming Language, and how they can be applied to other projects, languages, or technologies.
James is an embedded systems engineer, with a history of working on software for a wide range of systems, including safety critical avionics, and rapidly prototyped IoT systems. James is a founding member of the Rust Embedded Working Group, as well as a founder of Ferrous Systems, a consultancy focused on systems development in Rust, with a specialty in embedded systems development.
James is working hard to bring Rust to new places in the embedded domain, including efforts to qualify the Rust language for use in safety critical systems through the Sealed Rust initiative, and building easy to use open source tooling in the Knurling-rs project.
Tue 17 Nov Times are displayed in time zone: Central Time (US & Canada) change
|09:00 - 10:00|
|10:00 - 10:10|
|10:10 - 10:35|
|10:35 - 11:00|
Challenges and lessons learned introducing Fuse, an evolving open source technology, into an established legacy Ada and C++ program
|11:00 - 11:10|
|11:10 - 11:35|
Kyle ChardUniversity of Chicago
|11:35 - 12:00|
James MunnsFerrous Systems
|12:00 - 13:00|