Rust (programming language)

From HandWiki
Short description
Memory-safe programming language without garbage collection
Rust
A capitalised letter R set into a sprocket
The official Rust logo
ParadigmsMulti-paradigm: concurrent, functional, generic, imperative, structured
Designed byGraydon Hoare
DeveloperThe Rust Foundation
First appearedJuly 7, 2010; 11 years ago (2010-07-07)
Typing disciplineAffine, inferred, nominal, static, strong
Implementation languageRust
OSCross-platform
LicenseMIT or Apache 2.0[1]
Filename extensions.rs, .rlib
Websitewww.rust-lang.org
Influenced by
Influenced

Rust is a multi-paradigm, high-level, general-purpose programming language designed for performance and safety, especially safe concurrency.[11][12] Rust is syntactically similar to C++,[13] but can guarantee memory safety by using a borrow checker to validate references.[14] Rust achieves memory safety without garbage collection, and reference counting is optional.[15][16]

Rust was originally designed by Graydon Hoare at Mozilla Research, with contributions from Dave Herman, Brendan Eich, and others.[17][18] The designers refined the language while writing the Servo experimental browser engine,[19] and the Rust compiler. It has gained increasing use in industry, and Microsoft has been experimenting with the language for secure and safety-critical software components.[20][21]

Rust has been voted the "most loved programming language" in the Stack Overflow Developer Survey every year since 2016, though only used by 7% of the respondents in the 2021 survey.[22]

History

An example of compiling a Rust program

The language grew out of a personal project begun in 2006 by Mozilla employee Graydon Hoare,[12] who stated that the project was possibly named after the rust family of fungi.[23] Mozilla began sponsoring the project in 2009[12] and announced it in 2010.[24][25] The same year, work shifted from the initial compiler (written in OCaml) to the LLVM-based self-hosting compiler written in Rust.[26] Named rustc, it successfully compiled itself in 2011.[27]

The first numbered pre-alpha release of the Rust compiler occurred in January 2012.[28] Rust 1.0, the first stable release, was released on May 15, 2015.[29][30] Following 1.0, stable point releases are delivered every six weeks, while features are developed in nightly Rust with daily releases, then tested with beta releases that last six weeks.[31][32] Every 2 to 3 years, a new Rust "Edition" is produced. This is to provide a easy reference point for changes due to the frequent nature of Rust's Train release schedule, as well as to provide a window to make breaking changes. Editions are largely compatible.[33]

Along with conventional static typing, before version 0.4, Rust also supported typestates. The typestate system modeled assertions before and after program statements, through use of a special check statement. Discrepancies could be discovered at compile time, rather than at runtime, as might be the case with assertions in C or C++ code. The typestate concept was not unique to Rust, as it was first introduced in the language NIL.[34] Typestates were removed because in practice they were little used,[35] though the same functionality can be achieved by leveraging Rust's move semantics.[36]

The style of the object system changed considerably within versions 0.2, 0.3 and 0.4 of Rust. Version 0.2 introduced classes for the first time, and version 0.3 added several features, including destructors and polymorphism through the use of interfaces. 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.(citation?)

Starting in Rust 0.9 and ending in Rust 0.11, Rust had two built-in pointer types: ~ and @, simplifying the core memory model. It reimplemented those pointer types in the standard library as Box and (the now removed) Gc.

In January 2014, before the first stable release, Rust 1.0, the editor-in-chief of Dr. Dobb's, Andrew Binstock, commented on Rust's chances of becoming a competitor to C++ and to the other up-and-coming 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.[37]

Rust has a foreign function interface (FFI) that can be called from e.g. C language, and can call C. While calling C++ has historically been problematic (from any language), Rust has a library, CXX, to allow calling to or from C++, and "CXX has zero or negligible overhead".[38]

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.[39][40] Among those laid off were most of the Rust team,[41] while the Servo team was completely disbanded.[42] The event raised concerns about the future of Rust.[43]

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 taking ownership of all trademarks and domain names, and also take financial responsibility for their costs.[44]

