This is a good article. Click here for more information.

Rust (programming language)

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search

Rust
A capitalised letter R set into a sprocket
The official Rust logo
ParadigmsMulti-paradigm: concurrent, functional, generic, imperative, structured
Designed byGraydon Hoare
First appearedJuly 7, 2010; 12 years ago (2010-07-07)
Stable release
1.64.0[1] Edit this on Wikidata / September 22, 2022; 9 days ago (September 22, 2022)
Typing disciplineAffine, inferred, nominal, static, strong
Implementation languageRust
PlatformCross-platform[2][note 1]
OSCross-platform[2][note 2]
LicenseMIT and Apache 2.0 (dual-licensed) [3]
Filename extensions.rs, .rlib
Websitewww.rust-lang.org
Influenced by
Influenced

Rust is a multi-paradigm, general-purpose programming language. Rust emphasizes performance, type safety, and concurrency.[9][10][11] Rust enforces memory safety—that is, that all references point to valid memory—without requiring the use of a garbage collector or reference counting present in other memory-safe languages.[11][12] To simultaneously enforce memory safety and prevent concurrent data races, Rust's borrow checker tracks the object lifetime and variable scope of all references in a program during compilation.[13] Rust is popular for systems programming[11] but also offers high-level features including functional programming constructs.[14]

Software developer Graydon Hoare designed Rust while working at Mozilla Research in 2006.[15] Mozilla officially sponsored the project in 2009, and the designers refined the language while writing the Servo experimental browser engine[16] and the Rust compiler. Rust's major influences include SML, OCaml, C++, Cyclone, Haskell, and Erlang.[4] Since the first stable release in January 2014, Rust has been adopted by companies including Amazon, Discord, Dropbox, Facebook (Meta), Google (Alphabet), and Microsoft.

Rust has been noted for its growth as a newer language[10][17] and has been the subject of academic programming languages research.[18][19][20][11]

History[edit]

Origins (2006–2012)[edit]

Mozilla Foundation headquarters in Mountain View, California

Rust grew out of a personal project begun in 2006 by Mozilla employee Graydon Hoare. Mozilla began sponsoring the project in 2009 and officially announced the project in 2010.[15][21] During the same year, work had shifted from the initial compiler written in OCaml to a self-hosting compiler based on LLVM written in Rust. The new Rust compiler, named rustc, successfully compiled itself in 2011. The first numbered pre-alpha version of the compiler, Rust 0.1, was released in January 2012.[22]

Evolution (2013–2019)[edit]

Rust's type system changed considerably between versions 0.2, 0.3, and 0.4. Version 0.2 introduced classes for the first time,[23] and version 0.3 added destructors and polymorphism through the use of interfaces.[24] In Rust 0.4, traits were added as a means to provide inheritance; interfaces were unified with traits and removed as a separate feature. Classes were also removed and replaced by a combination of implementations and structured types.[25] Along with conventional static typing, before version 0.4, Rust also supported typestate analysis through contracts. It was removed in release 0.4, though the same functionality can be achieved by leveraging Rust's type system.[26]

In January 2014, the editor-in-chief of Dr. Dobb's Journal, Andrew Binstock, commented on Rust's chances of becoming a competitor to C++ in addition to the languages D, Go, and Nim (then Nimrod). According to Binstock, while Rust was "widely viewed as a remarkably elegant language", adoption slowed because it repeatedly changed between versions.[27] The first stable release, Rust 1.0, was announced on May 15, 2015.[28][29]

Mozilla layoffs and Rust Foundation (2020–present)[edit]

In August 2020, Mozilla laid off 250 of its 1,000 employees worldwide as part of a corporate restructuring caused by the long-term impact of the COVID-19 pandemic.[30][31] The team behind Servo, a browser engine written in Rust, was completely disbanded. The event raised concerns about the future of Rust, as some members of the team were active contributors to Rust.[32] In the following week, the Rust Core Team acknowledged the severe impact of the layoffs and announced that plans for a Rust foundation were underway. The first goal of the foundation would be to take ownership of all trademarks and domain names, and take financial responsibility for their costs.[33]

On February 8, 2021, the formation of the Rust Foundation was announced by its five founding companies (AWS, Huawei, Google, Microsoft, and Mozilla).[34][35] In a blog post published on April 6, 2021, Google announced support for Rust within Android Open Source Project as an alternative to C/C++.[36][37]

On November 22, 2021, the Moderation team, responsible for enforcing community standards and the Code of Conduct, announced their resignation "in protest of the Core Team placing themselves unaccountable to anyone but themselves." Although no further comments regarding the reasons for the resignation has been provided in the announcements, one of the former members of the Moderation team commented on Reddit, stating that "[c]ommunication with Core has failed, there's no team above Core, so... it's up to the members of the Rust Project to organize themselves and decide what to do in term of follow-up."[38]

Syntax and semantics[edit]

Hello World program[edit]

Below is a "Hello, World!" program in Rust. The println! macro prints the message to standard output.[39]

fn main() {
    println!("Hello, World!");
}

Keywords and control flow[edit]

In Rust, blocks of code are delimited by curly brackets, and control flow is annotated with keywords such as if, else, while, and for.[40][41] Pattern matching is provided using the match keyword.[42] In the examples below, explanations are given in comments, which start with //.[43][41]

fn main() {
    let mut values = vec![1, 2, 3, 4];

    for value in &values {
        println!("value = {}", value);
    }

    if values.len() > 5 {
        println!("List is longer than five items");
    }

    // Pattern matching
    match values.len() {
        0 => println!("Empty"),
        1 => println!("One value"),
        2..=10 => println!("Between two and ten values"),
        11 => println!("Eleven values"),
        _ => println!("Many values"),
    };

    // while loop with predicate and pattern matching using let
    while let Some(value) = values.pop() {
        println!("value = {value}"); // using curly braces to format a local variable
    }
}

Expression blocks[edit]

Despite the syntactic resemblance to C and C++,[44][45] Rust's design was more significantly influenced by functional programming languages.[46] For example, nearly every part of a function body is an expression, even control flow operators.[41] The ordinary if expression also takes the place of C's ternary conditional. A function does not need to end with a return expression: if the semicolon is omitted, the value of the last expression in the function will be used as the return value,[47] as seen in the following recursive implementation of the factorial function:

fn factorial(i: u64) -> u64 {
    if i == 0 {
        1
    } else {
        i * factorial(i - 1)
    }
}

The following iterative implementation uses the ..= operator to create an inclusive range:

