5 minutes read
What is Rust?

What is Rust?

Often, developers will turn to tech hubs like Github or Stack Overflow to get a sense of upcoming trends in programming languages. The thriving communities of developers using both sites are often polled on their preferred languages, both for specific use cases as well as broadly which languages are useful and convenient. Featuring prominently on a number of developers’ preference surveys over the past few years has been Rust -- in fact, the language has topped Stack Overflow’s list of most-loved languages for the past half decade.

For many beginning developers, Rust is not among the most in-demand languages to learn, when compared to globally known heavyweights like Python, Java, or Swift. However, the robust popularity of Rust is rapidly making it a more popular choice for newcomers beginning their coding classes, and there are some unique benefits to the language that are responsible for its widespread popularity.

So what is Rust, and why is it an attractive option for beginning programmers to learn? What can Rust be used for, and what are some of the specific features that drive its widespread adoption? From solving pain points and gaps in many existing languages, to capabilities that allow it to power some of the most innovative elements in modern tech, let’s take a deeper dive into the Rust language and why it might be the perfect language for you to learn.


The Rust Language

At its most basic definition, Rust is what is known as a low-level statically-typed multi-paradigm programming language. Compared to other similar languages, Rust is specifically centered on increasing and maintaining safety and performance. Like most newer languages (Rust was developed in 2016), Rust also builds off the existing feature sets of other popular languages while making tweaks based on common frustrations. For example, Rust solves problems that C/C++ has been plagued by for years, notably memory errors and building concurrent programs.

Rust devotees often cite three main benefits to using the language:

  • Rust offers programmers better memory safety due to the included compiler.
  • Rust offers easier concurrency due to its data ownership model which prevents data races (and thus improves performance)
  • Zero-cost abstractions.

If you are new to programming, you may be wondering what those three things mean. Let’s dive into each a bit more:

Memory Management 

For people interested in working with system programming, the low-level control that memory management provides is essential to effective project work. On the downside, manual management raises a ton of headaches for programmers when using languages like C. Even though useful tools like Valgrind exist to help alleviate these issues, catching memory management problems is tricky.

This is where Rust comes in. Rust’s ownership system analyzes a program’s memory management during compile-time, ensuring that bugs due to poor memory management can’t happen and that garbage collection is unnecessary. This saves programmers tons of time tracking down individual bugs (and then fixing them) on their own, and speeds up the entire development process.

Additionally, if you want to perform super-optimized implementations (similar to how you would when using C), you can do that while clearly delineating them from the rest of the code base, simply by using the unsafe keyword.

Rust Makes Concurrency Simpler

To understand why simplifying concurrency is a major benefit of Rust, you need to understand what data races are. Data races happen when two threads access the same memory at the same time, and they can often result in particularly problematic glitches and bugs that can cause things to go sideways fast. However, thanks to its borrow checker, Rust can head off data races at compile-time, preventing these undefined events from happening and again helping to streamline the coding process.

Zero-Cost Abstractions 

Once again, to know why this is a Rust benefit you need to understand zero-cost abstractions. To put it simply, zero-cost abstractions ensure that there is extremely limited runtime overhead for whatever abstractions you use during development. Put another way, there is no speed difference between low-level code and one written with abstractions. These issues have plagued major corporations (let alone bootstrapped startups) for years, and avoiding them can save countless time and money in later development costs.

What Is Rust Used For? 

Since Rust is considered a low-level language, it is most useful for cases when developers need to maximize their limited resources. Because it’s statically typed, the type system also helps programmers prevent certain troublesome classes of bugs during compilation. As a result of these structural benefits, Rust lends itself not only to situations where resources are limited, but also to times where you need to ensure your program doesn’t fail (i.e. more high-stakes situations). In comparison, high-level dynamically typed languages such as Python and JavaScript are a better choice for things like quick prototypes, since they are easily used but also more prone to bugs and issues.

Here are some of Rust’s most common use cases:

  • Distributed online services.
  • Powerful, cross-platform command-line tools.
  • Embedded devices.
  • Anywhere else you would need systems programming, such as a browser engine or a Linux kernel.

Other Uses For Rust 

Developing Games 

Many newer programmers begin their coding career because they want the chance for a career building games (for both mobile and hardware systems). With this in mind, Rust is theoretically a good choice for game development, since the language is performance-based and does not incorporate a garbage collector. This means games developed with the language should be both fast-operating and largely glitch-free.

However, like most new languages, there is a very limited existing base of code and tools for game development, and there is nothing written in Rust that would compare to the widely popular Unreal Engine, for example. However, as the Rust community grows, more and more game development and potential programming solutions should continue to grow as well.

Web Development 

The other most popular driver for people learning programming is breaking into web development - everybody has dreams of building the next hit app or useful software solution. Similar to other languages, Rust offers multiple frameworks for web development, such as Actix Web and Rocket that are both very usable and well-designed and built. Actix Web is particularly well-reviewed by experienced programmers, especially in terms of speed and other common framework metrics.

However, Rust doesn’t currently offer any solutions remotely in the neighborhood of more established frameworks like Django and Rails, among others. Similar to game development, because Rust is such a young (and therefore still-growing and developing) language, many of the needed utility libraries are missing. Without these libraries, the web development process is just not as simple and straightforward as it is for many of the more established web development languages.