Rust Programming Language / RustFest Zürich 2017

In this talk, I’ll share my experience evaluating Rust as a basis for building Internet of Things (IoT) applications down to the bare metal.

In principle, Rust’s combination of memory safety and low runtime overhead makes it an ideal candidate for building IoT applications which currently are almost the exclusive domain of C and C++. As part of my master’s studies, we ported Tock, an embedded operating system written in Rust, to a Bluetooth Low Energy SoC processor.

In the end, we found that Rust is usable for building IoT applications with similar power consumption as production C implementations.

About Niklas Adolfsson:
Niklas Adolfsson is embedded software developer at Cybercom in Sweden. He received a B.S. degree at in Electrical at University of Borås and is currently pursing a MSc. in Computer Science at Chalmers University. He is also a contributor to Tock and has worked as a dependability engineer at SP Technical Research Institute of Sweden.

Is Rust doomed to stagnate under the yoke of stability guarantees? Is change an inevitable force that will invalidate all your existing code? Is there a reasonable medium between these extremes? We explore these questions, under the guise of a modern day fable.

Felix “Scrooge” Klock remembers the early days when Rust development was fast and loose, an untamed beast. As a result, today he fears changes to the language definition.

Gather round as this “Scrooge” is visited by a series of spirits (manifesting themselves as Rust crates), including:

- The Ghost of Rust Epochs Past (code circa the 1.0 release),
- The Ghost of Rust Epochs Present (code today), and
- The Ghost of Rust Epochs Yet To Come (code as envisaged by the host of RFC’s as we head into the 2017 impl Period).

About Felix Klock:
Felix Klock is a research engineer at Mozilla, where he works on the Rust compiler, runtime libraries, and language design. He previously worked on the ActionScript Virtual Machine for the Adobe Flash runtime. Felix obtained his PhD in Computer Science from Northeastern University, and is also one of the developers of the Larceny Scheme language runtime.

Rust’s type system provides tools to ensure safe memory management, and safe concurrent access to data. What if we used those same tools to encode and enforce other API constraints?

We can leverage affine types (non-Clone structs) to enforce that a user performs a series of operations in a certain order; or we can use structs as tokens representing the user’s ability to perform certain actions. And everything’s checked at compile time.

We’ll see how these techniques let us encode complex API constraints, and make them self-documenting by preventing disallowed behaviour at compile time.

About Andrea Lattuada:
I’m a PhD student and Research assistant in the Systems Group, Dept. of Computer Science at ETH Zürich. I have past industry experience with type-heavy programming languages and now work with Rust on safe, reliable, distributed data processing.

A real-time stream processing and distributed computation system written completely in Rust designed to out-storm storm and is heavily influenced by the Twitter Heron paper. Antimony addresses all the architectural and efficiency issues of storm just like Heron does however implemented in a much safer language and is not bound to be backward compatible with storm. we will explore the implementation of a cross-platform high performance / lightweight stream processing and distributed computation system in Rust backed by the full power of Tokio.rs

About Mohammed Makhlouf:
Mohammed Makhlouf is a experienced Software / Security Engineer, with a passionate interest in machine learning, security and large scale distributed systems. He is the Threat Intelligence Manager at the National CERT of Qatar and is based in Qatar. He infrequently blogs at: http://blog.mak.my

Ever wanted to make a game in Rust but didn’t know where to start? Then ggez is the framework just for you!

It bundles graphics and audio crates together with a simple API so can get started straight away.

In this talk I want to walk you through the making of a game with ggez from empty boilerplate to publishing a playable game.

About Lisa:
Lisa works in the product team at Travis CI. When not writing frontend code she learns Clojure and Rust, makes games and boycotts centralized social media.

Fast, efficient, safe: pick three.

Embedded systems are highly concurrent; they must respond to several different external stimuli within tight time constraints while maintaining a low power consumption. At the core of these systems we usually find microcontrollers, low end Systems on a Chip (SoCs) with just about enough resources to fulfill their tasks: tens of MHz of CPU frequency and a few KBs of RAM are usual.

In this talk we’ll explore how to do efficient multitasking on these systems using zero cost, memory safe abstractions.

About Jorge Aparicio:
Jorge Aparicio has been a Rustacean since Rust 0.9 (early 2014) and since that time he has many several contributions to the compiler, the standard libraries and the crate ecosystem. With his background in Mechatronics Jorge has been tackling, for more than one year now, the task of making Rust easy to use for embedded development with great success. He’s the author and maintainer of several crates and tools core to the ARM Cortex-M ecosystem.

A whirlwind tour through a (macro_rules 1.0!) macro that interprets everyone’s favorite Turing tarpit, Brainfuck, completely at compile time. I’ll highlight various components such as number encoding, arithmetic, input/output and explain how they work.

This is not a macro tutorial. I’ll cover a few techniques that you might possibly be able to use in real code, such as how to set up a recursive macro with an accumulator, but I’ll be breezing through them to get to the fun stuff, like memory zippers and “Zermelo numbers” (a term I may have invented).

About Alex Burka:
Alex is a robotics graduate student at the University of Pennsylvania. He got into Rust by writing his research software (a hardware controller and web interface for a sensor suite), and continues to spend too much of his free time writing macros.

Many times you must reuse code
And your generics aren’t commode
Can you deal in the macro dark arts
Recompose code of similar parts
Or would the compiler explode?