fn factorial(i: u64) -> u64 {
    (2..=i).product()
}

Types[edit]

Rust is strongly typed and statically typed, where all types of variables must be known during compilation, and assigning a value of a different type to a variable will result in a compilation error. The default integer type is i32, and the default floating point type is f64. The type of a literal is either specified as a suffix or inferred from the context.[48][41]

Summary of Rust's built-in types
Type Description Examples
bool Boolean value
  • true
  • false
u8 Unsigned 8-bit integer (a byte)
  • 1 (Inferred type)
  • 255u8 (Explicit type)
  • b'W' (ASCII encoded byte)
  • i8
  • i16
  • i32
  • i64
  • i128
Signed integers, up to 128 bits
  • 7i128 (Explicit type)
  • -42 (Inferred type)
  • u16
  • u32
  • u64
  • u128
Unsigned integers, up to 128 bits
  • 14u128 (Explicit type)
  • 0 (Inferred type)
  • usize
  • isize
Pointer-sized integers (size depends on platform)
  • 14usize (Explicit type)
  • -2isize (Explicit type)
  • 0 (Inferred type)
  • f32
  • f64
Floating-point numbers
  • -3f32 (Explicit type)
  • 2.0 (Inferred type)
char
&str Strings (static or immutable)
  • "Hello"
  • "3"
  • "😂😂😂"
[T; N] Static arrays (size known at compile-time)
  • [2, 4, 6]
  • [0; 100]
  • b"Hello"
[T] Static arrays (size not known at compile-time)
  • [1, 2, 3, 4, 5][..i]
  • "Hello, world!".as_bytes()
  • let v = vec![1, 2, 3]; v.as_slice()
  • (T1, T2)
  • (T1, T2, T3)
  • ...
Tuples
  • () (An empty tuple, the unit type in Rust)
  • (5,) (if this was (5), it would've been parsed as an integer)
  • ("Age", 10)
  • (1, true, "Name")
  • &T
  • &mut T
References (immutable and mutable)
  • let x_ref = &x;
  • let x_ref = &mut x;
  • *const T
  • *mut T
  • let x_ptr = &x as *const T;
  • let x_ptr = &mut x as *mut T;
! Never type (unreachable value) let x = { return 123 };

Unlike other languages, Rust does not use null pointers to indicate a lack of data, as doing so can lead to accidental dereferencing. Therefore, in order to uphold its safety guarantees, it is impossible to dereference null pointers unless the code block is manually checked and explicitly declared unsafe through the use of an unsafe block.[50] Rust instead uses an Option type, which has two variants, Some(T) (which indicates that a value is present) and None (analogous to the null pointer).[51] Option implements a "null pointer optimization" avoiding any overhead for types which cannot have a null value (references or the NonZero types for example). Option values must be handled using syntactic sugar such as the if let construction in order to access the inner value (in this case, a string):[52]

fn main() {
    let name: Option<String> = None;
    // If name was not None, it would print here.
    if let Some(name) = name {
        println!("{}", name);
    }
}
Summary of Rust's types in the standard library
Type Description Examples
Box A value in the heap Box::new(5)
String Strings (dynamic)
  • String::new()
  • String::from("Hello")
  • "😂😂😂".to_string()
Vec<T> Dynamic arrays
  • Vec::new()
  • vec![1, 2, 3, 4, 5]
Option<T> Option type
  • None
  • Some(3)
  • Some("hello")
  • Option<&T>
  • Option<&mut T>
  • None
  • let x_ref = Some(&x);
  • let x_ref = Some(&mut x);
Result<T, E> Error handling
  • Result::Ok(3)
  • Result::Err("something went wrong")

Generics[edit]

More advanced features in Rust include the use of generic functions to achieve type polymorphism.[53] The following is a Rust program to calculate the sum of two things, for which addition is implemented using a generic function:

use std::ops::Add;

// sum is a generic function with one type parameter, T
fn sum<T>(num1: T, num2: T) -> T
where   
    T: Add<Output = T>,  // T must implement the Add trait where addition returns another T
{
    num1 + num2  // num1 + num2 is syntactic sugar for num1.add(num2) provided by the Add trait
}

fn main() {
    let result1 = sum(10, 20);
    println!("Sum is: {}", result1); // Sum is: 30

    let result2 = sum(10.23, 20.45);
    println!("Sum is: {}", result2); // Sum is: 30.68
}

Generics in Rust use trait bounds for their generic parameters, which precisely define what is required of a type in order to be used with a given generic function. This allows generics in Rust to be type-checked at compile time, without having to know the exact types.[53]

Ownership and lifetimes[edit]

Rust uses an ownership system, where each value has a unique owner. Values are moved between different owners through assignment or passing a value as a function parameter. Functions taking ownership of a parameter are said to consume the value in question. Ownership in Rust is similar to move semantics in C++; unlike C++, however, Rust keeps track of moved values and all types are movable by default. This means that types in Rust do not have to implement an "empty" or "invalid" state (and corresponding runtime checks) to signify that a value has been moved out of, because using a moved value is a compile-time error in Rust:[54]

fn print_string(s: String) {
    println!("{}", s);
}

fn main() {
    let s = String::from("Hello, World");
    print_string(s);  // s consumed by print_string
    // s has been moved, so cannot be used any more
    // another print_string(s);  would result in a compile error
}

Lifetimes are a usually implicit part of all reference types in Rust. Each particular lifetime encompasses a set of locations in the code for which a variable is valid. The borrow checker in the Rust compiler uses lifetimes to ensure that the values pointed to by a reference remains valid. It also ensures that a mutable reference only exists if no immutable references exist at the same time.[53]

Rust defines the relationship between the lifetimes of the objects used and created by functions as part of their signature using lifetime parameters. In languages like C or C++ the information about which objects have to outlive others is informally specified in documentation or comments, if at all, and cannot be checked by the compiler.[53]

When a stack variable or temporary goes out of scope, it is dropped by running its destructor, which may be implicitly defined or a programmer-defined "drop" function. The latter can be used for design patterns akin to resource acquisition is initialization (RAII), in which resources, like file descriptors or network sockets, are tied to the lifetime of an object: When the object is dropped, the resource is closed.[55][56]

The example below parses some configuration options from a string and creates a struct containing the options. The struct only contains references to the data, so for the struct to remain valid, the data referred to by the struct needs to be valid as well. The function signature for "parse_config" specifies this relationship explicitly. In this example, the explicit lifetimes are unnecessary in newer Rust versions due to lifetime elision, which is an algorithm that automatically assigns lifetimes to functions if they are trivial.[53]

use std::collections::HashMap;

#[derive(Debug)]
// This struct has one lifetime parameter, 'src. The name is only used within the struct's definition.
struct Config<'src> {
    hostname: &'src str,
    username: &'src str,
}