On February 8, 2021 the formation of the Rust Foundation was officially announced by its five founding companies (AWS, Huawei, Google, Microsoft, and Mozilla).[45][46]

On April 6, 2021, Google announced support for Rust within Android Open Source Project as an alternative to C/C++.[47]

Syntax

Here is a "Hello, World!" program written in Rust. The println! macro prints the message to standard output.

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

The syntax of Rust is similar to C and C++, with blocks of code delimited by curly brackets, and control flow keywords such as if, else, while, and for, although the specific syntax for defining functions is more similar to Pascal. Despite the resemblance to C and C++, the syntax of Rust in is closer to that of the ML family of languages and the Haskell language. Nearly every part of a function body is an expression,[48] even control flow operators. For example, the ordinary if expression also takes the place of C's ternary conditional, an idiom used by ALGOL 60. As in Lisp, a function need not end with a return expression: in this case if the semicolon is omitted, the last expression in the function creates the return value, as seen in the following recursive implementation of the factorial function:

fn factorial(i: u64) -> u64 {
    match i {
        0 => 1,
        n => n * factorial(n-1)
    }
}

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

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

Features

File:Rust 101.webm

Rust is intended to be a language for highly concurrent and highly safe systems,[49] and programming in the large, that is, creating and maintaining boundaries that preserve large-system integrity.[50] This has led to a feature set with an emphasis on safety, control of memory layout, and concurrency.

Memory safety

Rust is designed to be memory safe. It does not permit null pointers, dangling pointers, or data races.[51][52][53] Data values can be initialized only through a fixed set of forms, all of which require their inputs to be already initialized.[54] 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.[52] 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.[14]

Memory management

Rust does not use automated garbage collection. Memory and other resources are managed through the resource acquisition is initialization convention,[55] with optional reference counting. Rust provides deterministic management of resources, with very low overhead.(citation?) Rust favors stack allocation of values and does not perform implicit boxing.

There is the concept of references (using the & symbol), which does not involve run-time reference counting. The safety of such pointers is verified at compile time, preventing dangling pointers and other forms of undefined behavior. Rust's type system separates shared, immutable pointers of the form &T from unique, mutable pointers of the form &mut T. A mutable pointer can be coerced to an immutable pointer, but not vice versa.

Ownership

Rust has an ownership system where all values have a unique owner, and the scope of the value is the same as the scope of the owner.[56][57] Values can be passed by immutable reference, using &T, by mutable reference, using &mut T, or by value, using T. At all times, there can either be multiple immutable references or one mutable reference (an implicit readers–writer lock). The Rust compiler enforces these rules at compile time and also checks that all references are valid.

Types and polymorphism

The type system supports a mechanism similar to type classes, called traits, inspired by the Haskell language. This is a facility for ad hoc polymorphism, achieved by adding constraints to type variable declarations.

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.[58] Variables assigned multiple times must be marked with the keyword mut.

Functions can be given generic parameters, which usually require the generic type to implement a certain trait or traits. Within such a function, the generic value can only be used through those traits. 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. Type erasure is also available in Rust by using the keyword dyn. The benefit of monomorphization is optimized code for each specific use case; the drawback is increased compile time and size of the resulting binaries.

The object 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. Inheritance and polymorphism are provided by traits; 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.

Components

Rust features a large number of components that extend the Rust feature set and make Rust development easier. Component installation is typically managed by rustup, a Rust toolchain installer developed by the Rust project.[59]

Cargo

Cargo is Rust's build system and package manager. Cargo handles downloading dependencies, and building dependencies. Cargo also acts as a wrapper for clippy and other Rust components. It requires projects to follow a certain directory structure.[60]

The dependencies for a Rust package are specified in a Cargo.toml file along with version requirements, telling Cargo which versions of the dependency are compatible with the package. By default, Cargo sources its dependencies from the user-contributed registry crates.io but Git repositories and packages in the local filesystem can be specified as dependencies, too.[61]

Rustfmt

Rustfmt is a code formatter for Rust. It takes Rust source code as input and changes the whitespace and indentation to produce formatted code in accordance to the Rust style guide.[62] Rustfmt can also check whether the input is correctly formatted.[63]

