“Systems programming” is a category of programming that requires high speed, demanded by such applications as operating systems, network servers, and databases. For many years, and even today, C is the go-to programming language for such work — but over the years, a growing number of other languages have been joining this space, most notably C++, and more recently D, Go, and Rust. What do each of these languages have to offer, and what do the languages’ designers prioritize in their designs? This panel brings together Bjarne Stroustrup (C++), Rob Pike (Go), Andrei Alexandrescu (D), and Niko Matsakis (Rust) to discuss what they think about programming languages, language design, community, and future directions.
Rust is a new programming language, aimed at making systems programming reliable, even when dealing with concurrency. Rust, whose development is sponsored by the Mozilla foundation, is gaining many fans who have not previously worked with static, compiled languages. What is it like to work with Rust? And what does it offer that other languages can’t or don’t? In this talk, Alex Burkhart tries to answer these questions, including why the Rust community continues to grow, providing support to newcomers.
Rust is a new language for systems programming, which aims to be friendly to developers. But typically, a language that is friendly to developers can be hard to optimize. In this talk, Yehuda Katz discusses the Rust language, starting by focusing on a compiled extension that was written in Rust, and which required surprisingly little optimization to outperform C. How can this be, and what does it say about Rust? And how can it help us to understand the differences between dynamic and static languages?
Rust is a programming language from Mozilla Labs that has been getting a growing degree of attention. As Rust developer Alex Crichton describes in this talk, Rust aims to provide a systems language, similar to C or C++ in the degree of control that it gives programmers — while providing the reliability and safety of high-level languages such as Python, Ruby, and JavaScript. How does it aim to do this, and why are so many programmers interested in Rust? This talk describes the design goals of Rust, and the ways in which it tries to bridge the gap between control and safety, two goals that other languages would have us believe are mutually exclusive.
Rust and Ruby are both open-source languages. But that’s about all that they have in common. (Fine, and the letter “R.”) In this talk, Yehuda Katz and Tom Dale, two experienced Ruby developers who have done some work on Rust, describe how their understanding and use of Ruby improved as a result of working on Rust — a radically different language.
Type systems have long been used to enforce compile-time checks on data, to ensure greater program safety. But what happens when you have a distributed system? How easily can you define, and enforce, high-level abstractions and data types across multiple machines, processes, and languages? In this talk, David Renshaw describes Cap’n Proto, his system for describing such a type system. He also describes the type system in Rust, in which Cap’n Proto is implemented — and discusses how type systems can (and should) be used to encourage sharing of data, in a robust and predictable way.
I’m increasingly intrigued by the Rust language, and what is offers programmers. Steve Klabnik discusses what Rust brings to the table, and why programmers — including developers in such languages as Python and Ruby — should be excited about Rust.
Rust is a programming language that I am increasingly interested in learning and hearing about. This talk provides a good introduction, aimed at developers of Ruby and other dynamic languages.