Armin Ronacher talks about getting into Rust, when to use it, writing Rust extensions for Python, building the Symbolicator web application with actix, creating debugging libraries, and the Rust ecosystem.
Custom derive code can be challenging to read and write for developers who are not familiar with it, however it is a very powerful tool which may empower people to write less code while have more things done. It has been widely used in Servo’s style system. This talk will take a brief look at how custom derive is used in Servo’s style system, and describe how a custom derive can be developed from scratch.
While the official future based asynchronous system is under way of building and maturing, I’d like to talk about another asynchronous story that based on stackful generators and coroutines.
I’m the author of May(https://github.com/Xudong-Huang/may). I could talk the designs and implementations of it, give some fundamental concept about generator and coroutine, the overall structure of coroutine scheduling, the sub IO system, the sub sync preemptive system, the cancellation mechanism, and and compare it with current future based systems
Rust expresses trait bounds using the where clause. It is an essential tool for all generic Rust programming. Yet, many Rust programmers don't know about the full expressiveness of it!
This talk guides us through most of the features and shows us how to creatively use where clauses to both keep our code clean and flexible, but also sound and hard to use in a wrong way.
This talk will teach us the basic building blocks to not get lost in a forest of constraints.
Rust guarantees memory safety, but it doesn’t stop you from doing everything. From unsafe to unwrap and more, there are lots of ways for you to subvert and make your code fail due to our own mistakes: logic bugs and incorrect assumptions.
Come along and learn Rust techniques and patterns that will help build safe guards into your code, test your assumptions, and get a better understanding of what Rust and you can guarantee with your code.
All so you can sleep sounder at night and not be woken up at 3am while on call.
The Rust Compiler is quickly becoming well known for its helpful messages, going out of its way to provide relevant suggestions to common problems.
As the Rust language reaches more people, the compiler is having to cater to both newcomers and highly experienced developers who may write incredibly complex code.
In turn, this means that diagnostics need to be comprehensive enough for newcomers without being distracting to those already familiar with the language. Making rustc act as a personalized tutor is useful for newcomers and has contributed to the language's growing popularity. However, it requires a lot of upfront work and foresight from the developers of the compiler.
During this talk we will cover the current guiding principles of rustc development, how you can contribute to the compiler, and where to find documentation and help.
Nicholas Matsakis is a Senior Staff Researcher at Mozilla Research and a member of the Rust core, compiler, and language design teams. He has been working on Rust since 2011 and did much of the initial work on its type system and other core features. He did his undergraduate study at MIT, graduating in 2001, and later obtained a PhD in 2011, working with Thomas Gross at ETH Zurich. He also spent several years at DataPower Technology, a startup since acquired by IBM, working on the JIT compiler and networking runtime.
Alex will try to convince us that procedural macros are the best thing since sliced bread. With "macros 1.2" now on stable Rust there's no better time to discover the world of procedural macros and what they can do for us.
We've already seen the power of derive macros shoot Serde to one of the most popular crates in Rust. With attribute macros we can go even further with lightweight annotations powering frameworks. And finally with procedural macros the sky is the limit!
Let's learn about tips, tricks, and usage of the procedural macro world!
Boats is a member of the language design, library, and cargo teams of the Rust Project. They are Senior Research Engineer working on Rust for Mozilla Research. Contributing to Rust since 2014, they've done design work for significant language extensions like generic associated types and constant generics. For the last year, Boats has been focused on adding async/await syntax for non-blocking I/O to Rust.
WebAssembly fulfills the long-awaited promise of web technologies: fast code, type-safe at compile time, execution in the browser, on embedded devices, or anywhere else. Rust delivers the power of C in a language that strictly enforces type safety. Combine both languages and you can write for the web like never before!
He'll even show hot-swapping WebAssembly modules to control LEDs on a Raspberry Pi.
RustConf 2018 - Closing Keynote by Catherine West
When you’re just starting out in Rust, you start by building small programs. As we all know though, medium and large projects can have very different, unique kinds of problems that smaller projects never encounter. As our projects grow in size, we need to be increasingly concerned about code organization, separation of concerns, implementation hiding, and other techniques to manage growing complexity.
Most languages have tools and patterns to deal with this, and Rust is no exception. However, the patterns that we learned from other languages, especially in mainstream OO languages, are often unhelpful when applied to Rust, and this can lead to a roadblock when trying to transition to building moderate or large Rust programs.
This talk will cover a case study of a moderate sized game engine written in Rust and Lua, and show strategies for implementing things in Rust where common implementations in other mainstream languages are a poor fit. I’ll also discuss some examples of problems unique to Rust that ended up with very nice —but sometimes not obvious— solutions.
Along the way, I’d also like to discuss working with Rust in game development generally, and what it’s like getting Rust to run on mainstream game consoles.
Slides at [https://kyren.github.io/rustconf_2018...](https://kyren.github.io/rustconf_2018_slides/index.html)
The Rust programming language purports the bold claim that it guarantees thread safety while retaining the ability to write zero-cost abstractions. In this talk we'll explore precisely how Rust can make such a claim. We'll also explore the ecosystem that makes up the concurrency toolkit in Rust to see how these language principles are extended to common abstractions such as channels, thread pools, work stealing algorithms, concurrent data structures, and asynchronous I/O.
In this talk, I’ll tell the story of how I convinced my manager and team to give Rust a chance. Along the way, I’ll talk about the critical challenges that the npm registry services encounter on a daily basis, the patterns we’ve adopted to cope with the heavy operational load, and how they are well suited to be solved with Rust. I’ll also highlight the unique aspects of Rust that make it an pleasure to learn and teach, as well as how it is a strong technical candidate for replacing Node.js (hint: Tokio!).