Rust

The software industry never stands still. New technologies, frameworks, and programming languages are constantly emerging. To ensure we stay up to date with the latest technologies at our company, our Xperts regularly explore current topics. This time, we took a closer look at the Rust programming language. We wanted to find out more about this low-level, system-oriented language, which is very similar to C/C++.

What is Rust?

The development of Rust was supported by Mozilla Research in 2009. The goal was to design a language that would enable developers to write small, fast code without memory errors. Ultimately, the language was named Rust after the rust fungi. This group of fungi is particularly known for being exceptionally robust and resilient—qualities that also apply to Rust. For several years now, the language’s further development has been an open-source project. Installation requires the Rustup toolchain installer, which can also be used to update the Rust compiler and the Cargo build tool.

Despite its high level of abstraction from the actual hardware, Rust is still a low-level programming language. It operates without the overhead of a garbage collection mechanism. Its high level of memory safety is certainly the biggest difference compared to classic system programming languages such as C or C++. Rust uses various methods to prevent errors such as invalid memory access, buffer overflows, or race conditions. Static code analysis by the compiler plays an important role in this. This also includes concepts such as the default immutability of variables and exclusive ownership of memory locations.

Compared to traditional programming languages, these fundamental concepts and techniques in Rust are new and not as familiar to many developers. In the following sections, we’ll use two examples to illustrate some of the key aspects of Rust.

Examples

In Listing 1, we see an example program that demonstrates the use of mutable and immutable variables.

In general, variables are declared as follows:

• The keyword is sufficient let.
• Optionally, you can also specify the type and assign a value.
• If it is an immutable variable (read-only), which is the case by default, a value can be assigned to it only once.
• To declare a mutable variable (read and write access), the keyword courage according to let be used.
• A variable's scope is the surrounding statement block, delimited by curly braces.

LISTING 1: VARIABLES AND THEIR VARIABILITY:

"fn main() {\n    let x : i32;\n    x = 3;\n    \/\/ x = 4; -> Compiler Error\n    println!("{}", x); \/\/ -> 3\n\n    let mut y = 5;\n    y += 5;\n    println!("{}", y); \/\/ -> 10\n    {\n let y = y * 2; \/\/ -> 20\n println!("{}", y);\n    }\n    y += 1;\n    println!("{}", y); \/\/ -> 11\n}"

Listing 2 illustrates the concepts of ownership, reference, and borrowing. Memory must be explicitly allocated and deallocated here. In doing so, certain rules governing ownership of the memory region must be followed. These are already checked by the compiler. The rules are:

• Every value in Rust has an owner.
• There can only ever be one owner.
• If the owner leaves the scope, the value is deleted.

In addition, there are also rules regarding references:

• At any given time, there can be either one mutable reference or any number of immutable references.
• References must always be valid.

To illustrate this, we’ll use the string data type. This is a non-scalar data type that manages data allocated on the heap (another area of memory besides the stack). A mutable variable is defined, and the required memory is allocated. When passed to a function, the value is transferred into the function. The variable leaves its scope and is no longer available for access.

That is why, in this example, `Clone` is used to create and pass a copy of the variable. It is also possible to use a reference as a function parameter. In this case, a reference to an object is used as a parameter instead of passing ownership of the value. A reference is a pointer in the sense that it is an address that points to the location of the data. References are created using the & symbol. This is referred to as “borrowing.” In our use case, a mutable reference is passed to the function. Mutable references have one major limitation: While there can be exactly one write-access owner, any number of users can have read access. However, once assigned, the value may no longer be modified.

LISTING 2: OWNERSHIP:

"fn main() {\n\n    let mut string_original = String::from("Original");\n    ownership_with_drop_after(string_original.clone());\n    println!("{string_original}"); \/\/ -> Original\n\n    string_original = ownership_with_drop_after(string_original);\n    println!("{string_original}"); \/\/ -> Original : Changed\n\n    println!("########"); \n\n    let mut string_reference_pointer = String::from("Pointer");\n    change_with_pointer(&mut string_reference_pointer);\n    println!("{string_reference_pointer}"); \/\/ -> Pointer Reference\n}\n\nfn ownership_with_drop_after (mut s : String) -> String {\n    s.push_str(" : Changed\");\n}\n\nfn change_with_pointer(s : &mut String) {\n    s.push_str(" Reference\");\n}"

Conclusion

Compared to other programming languages, Rust offers particular advantages when it comes to stability, safety, and performance. However, getting started with Rust isn’t exactly easy due to the language’s fundamental concepts and the resulting architectures. Therefore, it’s advisable not to switch completely to Rust right away or to implement it prematurely in large projects.

Hybrid approaches, in particular, have proven to be effective—approaches in which Rust components are developed and integrated as microservices or libraries. Another promising option is generating WebAssembly bytecode in Rust, which could prove very useful in practice in the future. This approach allows computationally intensive or low-level tasks to be handled efficiently in Rust.

Rust is also used in the field of embedded systems. Thanks to its ownership concept, it ensures a high level of memory safety. Since Rust does not require a runtime environment or a garbage collector, it also has relatively low resource consumption.