Rust as a Lens

We have arrived at Rust, the third and final lens through which we are examining programming language concepts. Rust is relatively young. Its originator, Graydon Hoare, released its first prototype in 2006. Hoare's primary goals were to design a language that ensured memory safety and fast performance. At the time, Hoare was a software developer at Mozilla, the company that publishes the Firefox web browser. Mozilla invested heavily in Rust, hiring researchers and engineers who continued to develop the language and its ecosystem. The language has matured and been adopted by many companies seeking a language that is arguably safer than C++ and nearly as fast.

Hoare stepped down from his leadership role in 2013 after getting burnt out by work and crises in his personal life. By this point, Rust was being worked on by many different people, and his departure didn't derail its momentum. Hoare loudly rejected the idea that the language was solely his brainchild in a tweet:

PLEASE DESIST IN THINKING THINGS ARE MADE BY SINGLE PEOPLE IT IS A VERY UNHEALTHY MYTH

Later he joined the Swift development team at Apple. He explains his embrace of a completely different language in a Reddit post:

But: I don't think Rust is the last or only language that needs to exist. Indeed, I think there's quite a lot of work left to do on languages before anyone could credibly argue such things about any language. I've always been a language pluralist—picture my relationship towards languages like a kid enjoying a wide variety of building blocks, musical instruments or plastic dinosaurs—and I don't think evangelism or single-language puritanism is especially helpful.

Rust supports many of the features you have been learning about, including tuples, structs, enums, pattern matching, lambdas, and higher-order functions. In particular, you will recognize the strong influence of Haskell and its predecessors on Rust. But unlike Haskell, Rust tolerates mutability and side effects in a controlled manner.

In this chapter, we explore Rust's take on variables, types, functions, and control flow. All of these concepts we've already explored through the lens of Ruby and Haskell. By the chapter's end, you'll be able to answer the following questions:

• How are variables declared and how do Rust programmers think about scope, mutability, and sharing?
• What are the core primitive and composite types? What safety guarantees does the type system offer and what burdens does it place on developers?
• What control flow structures are available for choosing between or repeating code?
• How are subprograms defined and called, and how is data shared between caller and callee?

In later chapters, we'll explore Rust's polymorphism, unique approach to memory management, and builtin support for concurrency.