In this post you will find everything that happened in the Rust community during Q4 last year. 37 talks that had been recorded at Rust meetups and conferences, like Rust Belt Rust Conference in Columbus, OH or RustFest Zürich in Switzerland. Many thanks to all the speakers for helping me out with descriptions and reviewing your talks!

MeetupFeed collects and organizes dev talks recorded at meetups and conferences so you can follow your global community. The next Rust post is coming soon with this year’s Q1 talks so you might want to follow us on twitter or subscribe to the monthly newsletter (strictly one mail with dev talks only).

Clint Byrum talking about Rustlang as a systems programming language and the benefits of using Rust on a team.

In an age of diminishing single-core performance improvements, having a strong grasp of concurrent programming is more useful than ever. But what makes it so hard to learn compared to many other concepts? Race conditions are sneaky: they might not show up in your tests, and it can be terrifying if they’re first found in production. It’s not always easy to see when we’ve made a concurrency mistake. Rust can help! This talk will show you how Rust will catch many concurrency errors at compile time, giving you a quick feedback loop to improve your understanding of how to make concurrent programming safe. No matter what language you develop in the most, practicing with Rust could help you improve your skills. Don’t fear the concurrency! David Sullins NVIDIA Professionally, David has been doing all sorts of things related to game development for NVIDIA for the past 9 years, mostly using C++. In his free time he likes learning other languages that can teach us new ways of thinking about problems. Besides Rust, he’s recently been interested in Idris and Elixir. When he’s not working or talking your ear off about Rust, he also likes cooking, cycling in all weather, and hugs.

Aaron, Carol, and Niko will deliver an update on the state of all things Rust. You don’t want to miss it!

Rust was voted “most loved” language by developers for the second year in a row in the Stack Overflow developer survey. There have been projects made using Rust on everything from operating systems to game engines for Minecraft-like games. Despite this, IDE support is still very limited. As my Google Summer of Code project, I worked on a Rust plug-in for the KDevelop IDE which aimed to support most standard IDE features such as semantic highlighting, code completion, project management and debugging. I will go through the challenges of integrating language support in an existing IDE and talk about how adding semantic highlighting was one line of code and getting debugging to work took less than 10 minutes. Emma is a third year undergraduate at Imperial College London. She worked at Microsoft Research in summer 2016 on the AssessMS project. She started working on a Rust language support plugin as part of Google Summer of Code 2017. She has been programming for around 10 years. She is interested in several different areas of computer science, namely artificial intelligence, computer vision, computer graphics, and most recently, compilers, type systems and operating systems and has worked on various different projects in these fields during high school and university. In her free time, she’s currently working on a hobby OS in Rust.

Firefox is in the process of shipping a new implementation of CSS styling written in Rust as part of Mozilla’s Servo project. Firefox has 20+ million lines of code and hundreds of millions of users, so this is no small undertaking! As a case study for integrating a large, multi-repo Rust project into a larger C++ project, this talk explains how we: *created bi-directional FFI boundaries that maximized each project’s strengths *addressed cross-language mismatches including threadsafety and ownership *integrated two fast-moving codebases while managing regressions We’ll cover specific successes and failures that emerged over the course of the project, and discuss how Rust contributed to those outcomes. Josh Matthews builds web browsers and sustainable communities for a living at Mozilla. He gets excited about demolishing barriers to participating in open source projects. He also sings in a barbershop quartet.

Creativity as a concept is not generally well understood, and that’s especially true as it applies to programming. Creativity can be either invaluable or dangerous, and sometimes it’s both. By understanding creativity, you’ll be able to leverage it to build awesome software. In this talk, we’ll explore what it means to be creative and how it relates to programming, and especially to Rust. Expect to come away with some tips for how to let your creativity flourish. Phil has been a software developer for a while now, but before that he was a painter and sculptor. These days, he spends his time working for a big data startup in Columbus, and creating tooling for event-based microservices. He loves hiking, camping, climbing, and talking smack about art, programming, and the convergence of the two.

Beneath every safe programming language, library, or virtual machine is a whole lot of unsafe code. Rust is no exception. This talk will explain why “unsafe” code is allowed at all in a safe language, show the unsafe code at work inside safe features like Vec, and teach how to write a safe library that uses unsafe code. Jason Orendorff lives just outside Nashville, Tennessee. He’s a hacker for Mozilla and the coauthor of Programming Rust, the O’Reilly book with the crab on the cover. You can find Jason as @jorendorff on GitHub.

So, you’re new to the Rust community. (Or any community, really!) And you want to help, but, well, you’re new. So how exactly do you start contributing? What kinds of contributions are valuable? We’ll talk about everything from asking questions to writing documentation, from pitching in on forums and chat to writing blog posts, and from starting your own projects to contributing to other open-source projects. Chris Krycho is a senior software engineer at Olo, where he spends most of his time writing TypeScript in Ember.js. He has hosted the New Rustacean podcast for the last couple years, trying to build up the Rust community both by providing teaching resources and by helping create enthusiasm and a way for people to learn about the programming language without ever having written a line of code.

Traits are one of the most powerful, but also most difficult parts of Rust to master. Come to this talk for a visual exploration of how traits work – from the most basic to the advanced. It is only through deep understanding of a concept like traits that you can fully harness their power in your every day code. You will walk away with a deep understanding of how traits work, why they work the way they do, and the how and why of using them. Nell Shamrell-Harrington is a Software Development Engineer at Chef and a core maintainer of the Habitat open source project. She also sits on the advisory board for the University of Washington Certificates in Ruby Programming and DevOps. She specializes in Open Source, Chef, Rust, Ruby, Rails, Regular Expressions, and Test Driven Development and has traveled the world speaking on these topics. Prior to entering the world of software development, she studied and worked in the field of theatre.