Clippy

Clippy is Rust's built in linting tool to improve the correctness, performance, and readability of Rust code. As of 2021, Clippy has more than 450 rules,[64] which can be browsed online and filtered by category.[65] Some rules are disabled by default.

RLS

RLS is a language server that provides IDEs and text editors with more information about a Rust project. It provides linting checks via Clippy, formatting via Rustfmt, automatic code completion via Racer, among other functions.[66] Development of Racer was slowed down in favor of rust-analyzer.[67]

Language extensions

It is possible to extend the Rust language using the procedural macro mechanism.[68]

Procedural macros use Rust functions that run at compile time to modify the token stream that is processed by the compiler. This complements the user defined macro mechanism which uses pattern matching to achieve similar goals.

Procedural macros come in three flavors:

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

The println! macro is an example of a function-like macro and serde_derive[69] 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.[70]

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::{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);
}

Performance

Rust aims "to be as efficient and portable as idiomatic C++, without sacrificing safety".[71] Since Rust utilizes LLVM, any performance improvements in LLVM also carry over to Rust.[72]

Adoption

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

Rust was the third-most-loved programming language in the 2015 Stack Overflow annual survey[74] and took first place for 2016–2021.[75][76]

Web browsers

Firefox has two projects written in Rust: the Servo parallel browser engine[77] developed by Mozilla in collaboration with Samsung;[78] and Quantum, which is composed of several sub-projects for improving Mozilla's Gecko browser engine.[79]

Experimental operating systems

  • Redox, a "full-blown Unix-like operating system" including a microkernel[80]
  • Theseus, OS with "intralingual design" and a fundamental architecture which embodies Rust concepts[81]

Other

Governance

Rust Foundation
Rust Foundation logo.png
FormationFebruary 8, 2021; 7 months ago (2021-02-08)
Founders
TypeNonprofit organization
Location
Shane Miller
Executive Director
Ashley Williams (interim)
Websitefoundation.rust-lang.org

The Rust Foundation is a non-profit membership organization incorporated in Delaware, United States , with the primary purposes of supporting the maintenance and development of the language, cultivating the Rust project team members and user communities, managing the technical infrastructure underlying the development of Rust, and managing and stewarding the Rust trademark.

It was established on February 8, 2021, with five founding corporate members (Amazon Web Services, Huawei, Google, Microsoft, and Mozilla).[96]

The foundation's board is chaired by Shane Miller.[97] Its interim Executive Director is Ashley Williams.

Development

Rust conferences include:

  • RustConf: an annual conference in Portland, Oregon . Held annually since 2016 (except in 2020 and 2021 because of the COVID-19 pandemic).[98]
  • Rust Belt Rust: a #rustlang conference in the Rust Belt[99]
  • RustFest: Europe's @rustlang conference[100]
  • RustCon Asia
  • Rust LATAM
  • Oxidize Global[101]

See also

