Rust Programming Language / Other Conferences 2017

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.

This presentation was recorded at GOTO Berlin 2017. #gotocon #gotober
http://gotober.com

Florian Gilcher - Professional Programmer & Co-founder of asquera

ABSTRACT
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 [...]

Download slides and read the full abstract here:
https://gotober.com/2017/sessions/252

RECOMMENDED BOOKS
Tim McNamara • Rust in Action • https://amzn.to/3ux2R9u
Blandy, Orendorff & Tindall • Programming Rust • https://amzn.to/3x7r6w6
Ken Youens-Clark • Command-Line Rust • https://amzn.to/3PQZ539
Kevin Hoffman • Programming WebAssembly with Rust • https://amzn.to/3x3brhe

https://twitter.com/gotober
https://www.facebook.com/GOTOConference
http://gotocon.com
#Rustlang #Rust #Programming #ProgrammingLanguage #SoftwareEngineering #Mozilla #Coding #FP #FunctionalProgramming

No description provided.

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.

Web frameworks are laden with compromise. Do I choose the simplicity and ease of a dynamically typed language, or the safety, security, and performance of a compiled, statically typed language? Do I choose a framework that's made every decision for me or one that's made few? Rocket is a new web framework for the Rust language that aims to eliminate these compromises.

Rocket builds on Rust's strong type system and code generation facilities to provide a new level of simplicity, safety, security, expressiveness, and performance. With Rocket, developers only write what's unique — never boilerplate — and instruct Rocket to code generate the rest. Code generated by Rocket automatically parses, validates, and deserializes incoming request data and metadata. There is no runtime introspection and no runtime errors; it all happens at compile-time.

Rocket's code generation enables it to protect against input validation hazards that other frameworks consider not-their-problem. In Rocket, request handlers are protected by a set of types, known as request guards, that represent security and data validation policies. Rocket only dispatches requests to a handler when all of its guards pass. In other words, Rocket guarantees that handlers only execute under validated security and data policies.

This talk will describe Rocket and its approach to request handling, focusing on the use of code generation to deliver a superior developer experience and strong security guarantees.

Sergio Benitez

Sergio is a third-year PhD student at Stanford. His research focuses on converging programming language theory with operating systems and security. His recent work introduced Rusty Types, a formal typing discipline based on the Rust programming language. Before Stanford, Sergio spent time interning at Google, Apple, and SpaceX where he worked on projects ranging from designing anomaly detection algorithms to tuning the performance of operating systems running on rockets and other spacecraft.

The recent surge of interest in secure memory management has sparked a renaissance of type safe systems programming languages. ATS is a statically typed ML that compiles to C and offers what almost no other modern systems language including Rust has: type safe pointer arithmetic. It is unabashedly large and complex featuring a dazzling array of verification tools from advanced type system mechanisms like refinement types right up a full proof language. This talk will use these features to show off the language's incredible power and control with non-trivial examples C interop, concurrency, and GC free low latency servers. No ATS experience is expected but the talk will move fast. Basic experience with C and a type system like Haskell's will be helpful.

Aditya Siram
COMCAST

I work as a Scala developer by day, but write Haskell, Shen, C, Rust and ATS by candlelight. My latest passion is languages like Rust and ATS that use sophisticated type systems that allow safe memory access and high level abstractions over unboxed data structures.

Our experiences at Sentry of marrying Rust and Python and why it’s a great match for many applications. We will go over a quick intro to Rust, how to translate common concepts from Python to it, and how to make extension modules in Rust.

Watch this presentation to learn about the recent updates on the state of WebAssembly and view a short demo of Rust programming language interacting with the land of browsers.

EVENT: CinciJS

SPEAKER: Chris Nelson

PERMISSIONS: The original video was published on the GaslightLive YouTube Channel with the Creative Commons Attribution license (reuse allowed).

ORIGINAL SOURCE: https://www.youtube.com/watch?v=gdTcKq3FJuI

The usage of Rust started as an experiment at Sentry but became a non negligible part of our infrastructure. This is lessons learned, what works and doesn't and what we think is going to happen in the future.

Join SuperChris as he updates us on the state of WebAssembly and gives a short demo of Rust interacting with the land of browsers.

Abstract
Rust is a new systems-programming language that is becoming increasingly popular. It aims to combine C++’s focus on zero-cost abstractions with numerous ideas that emerged first in academia, most notably affine and region types (“ownership and borrowing”) and Haskell’s type classes (“traits”). One of the key goals for Rust is that it does not require a garbage collector.

In this talk, I’ll give a brief overview of Rust’s key features, with a focus on the type system. I’ll talk about how we leverage a few core features to offer a variety of APIs – ranging from efficient collections to various styles of parallel programming – while still guaranteeing memory safety and data-race freedom.

Bio
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.