“Ashley live codes a web server in Rust in less than 5 min”

A lot of people think that 0.999999… is almost, but not quite, entirely unlike 1. In this lightning talk Daan van Berkel tries to set the record straight, or at least add to the confusion. If you are feeling anxious, nervous are experiencing depersonalisation, reach out to Daan. He is also providing math counseling.

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). 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 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? Élisabeth Henry used to work as a programmer, but eventually gave up because she couldn’t find a job, and ended trying to make a living selling fantasy novels. Maybe this last fact shows that she’s not a great programmer. She loves Rust because it makes her feel more confident about the code she writes, and the strict compiler compensates for her lack of discipline.

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.

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.

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

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.

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.

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.

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.

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.

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.

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 is a web developer based in Berlin. When not writing frontend code she learns Clojure and Rust, makes games and boycotts centralized social media.

SHAR is the 3d multiplayer action game. I am going to talk about its internal implementation details and about problems and challenges met during development. I’ll give a quick overview of all components SHAR is using – GUI, animations, FXses, networking, data serialization, modding. I’ll show some code and will describe why decisions were made and to what consequences they led to. About Fedor Logachev: Game programmer from Saint-Petersburg, Russia. Worked on Unity3d games mostly.

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.

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.

Rust is a new systems programming language that promises to overcome the seemingly fundamental tradeoff between high-level safety guarantees and low-level control over resource management. Unfortunately, none of Rust’s safety claims have been formally proven, and there is good reason to question whether they actually hold. Specifically, Rust employs a strong, ownership-based type system, but then extends the expressive power of this core type system through libraries that internally use unsafe features. In this work, we present RustBelt, the first formal (and machine-checked) safety proof for a language representing a realistic subset of Rust. Our proof is extensible in the sense that, for each new Rust library that uses unsafe features, we can say what verification condition it must satisfy in order for it to be deemed a safe extension to the language. We have carried out this verification for some of the most important libraries that are used throughout the Rust ecosystem. In the talk, I will first review some of the essential features of Rust, and then explain some of the key ideas behind the RustBelt verification.

Rust is a new programming language that is growing rapidly. Rust’s goal is to help in writing programs that are at once correct and efficient. Rust offers performance comparable to C++ and, like C++, has minimal runtime requirements — it does not require a runtime or garbage collector, and you can even choose to forego the standard library. At the same time, Rust offers some of the strongest safety guarantees around — not only type and memory safety, but also data-race freedom! A key part of Rust’s design is that the language itself doesn’t “privilege” one form of parallel programming over the others.Instead, Rust supplies two core primitives — ownership and traits — that enable libraries to implement a wide variety of parallel styles. Currently, libraries exist to support newer models like actors and futures, but also more traditional threaded programming based on locks. There are also a host of non-blocking data structures available, as well as a work-stealing runtime that makes data parallelism very easy. This talk will cover some of the highlights of Rust’s design, and show how Rust’s type system not only supports different parallel styles but also encourages users to write code that is amenable to parallelization. I’ll also talk a bit about recent work at Mozilla, where Rust was instrumental in parallelizing parts of Firefox’s CSS engine. Nicholas Matsakis is a senior researcher at Mozilla research and a member of the Rust core team. 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.

Second talk for the first Rust Edinburgh meetup, the first Scottish meetup about the Rust programming language. Simon Brand from Codeplay Software Ltd. presents his talk “How Rust gets polymorphism right”.

Node.js is not just a server platform any more, but it is used to build client-side apps, automation, even fly drones and control robots! While JavaScript’s performance (and consequently node’s performance has increased tremendously in the past few years sometimes we really could use the extra juice: and here’s where Rust comes in, dropping in a few bits of blazingly fast Rust could make a huge difference for some applications and use cases. Here’s how…

JavaScript is the application language of the web. Rust will be the systems language of the web. WebAssembly wants to be the assembly language of the web. What if we take Rust, compile it to WebAssembly and it becomes the application language of the web as well? WebAssembly as a target for the web opens up new possibilities and Rust is one of the first languages with full support for it. Use your new project, re-compile that old library and make your application accessible in a web browser. Learn how to make use of this newfound superpower already found in the latest version of the most popular browsers!

We’ll take a look at how we started using the Rust Language in Firefox. From importing entire crates, to just a few lines, it’s a fascinating process that is already paying off. The Rust language already powers Firefox’s new Firefox Quantum release and is a source of infinite possibilities – and we’re only getting started!

Over the last year, Rust has found production adoption beyond Mozilla at Dropbox, Chef, Canonical and others, powering whole new production systems. Why is such a young language suddenly so eagerly picked up? Rust is a surprisingly versatile language bringing safety increases to both the server-side and memory-constrained systems like IoT devices. But it isn’t only a safe language, but also one to pleasantly program in. Rust provides both abstraction capabilities usually reserved to higher-level languages as well as fine-grained control upon need. The talk will give an overview of the problems Rust allows to solve better – in practice!

 

The post Rust Talk videos from meetups and conferences like the Rust Belt Rust Conference or RustFest Zürich appeared first on MeetupFeed.