Rejoice! Follow now our ways
Unlock the compiler’s high praise
Listen here to this initiation
Each eldritch arcane incantation
Summons help ‘gainst the terrors we face.

About Geoffroy Couprie:
Geoffroy handles security and quality assurance at Clever Cloud, develops in Rust and researches on parser security at VideoLAN. He thinks a lot about cryptography, protocol design and data management.

Do you need to perform a certain task in Rust? Why not pick a mature C library that already does what you want, and write a wrapping library around it?

Writing a wrapping library is sometimes not as easy as one could think, and you will probably make mistakes that will make you lose time or even make your wrapper unsound.

This talk will show you the most common safety problems you may not have thought of, such as leak safety, but will also give you advices on what not to do when designing the API of your library.

About Pierre Krieger:
After coding in C++ for about ten years, Pierre switched to Rust in 2014 and has been maintaining several game-development-related libraries. He specializes in graphics programming.

This talk will take on a rather diverse set of topics, each outlined in limerick form. For each topic, a short explanation, also in rhymes (though not limerick meter), will follow where applicable. Slides will vary between code examples, rustdoc screenshots and memes.

For example:
With unimplemented!() confess;
to your users the method is less
than done–you can now
add a message of how
to deal with the unfinished mess.

To delve a bit more into what’s new
PR 42155 brought to you
the way to get your message through
for things that you still intend to do.

About Andre Bogus:
The quintessential Rust bard Musician by heart, programmer by trade, Rustacean, Lint maven, Rust Tools peer, nags weekly on rust-users and reddit.

Rust is a systems programming language that runs blazingly fast. But what’s its place for writing applications that don’t particularly need to delve into systems programming, and only need to be “not too slow”? Can it be appealing to programmers who would rather not have to deal with memory management and don’t care about the performance cost?

Can Rust’s type safety and the guarantees it brings allow a high-level programmer to be more confident, empowering them to more easily build and maintain complex applications? Or is Rust’s complexity too much of a barrier for that?

About Élisabeth Henry:
I used to work as a programmer, but I eventually gave up because I couldn’t find a job, and ended I trying to make a living selling fantasy novels. Maybe this last fact shows that I’m not a great programmer (though there might be other factors in play). I love Rust because it makes me feel more confident about the code I write, and the strict compiler compensates for my lack of discipline.

IDE support is one of Rust’s most requested features. From the 2017 State of Rust Survey: roughly 30% of Rust users are looking forward to IDE support more than any other feature in 2017 and for 22% of non-users, lack of IDE support is their main reason for not using Rust. In this talk, I’ll cover what it took to support Cargo workspaces in the RLS and I’ll explain how the RLS leverages existing tooling, including Cargo and the compiler. I’ll demonstrate the current state of Rust programming with an IDE, and how you can benefit from using an IDE with your Rust projects.

About Igor Matuszewski:
Igor is studying Computer Science at the University of Warsaw, Poland. Having worked on a AAA game and various smaller ones, he grew tired of the repetitiveness of the process and started a journey to find a language that would aid in building better abstractions. He discovered Rust and decided to help further the IDE story, so the development process would be more enjoyable. He was accepted onto the Google Summer of Code 2017 as a student and has been working to improve the RLS and IDE support.

Test-Driven Development is a systematic method to develop robust and self-documented software by incremental steps. To TDD in Rust, there will be 2 great obstacles. First, testing infrastructure will be harder to build as Rust lacks reflection, introspection, and casting. Furthermore it is known for its compiler strictness, making incremental development harder. This talk is aimed at applying the TDD method successfully. We will see the methodology by the book, some pitfalls, and how to avoid them with some Rust patterns and strategies that will help you ship at all time with great confidence.

About Thomas Wickham:
Hey I’m Thomas, consultant by day, and open-source coder by night. I work at OCTO Technology, a consulting firm specialized in Agile development and Software Craftmanship. I am passionate about empowering people in their daily lives and helping them undertaking their Why.

Async I/O has forever been a hot topic of discussion in Rust, but over the past year we’ve seen some significant advances in this domain with the futures crate an the Tokio project. We’ll start off by taking a look at where we are today with the async I/O ecosystem in Rust, highlighting a number of the features we’ve added in both the libraries and the language over the past year. We’ll then take a deep dive into Tokio itself, seeing how it capitalizes on some of Rust’s greatest strengths by going Back to Futures and gets our DeLorean up to 88mph.

About Alex Crichton:
Alex is a member of the Rust Core Team who has worked at Mozilla on Rust for the past four years. He is also a member of the Tokio Core Team, one of the primary authors of Cargo, helps maintain the standard library, and likes to ensure that engine of Rust never stops.

Introducing a working prototype for a minimal actor-oriented system runtime to handle millions of actors and passed messages, across processor cores and even machines. It is written in and used from Rust. Using an additional code-generating build script, type-safe remote message sending and handling is magically desugared from plain Rust function calls and definitions, including dynamic dispatch with traits. This makes it possible to write complex, extensible distributed systems in idiomatic Rust.

About Anselm Eickhoff:
Self-taught hacker and CS student from Germany. Got the crazy idea to build Citybound - a new, large-scale city simulation game and engine, on my own. I’m busy plowing through all the custom technology that needs to be invented and implemented for that, all of which I write in Rust.