The success of Rust

Since its production release 1.0, Rust has enjoyed quite a steady uptake. This is manifest if you view a Google Trends survey:

In the well-known TIOBE Index (see https://www.tiobe.com/tiobe-index//), it reached 50th place in September 2015 and is now ranked in 37th position.

In the RedMonk ranking of programming languages (see http://redmonk.com/sogrady/2017/06/08/language-rankings-6-17/), it is ready to join the popularity of Lua, CoffeeScript, and Go.

Also, for two consecutive years, Rust was the most loved programing language on Stack Overflow (see https://insights.stackoverflow.com/survey/2017#most-loved-dreaded-and-wanted).

As a hallmark of its success, today, more than 50 companies are using Rust in production, see https://www.rust-lang.org/en-US/friends.html, amongst which are HoneyPot, Tilde, Chef, npm, Canonical, Coursera, and Dropbox.

Where to use Rust

It is clear from the previous sections that Rust can be used in projects that would normally use C or C++. Indeed, many regard Rust as a successor to, or a replacement for, C/C++. Although Rust is designed to be a systems language, due to its richness of constructs, it has a broad range of possible applications, making it an ideal candidate for applications that fall into one or all of the following categories:

• Client applications, like browsers
• Low-latency, high-performance systems, like device drivers, games and signal processing
• Highly distributed and concurrent systems, like server applications and microservices
• Real-time and critical systems, like operating systems or kernels
• Embedded systems (requiring a very minimal runtime footprint) or resource-constrained environments, like Raspberry Pi and Arduino, or robotics
• Tools or services that can't support the long warmup delays common in just-in-time (JIT) compiler systems and need instantaneous startup
• Web frameworks
• Large-scale, high-performance, resource intensive, and complex software systems

Rust is especially suitable when code quality is important, that is, for the following:

• Modestly-sized or larger development teams
• Code for long-running production use
• Code with a longer lifetime that requires regular maintenance and refactoring
• Code for which you would normally write a lot of unit tests to safeguard