Rust Article

Introduction

Rust is a multi-paradigm system programming language focused on safety, especially safe concurrency.

It is syntactically similar to C++, but is designed to provide better memory safety while maintaining high performance.

Rust was designed by Graydon Hoare. It first appeared in 2010 and was influenced by C++, C# Swift and Haskell.

Features

Safety

High Performance

Web Assembley production

Low Level Langauge for system programming

Pros/Cons

Rust has its pros and cons:

Pros	Cons
Low memory usage - Rust combines fine-grained control over memory layout with the lack of a GC and has a very minimal standard library. It used so little memory that is was actually practical to just start a separate Rust process for every document.	Errors are hard to debug - Error handling in Rust is intended to be done by returning in a value called "Result" tht can represent either success or failure. Unlike with exceptions, creating an error value in Rust does not capture a stack trace so any stack traces you get are for the code that reported the error instead of the code that caused the error.
Awesome Performance - Rust definitely delivered on its promise of optimal performance, both because it can take advantage of all of LLVM's optimizations and because the language itself is designed with performance in mind. Rust's slices make passing raw pointers around easy, ergonomic, and safe, and we used that a lot to avoid copying data during parsing. The HashMap API is implemented with linear probing and Robin Hood hashing, so unlike C++'s unordered_map API the contents can be stored inline in a single allocation and are much more cache-efficient.	Asynchronous Rust is difficult - Our multiplayer server talks over WebSockets and makes HTTP requests every so often. We tried writing these request handlers in Rust but hit some concerning ergonomic issues around the futures API (Rust's answer to asynchronous programming). The futures API is very efficient but somewhat complex as a result. For example chaining operations together is done by constructing a giant nested type that represents the whole operation chain. This means everything for that chain can be allocated in a single allocation, but it means that error messages generate long unreadable errors reminiscent of template errors in C++. That combined with other issues such as needing to adapt between different error types and having to solve complex lifetime issues made us decide to abandon this approach.
Solid tookchain - Rust comes with cargo built-in, which is a build tool, package manager, test runner, and documentation generator. This is a standard addition for most modern languages but is a very welcome improvement coming from the outdated world of C++, the other language we had considered using for the rewrite. Cargo was well-documented and easy to use, and it had helpful defaults.	Lifetimes are confusing - In Rust, storing a pointer in a variable can prevent you from mutating the thing it points to as long as that variable is in scope. This guarantees safety but is overly restrictive since the variable may not be needed anymore by the time the mutating happens. Even as someone who has been following Rust from the start, who writes compilers for fun, and who knows how to think like the borrow checker, it's still frustrating to have to pause your work to solve the little unnecessary borrow checker puzzles that can come up regularly as you work.
Friendly error messages - Rust is more complex than other languages because it has an additional piece, the borrow checker, with its own unique rules that need to be learned. People have put a lot of effort into making the error messages readable and it really shows. They make learning Rust much nicer.	Many libraries are still early - Figma's document format is compressed so our server needed to be able to handle compressed data. We tried using two separate Rust compression libraries that were both used by Servo, Mozilla's next-generation browser prototype, but both had subtle correctness issues that would have resulted in data loss.

Extra Programs

Related Programming Languages - C++, Swift, Haskell, C#
Other Programming Languages - JS, Java, Python.
Web Browsers - Mozilla, Google Chrome, Microsoft Edge
IDEs - NetBeams, JetBrains, Visual Studio

Sources

Summary

In conclusion:

Rust is a powerful programming language to use, and it has been consistently ranked as the best language to use by users on StackOverflow. This language is a good language to use, but limited in its qualities such as being hard to debug and hard to be used in an asynchronous way. Rust was made by Mozilla and it is still really good to use and I would say that the pros outweigh the cons.