// This function also has a lifetime parameter, 'cfg. 'cfg is attached to the "config" parameter, which
// establishes that the data in "config" lives at least as long as the 'cfg lifetime.
// The returned struct also uses 'cfg for it's lifetime, so it can live at most as long as 'cfg.
fn parse_config<'cfg>(config: &'cfg str) -> Config<'cfg> {
    let key_values: HashMap<_, _> = config
        .lines()
        .filter(|line| !line.starts_with('#'))
        .filter_map(|line| line.split_once('='))
        .map(|(key, value)| (key.trim(), value.trim()))
        .collect();
    Config {
        hostname: key_values["hostname"],
        username: key_values["username"],
    }
}

fn main() {
    let config = parse_config(
        r#"hostname = foobar
username=barfoo"#,
    );
    println!("Parsed config: {:#?}", config);
}

Features[edit]

A presentation on Rust by Emily Dunham from Mozilla's Rust team (linux.conf.au conference, Hobart, 2017)

Rust aims to support concurrent systems programming, which has inspired a feature set with an emphasis on safety, control of memory layout, and concurrency.[57]

Memory safety[edit]

Rust is designed to be memory safe. It does not permit null pointers, dangling pointers, or data races.[58][59][60] Data values can be initialized only through a fixed set of forms, all of which require their inputs to be already initialized.[61] To replicate pointers being either valid or NULL, such as in linked list or binary tree data structures, the Rust core library provides an option type, which can be used to test whether a pointer has Some value or None.[59] Rust has added syntax to manage lifetimes, which are checked at compile time by the borrow checker. Unsafe code can subvert some of these restrictions using the unsafe keyword.[50] Unsafe code may also used for low-level functionality like volatile memory access, architecture-specific intrinsics, type punning, and inline assembly.[52]: 139,376–379,395 

Memory management[edit]

Rust does not use automated garbage collection. Memory and other resources are managed through the resource acquisition is initialization convention,[62] with optional reference counting. Rust provides deterministic management of resources, with very low overhead.[63] Values are allocated on the stack by default and all dynamic allocations must be explicit.[64]

The built-in reference types using the & symbol do not involve run-time reference counting. The safety and validity of the underlying pointers is verified at compile time, preventing dangling pointers and other forms of undefined behavior. Rust's type system separates shared, immutable references of the form &T from unique, mutable references of the form &mut T. A mutable reference can be coerced to an immutable reference, but not vice versa.[54][65]

Types and polymorphism[edit]

Rust's type system supports a mechanism called traits, inspired by type classes in the Haskell language. Traits annotate types and are used to define shared behavior between different types. For example, floats and integers both implement the Add trait because they can both be added; and any type that can be printed out as a string implements the Display or Debug traits. This facility is known as ad hoc polymorphism.[53]

Rust uses type inference for variables declared with the keyword let. Such variables do not require a value to be initially assigned to determine their type. A compile time error results if any branch of code leaves the variable without an assignment.[66] Variables assigned multiple times must be marked with the keyword mut (short for mutable).[41]

A function can be given generic parameters, which allows the same function to be applied to different types. Generic functions can constrain the generic type to implement a particular trait or traits; for example, an "add one" function might require the type to implement "Add". This means that a generic function can be type-checked as soon as it is defined. The implementation of Rust generics is similar to the typical implementation of C++ templates: a separate copy of the code is generated for each instantiation. This is called monomorphization and contrasts with the type erasure scheme typically used in Java and Haskell. Rust's type erasure is also available by using the keyword dyn (short for dynamic) .The benefit of monomorphization is optimized code for each specific use case; the drawback is increased compile time and size of the resulting binaries.[53]

In Rust, user-defined types are created with the struct or enum keywords. The struct keyword denotes a record type.[67] enums are kinds of algebraic data types commonly found in functional programming languages. These types can contain fields of other types.[51] The impl keyword can define methods for the types (data and functions are defined separately) or implement a trait for the types.[67] Traits are used to restrict generic parameters and because traits can provide a type with more methods than the user defined. For example, the trait Iterator requires that the next method be defined for the type. Once the next method is defined the trait provides common functional helper methods over the iterator like map or filter.[53]

Type aliases, including generic arguments, can also be defined with the type keyword.[50]

The type system within Rust is based around implementations, traits and structured types. Implementations fulfill a role similar to that of classes within other languages and are defined with the keyword impl. Traits provide inheritance and polymorphism; they allow methods to be defined and mixed in to implementations. Structured types are used to define fields. Implementations and traits cannot define fields themselves, and only traits can provide inheritance. Among other benefits, this prevents the diamond problem of multiple inheritance, as in C++. In other words, Rust supports interface inheritance but replaces implementation inheritance with composition; see composition over inheritance.[67][53]

Trait objects[edit]

Rust traits are implemented using static dispatch, meaning that the type of all values is known at compile time; however, Rust also uses a feature known as trait objects to accomplish dynamic dispatch (also known as duck typing).[68] Dynamically dispatched trait objects are declared using the syntax Box<dyn Tr> where Tr is a trait. For example, it is possible to create a list of objects which each can be printed out as follows: let v: Vec<Box<dyn Display>> = vec![Box::new(3), Box::new(5.0), Box::new("hi")].[68] Trait objects are dynamically sized; however, prior to 2015, the dyn keyword was optional.[69] A trait object is essentially a fat pointer that include a pointer as well as additional information about what type the pointer is.[70]

Macros[edit]

It is possible to extend the Rust language using macros.

Declarative macros[edit]

Declarative macros (also called "macros by example") are macros that uses pattern matching to determine its expansion.[50]

Procedural macros[edit]

Procedural macros use Rust functions that are compiled before other components to run and modify the compiler's input token stream. They are generally more flexible than declarative macros, but are more difficult to maintain due to their complexity.[71][50]

Procedural macros come in three flavors:

  • Function-like macros custom!(...)
  • Derive macros #[derive(CustomDerive)]
  • Attribute macros #[custom_attribute]

The println! macro is an example of a function-like macro and serde_derive[72] is a commonly used library for generating code for reading and writing data in many formats such as JSON. Attribute macros are commonly used for language bindings such as the extendr library for Rust bindings to R.[73]

