Rust Programming Language / Other conferences 2016

Have you ever wanted lightning-fast code, without the segfaults and tedious boilerplate of C? Then come learn why so many Pythonistas are excited about Rust, a new language from Mozilla. After a short introduction to the language, we'll see how the Rust Python bindings let us easily write elegant, safe, and high-performance extension modules, hassle-free.

Up until now, the go-to language for low level, performance oriented code was C, or C++. Last year, Mozilla publicly released Rust, a language designed for safe memory manipulation, providing high level tools for low level development. It has since proven a good language to build the basic bricks of a system, and replace some C plugins for various language with safe and readable code. I will present in this talk various techniques I use to rewrite parts of a project in Rust, and the benefits you can get from applying it to your own projects.

Geoffroy Couprie 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.

[TYS-8334]

IoT devices are becoming more intelligent, cheaper and they are connected to the internet. They could also handle personal data and therefore need to be secure. On the other hand, they need full memory access. C/C++ can do this, but it’s also known to be complex and insecure memory management. Other languages (e.g. Java) protect the memory access but aren’t lightweight and it’s not possible to get full memory access. Rust is designed to have both 100% access and also be 100% secure.

I will give an overview, demonstrate how Rust handles the memory access and how it can be cross-compiled to run natively on a small microcontroller and how it can be debugged on bare metal.

Lars Gregori works as Technology Strategist at SAP Hybris in Munich as member of the Hybris Labs team. He is interested in all kinds of new technologies for the Internet of Things (IoT), Arduino, BLE and NFC, BeagleBone and Raspberry Pi, MQTT, Minecraft and more. Before the computer science degree, he completed an apprenticeship as communication electronics (wireless technology).

[FVY-3267]

Speaker: Omer Iqbal

Segfaults, Buffer Overflows, Data Races and Memory Leaks cross over unprotected memory with ease. They steal our jobs, crash our code, cause vulnerabilities in openssl. We need to be tough. The liberals from C and C++ have kept these borders open for too long. It's time to build a wall...

Rust is a systems programming language designed for speed, safety, concurrency and hype. It features a radical memory model that gives YOU control, rather than those pesky garbage collectors, while still maintaining compile time safety gurantees.

This talk will introduce Rust, focusing on the fabled memory model, the motivations behind its design and the consequences.

This talk was recorded at GeekCampSG 2016 on 29 September 2015.

Visit http://geekcamp.sg for more information about the event

Until recently making a compiler from scratch that produced fast native executables with a well-tuned garbage collector meant getting really comfy with C. Rust has risen to the top of the heap as a developer-friendly systems programming language that allows the same degree of control as C but is much more expressive and sports an innovative type system that avoids the pitfalls of pointer arithmetic. Surprisingly though it hasn't seen much uptake among language implementors. This talk will present a compiler for a small, garbage-collected Scheme-like language written entirely in Rust. It will explore the pros and cons of using Rust for language development and show benchmarks comparing the garbage collector and runtime up with similar well-known languages written in C.

Robert Collins
https://kiwi.pycon.org/schedule/presentation/136/
Rust is a new systems programming language iniated and sponsored by Mozilla thats making some waves - its the core for servo, Firefox's new parallel render engine, amongst other things. Find out how it is relevant to Pythonistas even in these modern mypy days, as well as interop between Rust and Python, and differences in programming style.

Rust is the new kid on the block. It's a system programming language that is blazingly fast and offers powerful high-level abstractions better known from dynamic languages like Ruby or Python. Rust offers memory safety without a Garbage Collector and makes low-level programming easier and more secure. I will give an introductory talk about Rust and show some of its nicest features.

Rust is a systems programming language from Mozilla that focuses on safety, speed, and concurrency. Rust reached 1.0 a year ago, and so there’s a question everyone is asking: how has 1.0 tested in production? Is the language “ready” yet? In this talk, Steve will give an overview of Rust’s value proposition, focusing on examples and anecdotes from companies using Rust in production today.

Every function or method we write in any language has some hidden semantics. Who owns the values passed in? What am I allowed to do with the values returned? In 2015, Mozilla released the Rust programming language, which brought to the table ways to represent these "ownership" semantics in programs. In this talk, we'll take a deep dive into how thinking about ownership can help keep defects out of our programs, regardless of language.

Author: Steve Klabnik

Abstract:

The Rust programming language recently celebrated its one year anniversary since 1.0. While that's not a long time, there were eight years of development before that, which saw radical changes in the language. In this talk, Steve will show off some of Rust's history, with all of the decisions and changes that were made along the way.

ACM DL: http://dl.acm.org/citation.cfm?id=2960081
DOI: http://dx.doi.org/10.1145/2959689.2960081

Speaker: Alex Crichton - Senior Research Engineer, Mozilla

Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety. Modern language features, such as closures, type inference, pattern matching, and trait-based generics, are supported in tandem with low-level features like zero-cost abstractions, efficient C bindings, and a minimal runtime. With the stable 1.0 release of the language in May 2015 Rust has seen widespread growth and adoption as well as continuous iteration on both the language and the libraries. This talk will explain the fundamentals of Rust and how they're leveraged to achieve the language's lofty goals as well as give a preview of some of Rust's upcoming features.

Alex is a Senior Research Engineer at Mozilla since late 2013. As a member of the Rust core team, library team, and leader of the Tools team, Alex has been working on Rust since late 2012. He is the author of the current std::sync::mpsc module in the standard library, and in the past has architected the runtimes of the standard library (which have since been removed). Currently Alex works on Cargo, Rust's package manager, the standard library, and fostering development of libraries in the community at large.

Recorded at Big Techday 9 / http://www.bigtechday.com of TNG Technology Consulting GmbH / http://www.tngtech.com on June 3rd, 2016 in Munich / Germany

Ruby is a wonderful language, but sometimes, you need a little extra oomph. While C extensions are a great way to improve performance-sensitive parts of your application, you can use other languages too. In this talk, Steve will show off the Rust programming language and how to integrate it with Ruby. Rust is a systems language focused on safety, speed, and concurrency, and compliments Ruby nicely.

Slides and more info: http://www.lambdadays.org/lambdadays2016/eduard-bopp


Functional reactive programming as pioneered by Conal Elliott is gaining wide-spread interest as the go-to abstraction for interactive applications. Many functional idioms rely on a high level of abstraction over details like memory layout.

But can this concept be translated to an application domain, where you cannot afford this luxury? Think of real-time systems like video game engines or embedded software, where you have a tight performance budget.

Rust is a new programming language developed as a community project supported by Mozilla. It brings a strong type system with compile-time memory safety and high-level abstractions to the world of low-level systems programming.

This talk tells the story of a library called Carboxyl, an implementation of functional reactive event streams and behaviours in Rust. Dealing with explicit memory management provides certain unique implementation challenges. However, Rust's static memory-safety guarantees were very helpful overcoming these. Furthermore, the talk will demonstrate typical architectural patterns for using FRP in practice.

Emily Dunham
https://linux.conf.au/schedule/30223/view_talk
Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety. Behind the scenes, Rust is also a community that nurtures new contributors, consistently enforces its code of conduct, and maintains a high-quality codebase.

This talk will discuss the implementation details, as well as the social motivations and effects, of the customized infrastructure and workflow practices which allow the small core team to have such a significant impact. Come learn about bots which integrate with GitHub to identify and assist new contributors, the "Not Rocket Science" process for holding a project's code to high standards without being mean to anyone, and more!