http://cppnow.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/boostcon/cppnow_presentations_2017
—
Through the concept of zero-cost abstractions, C++ has shown that it is possible to combine low-level control with high-level programming concepts. Rust is language that aims to offer the same sorts of zero-cost abstractions that C++ is capable of, while also enforcing memory safety and data-race freedom. The secret sauce is Rust's core notion of "ownership", which enables:

- Memory safety without garbage collection;
- Concurrency without data races,
- Abstraction without overhead.

In this talk, I'll explain ownership and show how Rust uses it to guarantee thread safety, amongst other things. I'll also talk about how Rust is designed to scale to large code-bases, sharing some of our experiences here at Mozilla from integrating Rust code into Firefox.

One final theme of the talk is that the benefits of ownership go beyond having fewer bugs: once you are freed from the need to prevent memory-safety violations, it becomes possible to write -- and **maintain** -- programs that aggressively pursue parallelization and other kinds of optimizations that would have been too risky or too difficult before.
—
Nicholas Matsakis is a senior researcher at Mozilla research and a member of the Rust core team. He has been working on Rust for nearly six years and did much of the initial work on its type system and other core features. Prior to working on Rust, he did his undergraduate studies at MIT and completed a PhD at ETH Zurich in 2011. He also spent several years at DataPower Technology, a startup since acquired by IBM, working on the JIT compiler and networking runtime.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com
---

*--*

---

https://github.com/Biacode/presentations/tree/master/rustlang

Elixir is a great choice for most applications. It's powered by the battle-tested Erlang VM know as the BEAM. It allows programmers to build incredibly fast, efficient, scalable, and fault-tolerant distributed systems.
As it turns out, Elixir isn't the fastest kid on the block. And while raw CPU speed matters little for most applications, there does exist a couple reasons you might want want to reach for tools that give you access to native power.

In this talk we're going to discuss Native Implemented Functions (NIFs) - Erlang's Foreign Function Interface (FFI).

NIFs are normally implemented in C and are considered dangerous. But we're going explore writing safer NIFs in Rust - a new systems programming language developed by Mozilla, that focuses on memory safety.

We'll talk about the pitfalls with writing NIFs and how Rust can make this process easier and safer.



NDC Conferences
https://ndc-london.com
https://ndcconferences.com

A quick introduction to the Rust Language. Code comparisons between Java and Rust, compiler features, type system, environment and integrating the two languages.

Topics

Brief History of Rust - how did the project get started, main goals, first stable releases.
Main types and Functions - writing a very basic code and a deep comparison between Java style and Rust style. The level of verbosity is similar; however, the way you explicit the types may be different.
Structs and Traits, contrasting them with Interfaces and Abstract Classes in Java.
Lifetime vs GC - how can we remove objects from the memory without a GC? An interesting alternative approach from Rust to Java's GC. We will show the good and the complicated parts.
Notes about the compiler

Hanneli Tavante
Hanneli is a software developer. With experience in Java, C++ and Ruby, she works mostly with backend development and project architecture. She contributes to some open source projects and organises Cassandra, Science and Rust meetups in Sao Paulo. She enjoys spreading the knowledge and learning new topics in conferences around the globe. She also likes coffee, GIFs, Lego and Mathematics.

http://www.lambdadays.org/lambdadays2017/tomasz-baranski

Rust is a systems programming language focused on safety, speed and concurrency. At the first glance Rust doesn't seem like a functional language. However, closer look reveals features like type inference, immutable data, traits that look a lot like type classes, algebraic data types, pattern matching.

During this presentation you will learn functional features of Rust and see some examples of how well-known functional patterns can be implemented in it. Prior knowledge of Rust is not required.

Rust: Removing the Sharp Edges from Systems Programming - Jonathan Creekmore, Star Lab

Systems programs are at the base of everything an embedded engineer works with, but manually managing memory safely can be difficult to get correct in traditional systems languages like C and C++. Rust gives a programmer a high-performance systems language that enforces data safety through its strong type system, eliminating memory corruption and data race issues at compile time. In this presentation, Jonathan Creekmore will give an overview of the Rust programming language and explain how systems programmers can use it to protect their programs from memory corruption and data races, leading to safer, more secure programs. Additionally, Jonathan will show how to use meta-rust to bring Rust programs into Yocto systems.

About Jonathan Creekmore
Twitter Tweet LinkedIn Connect Websitethecreekmores.org
Jonathan Creekmore has been an embedded systems and security software engineer for the last 16 years. Over the years, he has worked on routers, switches, and IoT sensor nodes, as well as a software protection product built on Linux. Since joining Star Lab, Jonathan has been contributing to the Xen hypervisor and writing security software utilities using Rust. Currently, Jonathan is one of the principal software engineers developing Crucible, a secure, authenticated boot solution for embedded virtualization.