The following code shows the use of the Serialize, Deserialize and Debug derive procedural macros to implement JSON reading and writing as well as the ability to format a structure for debugging.

use serde_json::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 1, y: 2 };

    let serialized = serde_json::to_string(&point).unwrap();
    println!("serialized = {}", serialized);

    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
    println!("deserialized = {:?}", deserialized);
}

Interface with C and C++[edit]

Rust has a foreign function interface (FFI) that can be used both to call code written in languages such as C from Rust and to call Rust code from those languages. Rust also has a library, CXX, for calling to or from C++.[74] Rust and C differ in how they lay out structs in memory, so Rust structs may be given a #[repr(C)] attribute, forcing the same layout as the equivalent C struct.[75]

Components[edit]

Compiling a Rust program with Cargo

Besides the compiler and standard library, the Rust ecosystem includes additional components for software development. Component installation is typically managed by rustup, a Rust toolchain installer developed by the Rust project.[76]

Standard library[edit]

The Rust standard library is split into three crates: core, alloc, and std. When a project is annotated with the crate-level attribute #![no_std], the std crate is excluded.[77]

Cargo[edit]

Screenshot of crates.io in June 2022

Cargo is Rust's build system and package manager. Cargo downloads, compiles, distributes, and uploads packages, called crates, maintained in the official registry. Cargo also acts as a front-end for Clippy and other Rust components.[10]

By default, Cargo sources its dependencies from the user-contributed registry crates.io, but Git repositories and crates in the local filesystem and other external sources can be specified as dependencies, too.[78]

Rustfmt[edit]

Rustfmt is a code formatter for Rust. It takes Rust source code as input and changes the whitespace and indentation to produce code formatted in accordance to a common style unless specified otherwise. Rustfmt can be invoked as a standalone program or on a Rust project through Cargo.[79]

Clippy[edit]

Example output of Clippy on a hello world Rust program

Clippy is Rust's built-in linting tool to improve the correctness, performance, and readability of Rust code. It was created in 2014[80] and named after the eponymous Microsoft Office feature.[81] As of 2021, Clippy has more than 450 rules,[82] which can be browsed online and filtered by category.[83][79]

Versioning system[edit]

Following Rust 1.0, new features are developed in nightly versions which release on a daily basis. During each release cycle of six weeks, changes on nightly versions are released to beta, while changes from the previous beta version are released to a new stable version.[84]

Every three years, a new "edition" is produced. Editions are released to provide an easy reference point for changes due to the frequent nature of Rust's train release schedule, and to provide a window to make limited breaking changes. Editions are largely compatible and migration to a new edition is trivialized with automated tooling.[85]

IDE support[edit]

The most popular language server for Rust is rust-analyzer.[79] The original language server, RLS was officially deprecated in favor of rust-analyzer in July 2022.[86] These projects provide IDEs and text editors with more information about a Rust project, with basic features including autocompletion, and display of compilation errors while editing.[79]

Performance[edit]

Rust aims "to be as efficient and portable as idiomatic C++, without sacrificing safety".[87] Rust does not perform garbage collection, which allows it to be more efficient and performant than other memory-safe languages.[88]

Rust provides two "modes": safe and unsafe. The safe mode is the "normal" one, in which most Rust is written. In unsafe mode, the developer is responsible for the correctness of the code, making it possible to create applications which require low-level features.[89] It has been demonstrated empirically that unsafe Rust is not always more performant than safe Rust, and can even be slower in some cases.[90]

Many of Rust's features are so-called zero-cost abstractions, meaning they are optimized away at compile time and incur no runtime penalty.[52]: 19,27  Since Rust utilizes LLVM, any performance improvements in LLVM also carry over to Rust.[91] Unlike C and C++, Rust allows re-organizing struct and enum element ordering.[92] This can be done to reduce the size of structures in memory, for better memory alignment, and to improve cache access efficiency.[93]

Adoption[edit]

According to the Stack Overflow Developer Survey in 2022, 9% of respondents have recently done extensive development in Rust.[94] The survey has additionally named Rust the "most loved programming language" every year from 2016 to 2022 (inclusive), a ranking based on the number of current developers who express an interest in continuing to work in the same language.[95][note 4] In 2022, Rust tied with Python for "most wanted technology" with 18% of developers not currently working in Rust expressing an interest in doing so.[94][96]

Rust has been adopted for components at a number of major software companies, including Amazon,[97][98] Discord,[99] Dropbox,[100] Facebook (Meta),[101] Google (Alphabet),[102][36] and Microsoft.[103][104]

Web browsers and services[edit]

Early homepage of Mozilla's Servo browser engine

Operating systems[edit]

exa, a command-line alternative to ls, written in Rust
  • Redox is a "full-blown Unix-like operating system" including a microkernel written in Rust.[115]
  • Theseus, an experimental operating system described as having "intralingual design": leveraging Rust's programming language mechanisms for implementing the OS.[116]
  • The Google Fuchsia capability-based operating system has components written in Rust,[117] including a TCP/IP library. [118]
  • Stratis is a file system manager written in Rust for Fedora[119] and RHEL.[120]
  • exa is a Unix/Linux command line alternative to ls written in Rust.
  • Rust for Linux is a patch series started in 2021 for adding Rust support to the Linux kernel.[121]

Other notable projects and platforms[edit]

Ruffle, a web emulator for Adobe Flash SWF files

Community[edit]

A bright orange crab icon
Some Rust users refer to themselves as Rustaceans (a pun on crustacean) and adopt an orange crab, Ferris, as their unofficial mascot.[127]

Conferences[edit]

Rust's official website lists online forums, messaging platforms, and in-person meetups for the Rust community.[128] Conferences dedicated to Rust development include:

Rust Foundation[edit]

Rust Foundation
FormationFebruary 8, 2021; 19 months ago (2021-02-08)
Founders
TypeNonprofit organization
Location
Shane Miller
Rebecca Rumbul
Websitefoundation.rust-lang.org

The Rust Foundation is a non-profit membership organization incorporated in United States, with the primary purposes of backing the technical project as a legal entity and helping to manage the trademark and infrastructure assets.[135][45]

It was established on February 8, 2021, with five founding corporate members (Amazon Web Services, Huawei, Google, Microsoft, and Mozilla).[136] The foundation's board is chaired by Shane Miller.[137] Starting in late 2021, its Executive Director and CEO is Rebecca Rumbul.[138] Prior to this, Ashley Williams was interim executive director.[139]

Governance teams[edit]

