-
keynoteSubtyping in Rust and Clarke's Third Law
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.
“Any sufficiently advanced technology is indistinguishable from magic.” – Arthur C Clarke
This is a talk about magic. In particular: Rust has subtyping, but it may not be in the place where you thought it was. My primary goal is to explain that metaphorical sleight-of-hand, in two parts. My secondary goal is to convey that most of the time you need not think about subtyping, except when doing particularly hairy data structure development where questions arise around “variance.”
Part 1 is dedicated to examples of Rust that might look like subtyping but are not. It will spend some time on how generics can be used for parametric polymorphism and how that differs from subtype polymorphism. However, most of the examples will be of things like coercions (e.g.
&Vec<T>to&[T]) and autoref/autoderef, which look very similar to subtyping, and thus require more scrutiny to differentiate them.Part 2 is dedicated to where Rust does have subtyping: references and their lifetimes. I will describe how the partial ordering on references naturally yields a subtyping relationship. The existence of a subtyping relationship, combined with type-parametric polymorphism, implies that we sometimes* need to think about variance. I will explain the roles of covariance and invariance, putting particular focus on how the selection of covariance over invariance in some cases has caused soundness holes (or at least warts) in other languages such as Eiffel and Java.
*: “sometimes” here means either 1. when we are writing unsafe data structures or 2. when we are trying to understand certain compiler error messages. Not everyone falls into category 1, but I think everyone cares about category 2.
-
keynoteScience tools borrow Rust
The reasons you need a software to perform calculations may vary, but if you come from a science or engineering background, you might need results to project electric circuits, process data or try to predict an output. There are several open source tools to help you with calculations - one of them is Octave, written mostly in C++.
“What if we rewrite some of this functions using Rust to see what happens?”
This talk will answer this question, showing an interesting journey to rewrite linear algebra functions, complex functions and structures often used into Digital Circuit processing or circuit schematics (such as FFT).
Topics:
- Some inconveniences of C/C++
- Rust as a possible solution to improve collaboration on tools like Octave
- First big challenge - I don’t know math
- Rewriting basic matrix functions with Rust
- Some functions involving complex numbers and Rust
- Attempts of FFT
- Lessons learned on types, safety and Rust Language
- Epilogue
-
Techniques for writing concurrent applications with asynchronous I/O
Matthieu Wipliez
A software developer and geek, Matthieu has been writing code since he was a teenager. He holds a PhD on compilation of dataflow programs, and co-founded a company called Synflow where he created a new language for chip design. He is now working at Harmonic, Inc. doing proof-of-concept of new applications related to video. After a decade of Java, Matthieu switched to Rust as his language of choice in 2016. He has developed an open-source Web framework in Rust and is also contributing to other open-source Rust crates.
This talk is about asynchronous I/O: how asynchronous compares to the traditional synchronous approach, how this changes the architecture of applications, and how to do asynchronous I/O in a concurrent multi-threaded application. Starting from a high-level view, we will then dive into code to explore useful code idioms and how to design ergonomic Rust APIs. This will include for instance how to store callbacks with unique types and call them from different threads, how to get lifetimes shorter than ‘static in threads and the associated benefits.
I am doing this talk based on the experience I gained developing a Web framework on top of the asynchronous version of Hyper, the most used HTTP library for Rust. Principles should apply to lower-level libraries and other protocol stacks as well.
-
Teaching myself Rust through the medium of coordinate system transforms and FFI
Stephan Hügel
I’m a PhD candidate at the UCL Centre for Advanced Spatial Analysis, in London. My research is focused on the “smart cities” movement, and socio-technical urban systems.
I’m the co-author of a book chapter on urban data visualisation, a popular blog post on making maps with Python, and several in-depth data analysis and visualisation tutorials, as well as Tweet City, a visualisation project using tweets and buildings, which was featured in Fast Company.
I’ve been teaching programming and data visualisation to undergraduates and postgraduates for three years, and have given talks at the Royal Geographic Society and the Bloomsbury festival. This is my first ever talk about programming languages!
Transforming coordinates from one coordinate reference system to another is slow, and usually done in bulk, so it’s a great candidate for low-level, multithreaded code, accessed via FFI from higher-level languages to facilitate easy I/O and visualisation. When Rust hit 1.0 last year, I decided to write a library to convert from latitude and longitude coordinates to British National Grid eastings and northings, in order to learn the language. The result is the lonlat_bng crate and the convertbng Python package.
This talk will focus on several areas:
- Experiences from learning a systems programming language for someone coming from dynamic languages
- Evolving code from single-threaded to multi-threaded, and how to use tests and benchmarks to get there
- Comparing the performance of the Crossbeam and Rayon libraries for parallel execution
- Using Perfect Hashing for fast access to large (300K+ members) HashMaps
- Detecting numerical instability using Herbie, and using Clippy to catch common mistakes and style errors
- Implementing generic functions to keep your code clean and DRY-conformant
- Writing a lot of docs and examples, so people can get going quickly
- Integrating your Rust binary with your dynamic code, and making it available to the rest of the world, including discussion of linking to system libraries, and the intricacies of building cross-platform libraries.
-
Hobby-oriented programming
Sonja Heinen
Sonja is a semi-nomadic visual designer interested in the space where technology, art and society collide. In October 2014 she earned a Master’s Degree in Sustainable Design from Kingston University in London, then relocated to Berlin. She currently works as a Frontend developer and roams through open source communities.
A hobby can be defined as any regular activity, that someone engages in for enjoyment. Activities range from artistic crafts, playing an instrument, making homemade food and drink to collecting strange items …or experimenting with code. With continuous practice the hobbyist will acquire significant skill and knowledge in a particular field, which allows him or her to apply it in a serious manner.
Hobby-oriented programming not only defines developer types (amateur and professional), but furthermore explores the correlation between a programmer’s happiness and leisure time activities.
-
Panopticon - A Libre Cross-Platform Disassembler in Rust
Panopticon is a libre cross-platform disassembler written in Rust. The project aims to develop a free replacement for tools like IDA Pro and Hopper. What sets Panopticon apart from other free disassembler is that we believe a graphical user interface is crucial in helping analysts understand binary code. Panopticon implements semantic-based analysis to aid reverse engineering and vulnerability discovery. The project started in 2012 but was rewritten in Rust in June 2015 and has grown to 25k lines of code since.
The talk will be about the architecture, vision and feature set of Panopticon as well as how Rust specific features helped to find bugs and accelerate development. I will also talk about my experience building a 25k LOC project as a complete Rust newbie. The talk will touch on the language itself as well as the availability (or lack) of tooling.
-
Why you'd be better off using QuickCheck when porting to Rust
Martin Hellspong
Martin is a developer and consultant at factor10 Solutions AB, and holds a Master’s degree in Software Engineering. He has spent almost two decades designing award winning systems and ERP integration solutions for the Retail industry, Food industry, Insurance sector and Military training systems, in roles ranging from architecture to managing terabyte-sized relational databases to hardware integration.
The last four years has included a lot of Scala and C#, CQRS/EventSourcing, Actor systems, Microservices, Cloud and Container technologies. He loves functional programming, and the clarity of thought in languages like Scala, Rust, F# and Clojure.
For about half a year I’ve been doing a Rust port of a CPU emulator library written in C. This talk will tell you why on earth someone would want to do that, and why the effort likely would have failed without the use of QuickCheck, which has enabled me to thoroughly compare and test that the port has identical behavior to the original (as well as the CPU spec).
It will also tell the tale of macro madness, the discovery of a O(n²) bug in the Rust compiler, and why I think most Rust tradeoffs are near-optimal, seen from someone with years of experience with C/C++, C#, Scala and Clojure. It will also explain the complications when using Cargos multi-threaded testing model interfacing a single-threaded C library, and some potential solutions.
-
Empathetic communication: why vulnerability is the key to collaboration
Sharon Steed
Sharon is a speaker and founder of Communilogue, a digital marketing agency specializing in content. She’s worked with companies across the globe on identifying their ideal audience and creating content geared specifically towards who that audience is. Her clients have included financial planners, estate attorneys, startups, insurance companies and retail corporations. She speaks on marketing and communication. A life-long stutterer, she uses her speech limitation to teach audiences about the value empathy and vulnerability in business and in life.
In business as well as in life, few things are more important to your success than building relationships. But so often, relationships fail before they get solid footing because we as humans sometimes have a difficult time connecting. That connection begins with empathy. And the key to empathy? Vulnerability. Sharon is a stutterer, and she knows how valuable one’s voice is. She also knows how it feels to attempt to share an idea only to fail miserably as a result of a communications breakdown. After years of struggling to join the conversation, she finally learned how communicate her ideas in a way that forced people to listen. And that’s what she’s going to discuss with you. The takeaways from this talk will be learning how to value the listener, improved collaboration at the office and becoming a master at building a relationship quickly and effectively.
-
Linux USB HID Interfacing in Userspace
Detailing the process of writing a userspace driver for a USB human-interface device in Rust using mio. Will briefly touch on reverse-engineering undocumented HID protocols and MIDI devices.
-
Learning to Love the Unfamiliar
Coming from Ruby, JS, Python or another language? Exploring new languages can be toilsome. Rust is no different. You’ll find new idioms and features that could be unfamiliar to navigate. You might even detest them at first; comparing it to how you’d prefer it in your favourite language.
We will learn to navigate your transition into the Rust landscape. Introduce practices that might not make sense at first. See comparisons of how you may have done things, and how we can improve those practices with Rust.
-
Sensors, Servos, and Signals with Rust
Rust is a systems language ready for IoT. In this talk, we’ll learn how to move servos, make sensor measurements, and speak low-level communication protocols like SPI and I2C. When joined with high-level HTTP libraries, audiences will leave knowing how to create a fault-tolerant embedded device that’s accessible from the cloud. Examples use the Rust language and target the Tessel microcontroller platform.
-
intermezzOS: a teaching operating system
ashley williams
engineer, npmjs board of directors, nodejs founder, node_together collaborator, intermezzos
intermezzOS is a teaching operating system, specifically focused on introducing systems programming concepts to experienced developers from other areas of programming.
-
special guestThe Rust That Could Have Been
This talk will describe a number of language concepts and features that were in the pre-1.0 Rust language at some point but were ultimately abandoned, such as typestate, garbage collection, structural types, and a more or less classical object system. I’ll go over the reasons they were abandoned, and try to convince you that the Rust we have now is the best Rust yet.
Further on stage
-
Moderator
Ryan Levick
I’m fairly new to low level programming so it’s been a real joy learning about topics that once seemed to be reserved for those who were fluent in C or C++. I hope to shed some of my excitement on others. This stuff doesn’t need to be scary! I take a lot of my inspiration from intermezzOS and the kaleidoscope LLVM tutorials both of which I think are very approachable.
-
EthCore Ltd
Robert Habermeier
Robert is a core developer and crypto researcher for Ethcore, where he works on Parity, a high-performance client for the Ethereum blockchain platform written in Rust. A longtime member of the Rust community, he has focused on building highly parallel and performant solutions by leveraging the language’s features.