Back

ⓘ Rust (programming language)




Rust (programming language)
                                     

ⓘ Rust (programming language)

Rust is a multi-paradigm system programming language focused on safety, especially safe concurrency. Rust is syntactically similar to C++, but is designed to provide better memory safety while maintaining high performance.

Rust was originally designed by Graydon Hoare at Mozilla Research, with contributions from Dave Herman, Brendan Eich, and others. The designers refined the language while writing the Servo layout or browser engine, and the Rust compiler. The compiler is free and open-source software dual-licensed under the MIT License and Apache License 2.0.

Rust has been the "most loved programming language" in the Stack Overflow Developer Survey every year since 2016.

                                     

1. Design

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

                                     

1.1. Design Syntax

The concrete 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. Not all C or C++ keywords are implemented, however, and some Rust functions such as the use of the keyword match for pattern matching will be less familiar to those versed in these languages. Despite the superficial resemblance to C and C++, the syntax of Rust in a deeper sense is closer to that of the ML family of languages and the Haskell language. Nearly every part of a function body is an expression, even control flow operators. For example, the ordinary if expression also takes the place of Cs ternary conditional. 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.

                                     

1.2. Design Memory safety

Rust is designed to be memory safe, and thus it does not permit null pointers, dangling pointers, or data races in safe code. Data values can only be initialized through a fixed set of forms, all of which require their inputs to be already initialized. To replicate the function in other languages of 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. Rust also introduces added syntax to manage lifetimes, and the compiler reasons about these through its borrow checker.

                                     

1.3. Design Memory management

Rust does not use an automated garbage collection system like those used by Go, Java, or the.NET Framework. Instead, memory and other resources are managed through the resource acquisition is initialization RAII convention, with optional reference counting. Rust provides deterministic management of resources, with very low overhead. Rust also favors stack allocation of values and does not perform implicit boxing.

There is also a concept of references using the & symbol, which do not involve run-time reference counting. The safety of using such pointers is verified at compile time by the borrow checker, preventing dangling pointers and other forms of undefined behavior.

                                     

1.4. Design 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. 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.

                                     

1.5. Design Types and polymorphism

The type system supports a mechanism similar to type classes, called "traits", inspired directly by the Haskell language. This is a facility for ad hoc polymorphism, achieved by adding constraints to type variable declarations. Other features from Haskell, such as higher-kinded polymorphism, are not yet supported.

Rust features 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 fails to assign a value to the variable. 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. This is in contrast to C++ templates, which are fundamentally duck typed and cannot be checked until instantiated with concrete types. C++ concepts address the same issue and are expected to be part of C++20 2020.

However, 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. 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.



                                     

2. History

The language grew out of a personal project begun in 2006 by Mozilla employee Graydon Hoare, who stated that the project was possibly named after the rust family of fungi. Mozilla began sponsoring the project in 2009 and announced it in 2010. The same year, work shifted from the initial compiler written in OCaml to the self-hosting compiler written in Rust. Named rustc, it successfully compiled itself in 2011. rustc uses LLVM as its back end.

The first numbered pre-alpha release of the Rust compiler occurred in January 2012. Rust 1.0, the first stable release, was released on May 15, 2015. Following 1.0, stable point releases are delivered every six weeks, while features are developed in nightly Rust and then tested with alpha and beta releases that last six weeks.

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 when a program was running, 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. Typestates were removed because in practice they were little used, though the same function can still be achieved with a branding pattern.

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, with version 0.3 adding 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, replaced by a combination of implementations and structured types.

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 Dobbs, Andrew Binstock, commented on Rusts chances to become a competitor to C++ and to the other upcoming languages D, Go, and Nim then Nimrod. According to Binstock, while Rust was "widely viewed as a remarkably elegant language", adoption slowed because it changed repeatedly between versions.

Rust was the third-most-loved programming language in the 2015 Stack Overflow annual survey and took first place for 2016–2019.

The language is referenced in The Book of Mozilla as "oxidised metal".



                                     

3.1. Projects Web browser

A Web browser and several related components are being written in Rust, including:

  • Servo – Mozillas parallel web-browser engine developed in collaboration with Samsung
  • Quantum – a project, composed of several sub-projects, to improve the Gecko web-browser engine of Firefox, developed by Mozilla
  • Firefox
                                     

3.2. Projects Operating systems

Many operating systems OS and related components are being written in Rust. As of January 2019, the OSes included: BlogOS, intermezzOS, QuiltOS, Redox, RustOS, Rux, Tefflin, and Tock. Wikipedia articles exist on:

  • Firecracker – secure and fast microVMs for serverless computing
  • Redox – a microkernel
  • Stratis – a file system for Fedora and RHEL 8
  • Railcar – a container runtime by Oracle
  • Magic Pocket – Dropboxs file system that powers their Diskotech petabyte storage machines
                                     

3.3. Projects Other

  • Deno – a secure runtime for JavaScript and TypeScript built with V8, Rust, and Tokio
  • TiKV – a distributed key-value database first developed by PingCAP, now a Cloud Native Computing Foundation member project
  • Xi – a text editor from Raph Levien, used within the Fuchsia operating system
  • TerminusDB Data structure design and layout. terminus-store
  • Microsoft Azure IoT Edge – a platform used to run Azure services and artificial intelligence on IoT devices has components implemented in Rust
  • Tor – an anonymity network, written in C originally, is experimenting with porting to Rust for its security features
  • Wargroove – a video game developed by Chucklefish that uses Rust for its server software
  • OpenDNS – used in two of its components
  • Linkerd 2.x service mesh, tool for micro-service monitoring is largely written in Rust,
  • exa – a "modern replacement for ls"


                                     

4. Conferences

  • Rust Belt Rust – a #rustlang conference in the Rust Belt
  • 2018: Ann Arbor, Michigan
  • 2019: Dayton, Ohio
  • RustConf – an annual conference in Portland, Oregon. Held since 2016.
  • 2016: Pittsburgh, Pennsylvania
  • 2017: Columbus, Ohio
  • 2018: Paris, France
  • RustFest – Europes rustlang conference
  • 2016: Berlin, Germany
  • 2017: Kyiv Київ, Ukraine
  • 2018: Rome, Italy
  • 2017: Zurich, Switzerland
  • 2019: Barcelona, Spain
  • RustCon Asia
  • 2019: Beijing, China
  • 2019: Montevideo, Uruguay
  • Rust LATAM
                                     
  • of programming languages spans from documentation of early mechanical computers to modern tools for software development. Early programming languages were
  • comparison of programming languages compares the features of language syntax format for over 50 computer programming languages Programming language expressions
  • collection. It supports multiple programming paradigms, including procedural, object - oriented, and functional programming According to the creator, Ruby
  • Go, also known as Golang, is a statically typed, compiled programming language designed at Google by Robert Griesemer, Rob Pike, and Ken Thompson. Go is
  • genealogy of programming languages Languages are categorized under the ancestor language with the strongest influence. Those ancestor languages are listed
  • ˈɜːrlæŋ UR - lang is a general - purpose, concurrent, functional programming language and a garbage - collected runtime system. The term Erlang is used
  • earlier Newsqueak language and Winterbottom s Alef. Limbo supports the following features: modular programming concurrent programming strong type checking
  • native modules since ECMAScript 2015. Modular programming can be performed even where the programming language lacks explicit syntactic features to support
  • important programming languages by decade. Programming language Timeline of computing History of computing hardware History of programming languages Booth
  • Rust is a multiplayer - only survival video game developed by Facepunch Studios. Rust was first released in early access in December 2013 and received its

Users also searched:

rust programming language classes, rust vs go,

...
...
...