The Rust project is composed of teams that are responsible for different subareas of the development. For example, the Core team is responsible for "Managing the overall direction of Rust, subteam leadership, and any cross-cutting issues," the Compiler team is responsible for "Developing and managing compiler internals and optimizations," and the Language team is responsible for "Designing and helping to implement new language features," according to the official website.[140][141]

See also[edit]

Notes[edit]

  1. ^ Including build tools, host tools, and standard library support for x86-64, ARM, MIPS, RISC-V, WebAssembly, i686, AArch64, PowerPC, and s390x.[2]
  2. ^ Including Windows, Linux, macOS, FreeBSD, NetBSD, and Illumos. Host build tools on Android, iOS, Haiku, Redox, and Fuchsia are not officially shipped; these operating systems are supported as targets.[2]
  3. ^ For a complete list, see[4]
  4. ^ That is, among respondents who have done "extensive development work [with Rust] in over the past year" (9.3%), Rust had the largest percentage who also expressed interest to "work in [Rust] over the next year" (87%).[94]

References[edit]

  1. ^ "Announcing Rust 1.64.0".
  2. ^ a b c d "Platform Support". The rustc book. Retrieved 2022-06-27.
  3. ^ a b c "Appendix: Influences". The Rust Reference. Archived from the original on 2019-01-26. Retrieved 2018-11-11.
  4. ^ "Uniqueness Types". Idris 1.3.3 documentation. Retrieved 2022-07-14. They are inspired by ... ownership types and borrowed pointers in the Rust programming language.
  5. ^ Jaloyan, Georges-Axel (2017-10-19). "Safe Pointers in SPARK 2014". arXiv:1710.07047 [cs.PL].
  6. ^ Lattner, Chris. "Chris Lattner's Homepage". Nondot.org. Archived from the original on 2018-12-25. Retrieved 2019-05-14.
  7. ^ "Microsoft opens up Rust-inspired Project Verona programming language on GitHub". ZDNet. Archived from the original on 2020-01-17. Retrieved 2020-01-17.
  8. ^ Quentin, Ochem. "Rust and SPARK: Software Reliability for Everyone". Electronic Design. Retrieved 2022-06-22.
  9. ^ a b c Perkel, Jeffrey M. (2020-12-01). "Why scientists are turning to Rust". Nature. 588 (7836): 185–186. Bibcode:2020Natur.588..185P. doi:10.1038/d41586-020-03382-2. PMID 33262490. S2CID 227251258. Archived from the original on 2022-05-06. Retrieved 2022-05-15.
  10. ^ a b c d Balasubramanian, Abhiram; Baranowski, Marek S.; Burtsev, Anton; Panda, Aurojit; Rakamarić, Zvonimir; Ryzhyk, Leonid (2017-05-07). "System Programming in Rust: Beyond Safety". Proceedings of the 16th Workshop on Hot Topics in Operating Systems. HotOS '17. New York, NY, USA: Association for Computing Machinery: 156–161. doi:10.1145/3102980.3103006. ISBN 978-1-4503-5068-6. S2CID 24100599. Archived from the original on 2022-06-11. Retrieved 2022-06-01.
  11. ^ Yegulalp, Serdar (2021-10-06). "What is the Rust language? Safe, fast, and easy software development". InfoWorld. Retrieved 2022-06-25.
  12. ^ Shamrell-Harrington, Nell. "The Rust Borrow Checker – a Deep Dive". InfoQ. Retrieved 2022-06-25.
  13. ^ Blanco-Cuaresma, Sergi; Bolmont, Emeline (2017-05-30). "What can the programming language Rust do for astrophysics?". Proceedings of the International Astronomical Union. 12 (S325): 341–344. arXiv:1702.02951. Bibcode:2017IAUS..325..341B. doi:10.1017/S1743921316013168. ISSN 1743-9213. S2CID 7857871.
  14. ^ a b Asay, Matt (2021-04-12). "Rust, not Firefox, is Mozilla's greatest industry contribution". TechRepublic. Retrieved 2022-07-07.
  15. ^ Bright, Peter (2013-04-03). "Samsung teams up with Mozilla to build browser engine for multicore machines". Ars Technica. Archived from the original on 2016-12-16. Retrieved 2013-04-04.
  16. ^ "Rust | TIOBE - The Software Quality Company". www.tiobe.com. Archived from the original on 2022-03-03. Retrieved 2022-05-15.
  17. ^ "Computer Scientist proves safety claims of the programming language Rust". EurekAlert!. Archived from the original on 2022-02-24. Retrieved 2022-05-15.
  18. ^ Jung, Ralf; Jourdan, Jacques-Henri; Krebbers, Robbert; Dreyer, Derek (2017-12-27). "RustBelt: securing the foundations of the Rust programming language". Proceedings of the ACM on Programming Languages. 2 (POPL): 66:1–66:34. doi:10.1145/3158154. S2CID 215791659. Archived from the original on 2022-06-11. Retrieved 2022-05-15.
  19. ^ Jung, Ralf (2020). Understanding and evolving the Rust programming language (PhD thesis). Saarland University. doi:10.22028/D291-31946. Archived from the original on 2022-03-08. Retrieved 2022-05-15.
  20. ^ Hoare, Graydon (2010-07-07). Project Servo (PDF). Mozilla Annual Summit 2010. Whistler, Canada. Archived (PDF) from the original on 2017-07-11. Retrieved 2017-02-22.
  21. ^ Brian, Anderson (2012-01-20). "[rust-dev] The Rust compiler 0.1 is unleashed". Archived from the original on 2014-09-05. Retrieved 2022-05-18.
  22. ^ Hoare, Graydon (2012-03-29). "[rust-dev] Rust 0.2 released". mail.mozilla.org. Retrieved 2022-06-12.
  23. ^ Hoare, Graydon (2012-07-12). "[rust-dev] Rust 0.3 released". mail.mozilla.org. Retrieved 2022-06-12.
  24. ^ Hoare, Graydon. "[rust-dev] Rust 0.4 released". mail.mozilla.org. Archived from the original on 2021-10-31. Retrieved 2021-10-31.
  25. ^ Duarte, José; Ravara, António (2021-09-27), "Retrofitting Typestates into Rust", 25th Brazilian Symposium on Programming Languages, New York, NY, USA: Association for Computing Machinery, pp. 83–91, doi:10.1145/3475061.3475082, ISBN 978-1-4503-9062-0, S2CID 238359093, retrieved 2022-07-12
  26. ^ Binstock, Andrew. "The Rise And Fall of Languages in 2013". Dr Dobb's. Archived from the original on 2016-08-07. Retrieved 2015-12-11.
  27. ^ "Version History". GitHub. Archived from the original on 2015-05-15. Retrieved 2017-01-01.
  28. ^ The Rust Core Team (2015-05-15). "Announcing Rust 1.0". Rust Blog. Archived from the original on 2015-05-15. Retrieved 2015-12-11.
  29. ^ Cimpanu, Catalin (2020-08-11). "Mozilla lays off 250 employees while it refocuses on commercial products". ZDNet. Archived from the original on 2022-03-18. Retrieved 2020-12-02.
  30. ^ Cooper, Daniel (2020-08-11). "Mozilla lays off 250 employees due to the pandemic". Engadget. Archived from the original on 2020-12-13. Retrieved 2020-12-02.
  31. ^ Tung, Liam. "Programming language Rust: Mozilla job cuts have hit us badly but here's how we'll survive". ZDNet. Archived from the original on 2022-04-21. Retrieved 2022-04-21.
  32. ^ "Laying the foundation for Rust's future". Rust Blog. 2020-08-18. Archived from the original on 2020-12-02. Retrieved 2020-12-02.
  33. ^ "Hello World!". Rust Foundation. 2020-02-08. Archived from the original on 2022-04-19. Retrieved 2022-06-04.
  34. ^ "Mozilla Welcomes the Rust Foundation". Mozilla Blog. 2021-02-09. Archived from the original on 2021-02-08. Retrieved 2021-02-09.
  35. ^ a b "Rust in the Android platform". Google Online Security Blog. Archived from the original on 2022-04-03. Retrieved 2022-04-21.
  36. ^ Amadeo, Ron (2021-04-07). "Google is now writing low-level Android code in Rust". Ars Technica. Archived from the original on 2021-04-08. Retrieved 2021-04-08.
  37. ^ Anderson, Tim (2021-11-23). "Entire Rust moderation team resigns". The Register. Retrieved 2022-08-04.
  38. ^ Klabnik, Steve; Nichols, Carol (2019-08-12). "Chapter 1: Getting Started". The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
  39. ^ "Control Flow". The Rust Programming Language. Retrieved 2022-07-14.
  40. ^ a b c d e f Klabnik, Steve; Nichols, Carol (2019-08-12). "Chapter 3: Common Programming Concepts". The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
  41. ^ "The match Control Flow Construct". The Rust Programming Language. Retrieved 2022-07-14.
  42. ^ "Comments". The Rust Programming Language. Retrieved 2022-07-14.
  43. ^ Proven, Liam (2019-11-27). "Rebecca Rumbul named new CEO of The Rust Foundation". www.theregister.com. Retrieved 2022-07-14. Both are curly bracket languages, with C-like syntax that makes them unintimidating for C programmers.
  44. ^ a b Brandon Vigliarolo (2021-02-10). "The Rust programming language now has its own independent foundation". TechRepublic. Retrieved 2022-07-14.
  45. ^ Klabnik, Steve; Nichols, Carol (2019-08-12). "Chapter 13: Functional Language Features: Iterators and Closures". The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
  46. ^ Tyson, Matthew (2022-03-03). "Rust programming for Java developers". InfoWorld. Retrieved 2022-07-14.
  47. ^ "Data Types". The Rust Programming Language. Retrieved 2022-07-14.
  48. ^ "Textual types". The Rust Reference. Retrieved 2022-06-12.
  49. ^ a b c d e Klabnik, Steve; Nichols, Carol (2019-08-12). "Chapter 19: Advanced Features". The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
  50. ^ a b Klabnik, Steve; Nichols, Carol (2019-08-12). "Chapter 6: Enums and Pattern Matching". The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
  51. ^ a b c McNamara, Tim (2021-08-10). Rust in Action. an O'Reilly Media Company Safari (1st ed.). ISBN 9781617294556. OCLC 1268279410.
  52. ^ a b c d e f g h i Klabnik, Steve; Nichols, Carol (2019-08-12). "Chapter 10: Generic Types, Traits, and Lifetimes". The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
  53. ^ a b Klabnik, Steve; Nichols, Carol (2019-08-12). "Chapter 4: Understanding Ownership". The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
  54. ^ "Drop in std::ops – Rust". doc.rust-lang.org. Retrieved 2022-07-16.
  55. ^ Gomez, Guillaume; Boucher, Antoni (2018). "RAII". Rust programming by example (First ed.). Birmingham, UK. p. 358. ISBN 9781788390637.
  56. ^ Avram, Abel (2012-08-03). "Interview on Rust, a Systems Programming Language Developed by Mozilla". InfoQ. Archived from the original on 2013-07-24. Retrieved 2013-08-17.
  57. ^ Rosenblatt, Seth (2013-04-03). "Samsung joins Mozilla's quest for Rust". CNET. Archived from the original on 2013-04-04. Retrieved 2013-04-05.
  58. ^ a b Brown, Neil (2013-04-17). "A taste of Rust". Archived from the original on 2013-04-26. Retrieved 2013-04-25.
  59. ^ "Races – The Rustonomicon". doc.rust-lang.org. Archived from the original on 2017-07-10. Retrieved 2017-07-03.
  60. ^ "The Rust Language FAQ". static.rust-lang.org. 2015. Archived from the original on 2015-04-20. Retrieved 2017-04-24.
  61. ^ "RAII – Rust By Example". doc.rust-lang.org. Archived from the original on 2019-04-21. Retrieved 2020-11-22.
  62. ^ "Abstraction without overhead: traits in Rust". Rust Blog. Archived from the original on 2021-09-23. Retrieved 2021-10-19.
  63. ^ "Box, stack and heap". Rust By Example. Retrieved 2022-06-13.
  64. ^ Klabnik, Steve; Nichols, Carol (2019-08-12). "Chapter 15: Smart Pointers". The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
  65. ^ Walton, Patrick (2010-10-01). "Rust Features I: Type Inference". Archived from the original on 2011-07-08. Retrieved 2011-01-21.
  66. ^ a b c Klabnik, Steve; Nichols, Carol (2019-08-12). "Chapter 5: Using Structs to Structure Related Data". The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
  67. ^ a b "Using Trait Objects That Allow for Values of Different Types – The Rust Programming Language". doc.rust-lang.org. Retrieved 2022-07-11.
  68. ^ "Trait object types – The Rust Reference". doc.rust-lang.org. Retrieved 2022-07-11.
  69. ^ VanHattum, Alexa; Schwartz-Narbonne, Daniel; Chong, Nathan; Sampson, Adrian (2022). "Verifying Dynamic Trait Objects in Rust". 2022 IEEE/ACM 44th International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP). Section 2 (pp. 322–324). doi:10.1109/ICSE-SEIP55303.2022.9794041. ISBN 978-1-6654-9590-5. S2CID 247148388.
  70. ^ "Procedural Macros". The Rust Programming Language Reference. Archived from the original on 2020-11-07. Retrieved 2021-03-23.
  71. ^ "Serde Derive". Serde Derive documentation. Archived from the original on 2021-04-17. Retrieved 2021-03-23.
  72. ^ "extendr_api – Rust". Extendr Api Documentation. Archived from the original on 2021-05-25. Retrieved 2021-03-23.
  73. ^ "Safe Interoperability between Rust and C++ with CXX". InfoQ. 2020-12-06. Archived from the original on 2021-01-22. Retrieved 2021-01-03.
  74. ^ "Type layout – The Rust Reference". doc.rust-lang.org. Retrieved 2022-07-15.
  75. ^ 樽井, 秀人 (2022-07-13). "「Rust」言語のインストーラー「Rustup」が「Visual Studio 2022」の自動導入に対応/Windows/Mac/Linux、どのプラットフォームでも共通の手順でお手軽セットアップ". 窓の杜 (in Japanese). Retrieved 2022-07-14.
  76. ^ Gjengset, Jon (2021). Rust for Rustaceans. an O'Reilly Media Company Safari (1st ed.). pp. 212–213. ISBN 9781718501850. OCLC 1277511986.
  77. ^ Simone, Sergio De (2019-04-18). "Rust 1.34 Introduces Alternative Registries for Non-Public Crates". InfoQ. Retrieved 2022-07-14.
  78. ^ a b c d Klabnik, Steve; Nichols, Carol (2019-08-12). "Appendix D - Useful Development Tools". The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
  79. ^ "Create README.md · rust-lang/rust-clippy@507dc2b". GitHub. Archived from the original on 2021-11-22. Retrieved 2021-11-22.
  80. ^ "Day 1 – cargo subcommands | 24 days of Rust". zsiciarz.github.io. Archived from the original on 2022-04-07. Retrieved 2021-11-22.
  81. ^ "rust-lang/rust-clippy". GitHub. Archived from the original on 2021-05-23. Retrieved 2021-05-21.
  82. ^ "ALL the Clippy Lints". Archived from the original on 2021-05-22. Retrieved 2021-05-22.
  83. ^ Klabnik, Steve; Nichols, Carol (2019-08-12). "Appendix G - How Rust is Made and "Nightly Rust"". The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
  84. ^ Klabnik, Steve; Nichols, Carol (2019-08-12). "Appendix E - Editions". The Rust Programming Language (Covers Rust 2018). No Starch Press. ISBN 978-1-7185-0044-0.
  85. ^ Anderson, Tim (2022-07-05). "Rust team releases 1.62, sets end date for deprecated language server". DEVCLASS. Retrieved 2022-07-14.
  86. ^ Walton, Patrick (2010-12-05). "C++ Design Goals in the Context of Rust". Archived from the original on 2010-12-09. Retrieved 2011-01-21.
  87. ^ Anderson, Tim. "Can Rust save the planet? Why, and why not". The Register. Retrieved 2022-07-11.
  88. ^ "Rust projects – why large IT companies use Rust?". 2022-04-11.{{cite web}}: CS1 maint: url-status (link)
  89. ^ Popescu, Natalie; Xu, Ziyang; Apostolakis, Sotiris; August, David I.; Levy, Amit (2021-10-15). "Safer at any speed: automatic context-aware safety enhancement for Rust". Proceedings of the ACM on Programming Languages. 5 (OOPSLA). Section 2. doi:10.1145/3485480. S2CID 238212612. p. 5: We observe a large variance in the overheads of checked indexing: 23.6% of benchmarks do report significant performance hits from checked indexing, but 64.5% report little-to-no impact and, surprisingly, 11.8% report improved performance ... Ultimately, while unchecked indexing can improve performance, most of the time it does not.
  90. ^ "How Fast Is Rust?". The Rust Programming Language FAQ. Archived from the original on 2020-10-28. Retrieved 2019-04-11.
  91. ^ Farshin, Alireza; Barbette, Tom; Roozbeh, Amir; Maguire Jr, Gerald Q.; Kostić, Dejan (2021). PacketMill: toward per-Core 100-Gbps networking. ACM Conferences. pp. 1–17. doi:10.1145/3445814.3446724. ISBN 9781450383172. S2CID 231949599. Retrieved 2022-07-12. ... While some compilers (e.g., Rust) support structure reordering [82], C & C++ compilers are forbidden to reorder data structures (e.g., struct or class) [74] ...
  92. ^ "Type layout". The Rust Reference. Retrieved 2022-07-14.
  93. ^ a b c "Stack Overflow Developer Survey 2022". Stack Overflow. Retrieved 2022-06-22.
  94. ^ Claburn, Thomas (2022-06-23). "Linus Torvalds says Rust is coming to the Linux kernel". The Register. Retrieved 2022-07-15.
  95. ^ Wachtel, Jessica (2022-06-27). "Stack Overflow: Rust Remains Most Loved, but Clojure Pays the Best". The New Stack. Retrieved 2022-07-14.
  96. ^ "Why AWS loves Rust, and how we'd like to help". Amazon Web Services. 2020-11-24. Archived from the original on 2020-12-03. Retrieved 2022-04-21.
  97. ^ "How our AWS Rust team will contribute to Rust's future successes". Amazon Web Services. 2021-03-03. Archived from the original on 2022-01-02. Retrieved 2022-01-02.
  98. ^ a b Howarth, Jesse (2020-02-04). "Why Discord is switching from Go to Rust". Archived from the original on 2020-06-30. Retrieved 2020-04-14.
  99. ^ The Dropbox Capture Team. "Why we built a custom Rust library for Capture". Dropbox.Tech. Archived from the original on 2022-04-06. Retrieved 2022-04-21.
  100. ^ "A brief history of Rust at Facebook". Engineering at Meta. 2021-04-29. Archived from the original on 2022-01-19. Retrieved 2022-04-21.
  101. ^ Amadeo, Ron (2021-04-07). "Google is now writing low-level Android code in Rust". Ars Technica. Archived from the original on 2021-04-08. Retrieved 2022-04-21.
  102. ^ "Why Rust for safe systems programming". Microsoft Security Response Center. Archived from the original on 2019-07-22. Retrieved 2022-04-21.
  103. ^ Tung, Liam. "Microsoft: Why we used programming language Rust over Go for WebAssembly on Kubernetes app". ZDNet. Archived from the original on 2022-04-21. Retrieved 2022-04-21.
  104. ^ Yegulalp, Serdar (2015-04-03). "Mozilla's Rust-based Servo browser engine inches forward". InfoWorld. Archived from the original on 2016-03-16. Retrieved 2016-03-15.
  105. ^ Lardinois, Frederic (2015-04-03). "Mozilla And Samsung Team Up To Develop Servo, Mozilla's Next-Gen Browser Engine For Multicore Processors". TechCrunch. Archived from the original on 2016-09-10. Retrieved 2017-06-25.
  106. ^ Nichols, Shaun (2017-09-26). "Mozilla whips out Rusty new Firefox Quantum (and that's a good thing)". www.theregister.com. Retrieved 2022-07-14.
  107. ^ Shankland, Stephen (2016-07-12). "Firefox will get overhaul in bid to get you interested again". CNET. Retrieved 2022-07-14.
  108. ^ Hu, Vivian (2020-06-12). "Deno Is Ready for Production". InfoQ. Retrieved 2022-07-14.
  109. ^ "Firecracker – Lightweight Virtualization for Serverless Computing". Amazon Web Services. 2018-11-26. Archived from the original on 2021-12-08. Retrieved 2022-01-02.
  110. ^ "Announcing the General Availability of Bottlerocket, an open source Linux distribution built to run containers". Amazon Web Services. 2020-08-31. Archived from the original on 2022-01-02. Retrieved 2022-01-02.
  111. ^ "How we made Firewall Rules". The Cloudflare Blog. 2019-03-04. Retrieved 2022-06-11.
  112. ^ "Enjoy a slice of QUIC, and Rust!". The Cloudflare Blog. 2019-01-22. Retrieved 2022-06-11.
  113. ^ "Arti 1.0.0 is released: Our Rust Tor implementation is ready for production use".
  114. ^ Yegulalp, Serdar. "Rust's Redox OS could show Linux a few new tricks". infoworld. Archived from the original on 2016-03-21. Retrieved 2016-03-21.
  115. ^ Anderson, Tim (2021-01-14). "Another Rust-y OS: Theseus joins Redox in pursuit of safer, more resilient systems". www.theregister.com. Retrieved 2022-07-14.
  116. ^ "Google Fushcia's source code". Google Git. Archived from the original on 2021-07-09. Retrieved 2021-07-02.
  117. ^ "src/connectivity/network/netstack3/core/src – fuchsia". Google Git. Archived from the original on 2022-06-11. Retrieved 2022-04-21.
  118. ^ Sei, Mark (2018-10-10). "Fedora 29 new features: Startis now officially in Fedora". Marksei, Weekly sysadmin pills. Archived from the original on 2019-04-13. Retrieved 2019-05-13.
  119. ^ Proven, Liam (2022-07-12). "Oracle Linux 9 released, with some interesting additions". The Register. Retrieved 2022-07-14.
  120. ^ Anderson, Tim (2021-12-07). "Rusty Linux kernel draws closer with new patch". The Register. Retrieved 2022-07-14.
  121. ^ Vishnevskiy, Stanislav (2017-07-06). "How Discord Scaled Elixir to 5,000,000 Concurrent Users". Discord Blog. Archived from the original on 2020-04-26. Retrieved 2021-08-14.
  122. ^ Nichols, Shaun (2018-06-27). "Microsoft's next trick? Kicking things out of the cloud to Azure IoT Edge". The Register. Archived from the original on 2019-09-27. Retrieved 2019-09-27.
  123. ^ "Ethereum Blockchain Killer Goes By Unassuming Name of Polkadot". Bloomberg. 2020-10-17. Retrieved 2021-07-14.
  124. ^ "Ruffle". Ruffle. Archived from the original on 2021-01-26. Retrieved 2021-04-14.
  125. ^ terminusdb/terminusdb-store, TerminusDB, 2020-12-14, archived from the original on 2020-12-15, retrieved 2020-12-14
  126. ^ "Getting Started". rust-lang.org. Archived from the original on 2020-11-01. Retrieved 2020-10-11.
  127. ^ "Community". www.rust-lang.org. Archived from the original on 2022-01-03. Retrieved 2022-01-03.
  128. ^ "RustConf 2020 – Thursday, August 20". rustconf.com. Archived from the original on 2019-08-25. Retrieved 2019-08-25.
  129. ^ Rust Belt Rust. Rust Belt Rust. Dayton, Ohio. 2019-10-18. Archived from the original on 2019-05-14. Retrieved 2019-05-14.
  130. ^ RustFest. Barcelona, Spain: asquera Event UG. 2019. Archived from the original on 2019-04-24. Retrieved 2019-05-14.
  131. ^ "RustCon Asia 2019 – About". RustCon Asia. Archived from the original on 2021-05-09. Retrieved 2022-04-21.
  132. ^ "Rust Latam". Rust Latam. Archived from the original on 2021-04-16. Retrieved 2022-04-21.
  133. ^ "Oxidize Global". Oxidize Berlin Conference. Archived from the original on 2021-02-06. Retrieved 2021-02-01.
  134. ^ Tung, Liam (2021-02-08). "The Rust programming language just took a huge step forwards". ZDNet. Retrieved 2022-07-14.
  135. ^ Krill, Paul. "Rust language moves to independent foundation". InfoWorld. Archived from the original on 2021-04-10. Retrieved 2021-04-10.
  136. ^ Vaughan-Nichols, Steven J. (2021-04-09). "AWS's Shane Miller to head the newly created Rust Foundation". ZDNet. Archived from the original on 2021-04-10. Retrieved 2021-04-10.
  137. ^ Vaughan-Nichols, Steven J. (2021-11-17). "Rust Foundation appoints Rebecca Rumbul as executive director". ZDNet. Archived from the original on 2021-11-18. Retrieved 2021-11-18.
  138. ^ "The Rust programming language now has its own independent foundation". TechRepublic. 2021-02-10. Archived from the original on 2021-11-18. Retrieved 2021-11-18.
  139. ^ "Governance". The Rust Programming Language. Archived from the original on 2022-05-10. Retrieved 2022-05-07.
  140. ^ Anderson, Tim (2021-11-23). "Entire Rust moderation team resigns". The Register. Retrieved 2022-07-14.

Further reading[edit]

External links[edit]