References

  1. 2.00 2.01 2.02 2.03 2.04 2.05 2.06 2.07 2.08 2.09 2.10 2.11 2.12 "The Rust Reference: Appendix: Influences". https://doc.rust-lang.org/reference/influences.html. 
  2. "Note Research: Type System". 2015-02-01. https://github.com/rust-lang/rust-wiki-backup/blob/master/Note-research.md#type-system. 
  3. "RFC for 'if let' expression". https://github.com/rust-lang/rfcs/pull/160. 
  4. "Command Optimizations?". 2014-06-26. https://groups.google.com/forum/?fromgroups#!searchin/elm-discuss/rust/elm-discuss/lMX_9miTD2E/QBwdvL4JD9wJ. 
  5. "Idris – Uniqueness Types". http://docs.idris-lang.org/en/latest/reference/uniqueness-types.html. 
  6. Jaloyan, Georges-Axel (19 October 2017). Safe Pointers in SPARK 2014. Bibcode2017arXiv171007047J. 
  7. Lattner, Chris. "Chris Lattner's Homepage". http://nondot.org/sabre/. 
  8. "Microsoft opens up Rust-inspired Project Verona programming language on GitHub". https://www.zdnet.com/article/microsoft-opens-up-rust-inspired-project-verona-programming-language-on-github/. 
  9. "PHP RFC: Shorter Attribute Syntax". 2020-06-03. https://wiki.php.net/rfc/shorter_attribute_syntax. 
  10. Hoare, Graydon (2016-12-28). "Rust is mostly safety". Dreamwidth Studios. https://graydon2.dreamwidth.org/247406.html. 
  11. 12.0 12.1 12.2 "FAQ – The Rust Project". https://www.rust-lang.org/faq.html#project. 
  12. "Rust vs. C++ Comparison". https://www.apriorit.com/dev-blog/520-rust-vs-c-comparison. 
  13. 14.0 14.1 "Unsafe Rust". https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html. 
  14. "Fearless Security: Memory Safety". https://hacks.mozilla.org/2019/01/fearless-security-memory-safety/. 
  15. "Rc<T>, the Reference Counted Smart Pointer". https://doc.rust-lang.org/book/ch15-04-rc.html. 
  16. Noel (2010-07-08). "The Rust Language". Lambda the Ultimate. http://lambda-the-ultimate.org/node/4009. 
  17. "Contributors to rust-lang/rust". https://github.com/rust-lang/rust/graphs/contributors. 
  18. Bright, Peter (2013-04-03). "Samsung teams up with Mozilla to build browser engine for multicore machines". https://arstechnica.com/information-technology/2013/04/samsung-teams-up-with-mozilla-to-build-browser-engine-for-multicore-machines/. 
  19. "Why Rust for safe systems programming". https://msrc-blog.microsoft.com/2019/07/22/why-rust-for-safe-systems-programming/. 
  20. "How Microsoft Is Adopting Rust". August 6, 2020. https://medium.com/the-innovation/how-microsoft-is-adopting-rust-e0f8816566ba. 
  21. "Stack Overflow Developer Survey 2021". https://insights.stackoverflow.com/survey/2021. 
  22. Hoare, Graydon (2014-06-07). "Internet archaeology: the definitive, end-all source for why Rust is named "Rust"". https://www.reddit.com/r/rust/comments/27jvdt/internet_archaeology_the_definitive_endall_source/. 
  23. "Future Tense". 2011-04-29. http://www.slideshare.net/BrendanEich/future-tense-7782010. 
  24. Hoare, Graydon (7 July 2010). "Project Servo". Mozilla Annual Summit 2010. Whistler, Canada. http://venge.net/graydon/talks/intro-talk-2.pdf. Retrieved 22 February 2017. 
  25. Hoare, Graydon (2010-10-02). "Rust Progress". http://blog.mozilla.com/graydon/2010/10/02/rust-progress/. 
  26. Hoare, Graydon (2011-04-20). "[rust-dev] stage1/rustc builds". https://mail.mozilla.org/pipermail/rust-dev/2011-April/000330.html. 
  27. catamorphism (2012-01-20). "Mozilla and the Rust community release Rust 0.1 (a strongly-typed systems programming language with a focus on memory safety and concurrency)". https://www.reddit.com/r/programming/comments/opgxd/mozilla_and_the_rust_community_release_rust_01_a/. 
  28. "Version History". https://github.com/rust-lang/rust/blob/master/RELEASES.md. 
  29. The Rust Core Team (May 15, 2015). "Announcing Rust 1.0". http://blog.rust-lang.org/2015/05/15/Rust-1.0.html. 
  30. "Scheduling the Trains". https://blog.rust-lang.org/2014/12/12/1.0-Timeline.html. 
  31. "G - How Rust is Made and "Nightly Rust" - The Rust Programming Language". https://doc.rust-lang.org/book/appendix-07-nightly-rust.html. 
  32. "What are editions? - The Edition Guide". https://doc.rust-lang.org/edition-guide/editions/index.html. 
  33. Strom, Robert E.; Yemini, Shaula (1986). "Typestate: A Programming Language Concept for Enhancing Software Reliability". IEEE Transactions on Software Engineering: 157–171. doi:10.1109/TSE.1986.6312929. ISSN 0098-5589. https://www.cs.cmu.edu/~aldrich/papers/classic/tse12-typestate.pdf. Retrieved 2010-11-14. 
  34. Walton, Patrick (2012-12-26). "Typestate Is Dead, Long Live Typestate!". https://pcwalton.github.io/2012/12/26/typestate-is-dead.html. 
  35. Biffle, Cliff (2019-06-05). "The Typestate Pattern in Rust". https://cliffle.com/blog/rust-typestate/. 
  36. Binstock, Andrew. "The Rise And Fall of Languages in 2013". http://www.drdobbs.com/jvm/the-rise-and-fall-of-languages-in-2013/240165192. 
  37. "Safe Interoperability between Rust and C++ with CXX" (in en). 2020-12-06. https://www.infoq.com/news/2020/12/cpp-rust-interop-cxx/. 
  38. Cimpanu, Catalin (2020-08-11). "Mozilla lays off 250 employees while it refocuses on commercial products". https://www.zdnet.com/article/mozilla-lays-off-250-employees-while-it-refocuses-on-commercial-products/. 
  39. Cooper, Daniel (2020-08-11). "Mozilla lays off 250 employees due to the pandemic". https://www.engadget.com/mozilla-firefox-250-employees-layoffs-151324924.html. 
  40. @tschneidereit (2020-08-12). "Much of the team I used to manage was part of the Mozilla layoffs on Tuesday. That team was Mozilla's Rust team, and Mozilla's Wasmtime team. I thought I'd know how to talk about it by now, but I don't. It's heartbreaking, incomprehensible, and staggering in its impact.". https://twitter.com/tschneidereit/status/1293868141953667074. 
  41. @asajeffrey (2020-08-11). "Mozilla is closing down the team I'm on, so I am one of the many folks now wondering what the next gig will be. It's been a wild ride!". https://twitter.com/asajeffrey/status/1293220656339988483. 
  42. Kolakowski, Nick (2020-08-27). "Is Rust in Trouble After Big Mozilla Layoffs?". https://insights.dice.com/2020/08/27/rust-in-trouble-after-big-mozilla-layoffs/. 
  43. "Laying the foundation for Rust's future". 2020-08-18. https://blog.rust-lang.org/2020/08/18/laying-the-foundation-for-rusts-future.html. 
  44. "Rust Foundation" (in en). 2021-02-08. https://foundation.rust-lang.org/. 
  45. "Mozilla Welcomes the Rust Foundation" (in en-US). 2021-02-09. https://blog.mozilla.org/blog/2021/02/08/mozilla-welcomes-the-rust-foundation. 
  46. Amadeo, Ron (2021-04-07). "Google is now writing low-level Android code in Rust" (in en-us). https://arstechnica.com/gadgets/2021/04/google-is-now-writing-low-level-android-code-in-rust/. 
  47. "rust/src/grammar/parser-lalr.y". 2017-05-23. https://github.com/rust-lang/rust/blob/5b13bff5203c1bdc6ac6dc87f69b5359a9503078/src/grammar/parser-lalr.y#L1309-L1573. 
  48. Avram, Abel (2012-08-03). "Interview on Rust, a Systems Programming Language Developed by Mozilla". InfoQ. http://www.infoq.com/news/2012/08/Interview-Rust. 
  49. "Debian -- Details of package rustc in sid". https://packages.debian.org/sid/main/rustc. 
  50. Rosenblatt, Seth (2013-04-03). "Samsung joins Mozilla's quest for Rust". http://reviews.cnet.com/8301-3514_7-57577639/samsung-joins-mozillas-quest-for-rust/. 
  51. 52.0 52.1 Brown, Neil (2013-04-17). "A taste of Rust". https://lwn.net/Articles/547145/. 
  52. "Races - The Rustonomicon". https://doc.rust-lang.org/nomicon/races.html. 
  53. "The Rust Language FAQ". 2015. http://static.rust-lang.org/doc/master/complement-lang-faq.html. 
  54. "RAII – Rust By Example". https://doc.rust-lang.org/rust-by-example/scope/raii.html. 
  55. Klabnik, Steve; Nichols, Carol (June 2018). "Chapter 4: Understanding Ownership" (in en). The Rust Programming Language. San Francisco, California: No Starch Press. p. 44. ISBN 978-1-593-27828-1. https://nostarch.com/rust. Retrieved 2019-05-14. 
  56. "The Rust Programming Language: What is Ownership" (in en). https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html. 
  57. Walton, Patrick (2010-10-01). "Rust Features I: Type Inference". http://pcwalton.blogspot.com/2010/10/rust-features-i-type-inference.html. 
  58. rust-lang/rustup, The Rust Programming Language, 2021-05-17, https://github.com/rust-lang/rustup, retrieved 2021-05-17 
  59. "Why Cargo Exists". https://doc.rust-lang.org/cargo/guide/why-cargo-exists.html. 
  60. "Specifying Dependencies - The Cargo Book". https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html. 
  61. "rust-dev-tools/fmt-rfcs" (in en). https://github.com/rust-dev-tools/fmt-rfcs. 
  62. "rustfmt". https://github.com/rust-lang/rustfmt. 
  63. "rust-lang/rust-clippy" (in en). https://github.com/rust-lang/rust-clippy. 
  64. "ALL the Clippy Lints". https://rust-lang.github.io/rust-clippy/. 
  65. "rust-lang/rls" (in en). https://github.com/rust-lang/rls. 
  66. "racer-rust/racer" (in en). https://github.com/racer-rust/racer. 
  67. "Procedural Macros". https://doc.rust-lang.org/reference/procedural-macros.html. 
  68. "Serde Derive". https://serde.rs/derive.html. 
  69. "extendr_api - Rust". https://extendr.github.io/extendr/extendr_api/index.html. 
  70. Walton, Patrick (2010-12-05). "C++ Design Goals in the Context of Rust". http://pcwalton.blogspot.com/2010/12/c-design-goals-in-context-of-rust.html. 
  71. "How Fast Is Rust?". https://doc.rust-lang.org/1.0.0/complement-lang-faq.html#how-fast-is-rust?. 
  72. "Getting Started". https://www.rust-lang.org/learn/get-started#ferris. 
  73. "Stack Overflow Developer Survey 2015". https://stackoverflow.com/research/developer-survey-2015. 
  74. "Stack Overflow Developer Survey 2019". https://insights.stackoverflow.com/survey/2019/?utm_source=social-share&utm_medium=social&utm_campaign=dev-survey-2019. 
  75. "Stack Overflow Developer Survey 2021". https://insights.stackoverflow.com/survey/2021#most-loved-dreaded-and-wanted-language-love-dread. 
  76. Yegulalp, Serdar (2015-04-03). "Mozilla's Rust-based Servo browser engine inches forward". InfoWorld. http://www.infoworld.com/article/2905688/applications/mozillas-rust-based-servo-browser-engine-inches-forward.html. 
  77. Lardinois, Frederic (2015-04-03). "Mozilla And Samsung Team Up To Develop Servo, Mozilla's Next-Gen Browser Engine For Multicore Processors". TechCrunch. https://techcrunch.com/2013/04/03/mozilla-and-samsung-collaborate-on-servo-mozillas-next-gen-browser-engine-for-tomorrows-multicore-processors/. 
  78. Bryant, David (27 October 2016). "A Quantum Leap for the web". https://medium.com/mozilla-tech/a-quantum-leap-for-the-web-a3b7174b3c12#.ldic6a78e. 
  79. Yegulalp, Serdar. "Rust's Redox OS could show Linux a few new tricks". infoworld. http://www.infoworld.com/article/3046100/open-source-tools/rusts-redox-os-could-show-linux-a-few-new-tricks.html. 
  80. "Introduction to Theseus" (in en). https://theseus-os.github.io/Theseus/book/index.html. 
  81. Garbutt, James (27 January 2019). "First thoughts on Deno, the JavaScript/TypeScript run-time". https://43081j.com/2019/01/first-look-at-deno. 
  82. Howarth, Jesse (2020-02-04). "Why Discord is switching from Go to Rust". https://blog.discord.com/why-discord-is-switching-from-go-to-rust-a190bbca2b1f. 
  83. Vishnevskiy, Stanislav (July 6, 2017). "How Discord Scaled Elixir to 5,000,000 Concurrent Users". https://blog.discord.com/scaling-elixir-f9b8e1e7c29b. 
  84. "Google Fushcia's source code" (in en). https://fuchsia.googlesource.com/fuchsia/+/refs/heads/main/tools. 
  85. Nichols, Shaun (27 June 2018). "Microsoft's next trick? Kicking things out of the cloud to Azure IoT Edge" (in en). https://www.theregister.co.uk/2018/06/27/microsofts_next_cloud_trick_kicking_things_out_of_the_cloud_to_azure_iot_edge/. 
  86. Balbaert, Ivo (27 May 2015). Rust Essentials. Packt Publishing. p. 6. ISBN 978-1785285769. https://books.google.com/books?id=TeiuCQAAQBAJ&q=OpenDNS+Rust&pg=PA6. Retrieved 21 March 2016. 
  87. Frank, Denis (5 December 2013). "Using HyperLogLog to Detect Malware Faster Than Ever". https://umbrella.cisco.com/blog/2013/12/05/hyperloglog-and-malware-detection/. 
  88. Denis, Frank (4 October 2013). "ZeroMQ: Helping us Block Malicious Domains in Real Time". https://umbrella.cisco.com/blog/2013/10/04/zeromq-helping-us-block-malicious-domains/. 
  89. "Ruffle" (in en). https://ruffle.rs/#what-is-ruffle. 
  90. Sei, Mark (10 October 2018). "Fedora 29 new features: Startis now officially in Fedora". https://www.marksei.com/fedora-29-new-features-startis/. 
  91. "RHEL 8: Chapter 8. Managing layered local storage with Stratis". 10 October 2018. https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/8-beta/html/configuring_and_managing_file_systems/managing-layered-local-storage-with-stratis_configuring-and-managing-file-systems. 
  92. Hahn, Sebastian (2017-03-31). "[tor-dev Tor in a safer language: Network team update from Amsterdam"]. https://lists.torproject.org/pipermail/tor-dev/2017-March/012088.html. 
  93. asn (2017-07-05). "The Wilmington Watch: A Tor Network Team Hackfest". https://blog.torproject.org/blog/network-team-hackfest-wilmington-watch. 
  94. terminusdb/terminusdb-store, TerminusDB, 2020-12-14, https://github.com/terminusdb/terminusdb-store, retrieved 2020-12-14 
  95. Krill, Paul. "Rust language moves to independent foundation". InfoWorld. https://www.infoworld.com/article/3606774/rust-language-moves-to-independent-foundation.html. 
  96. Vaughan-Nichols, Steven J. (9 April 2021). "AWS's Shane Miller to head the newly created Rust Foundation". ZDNet. https://www.zdnet.com/article/awss-shane-miller-to-head-the-newly-created-rust-foundation/. 
  97. "RustConf 2020 - Thursday, August 20". https://rustconf.com/. 
  98. "Rust Belt Rust". Dayton, Ohio. 2019-10-18. https://rust-belt-rust.com/. Retrieved 2019-05-14. 
  99. "RustFest". Barcelona, Spain: asquera Event UG. 2019. https://blog.rustfest.eu/past_events/. Retrieved 2019-05-14. 
  100. "Oxidize Global". https://oxidizeconf.com/. 

Cite error: <ref> tag with name "mozilla-research" defined in <references> is not used in prior text.
Cite error: <ref> tag with name "RustPlatforms" defined in <references> is not used in prior text.
Cite error: <ref> tag with name "EmbeddedFAQ" defined in <references> is not used in prior text.
Cite error: <ref> tag with name "OpenBSD" defined in <references> is not used in prior text.

Cite error: <ref> tag with name "rust-on-ios" defined in <references> is not used in prior text.

External links