I work at a startup with large amounts of JavaScript and Ruby, but no existing investment in a compiled language prior to Rust.

Adding C++ to our toolchain would result in a nasty culture shock. Ruby and JavaScript have modern dependency managers (bundler and npm/yarn). They're easy to get working cross-platform. They almost never segfault.

C++ would bring a whole host of issues (build systems, dependency management, pointers, segfaults, etc.). I didn't want to go there, and neither did my management. But Rust feels more like a modern scripting language (except with a steeper learning curve): It has cargo to handle dependencies and builds, it works cross-platform with minimal fuss, and it provides excellent protection against shooting yourself in the foot.

It turns out that I can use Rust for CLI tools, server applications and Node.js add-ons, and it's great at all of these things.

Plus, every time I write something in Rust, my coworkers are happy, because it's fast, it's easy to install, and it's "solid."

It does take a little while to bring people up to speed on Rust. It really helps to pair program and explain what's going on when they hit a speed bump.

I think the best way to put it is that Rust has no overhead. You'll never be in a situations with Rust where you say "Oh damn I wish I had written this in X because Rust has this annoying limitation". Some examples of limitations in other languages:

* Python has a GIL (Global Interpreter Lock) so writing multi-threaded Python code is more or less impossible (there are some workarounds but it still sucks).

* Most garbage collected languages (e.g. Java, C#) suffer from 'stop the world' pauses which make doing low-latency realtime stuff a pain in the arse. For example on Android they recommend you don't create any objects in your draw functions to avoid invoking the GC. It's kind of like "Java is great, no need to worry about memory, but oh... you really have to be careful about memory here." Not all GC languages are like this, e.g. Go now has sub-millisecond pauses.

And aside from that it is safer than C/C++. So basically it will be used wherever C++ was before.

The big downside is that it is definitely one of the hardest languages to understand and write. That can make you less productive. If I were on a varied team that included less skilled people I would definitely choose Go over Rust if it were suitable - it is a lot simpler.

I use Rust primarily because it has very precise mutability semantics: things are either immutable or uniquely mutable. It is much easier to understand what can or can not happen to structures when they are passed between functions, as opposed to, say, Java, where object's lifetime is undefined.

Destruction after last use (RAII) ensures that resources such as files, sockets, db connections are closed. Also unavailable in majority of languages.

Also the language is expressive (type inference, generics, pattern matching, traits).

These three things are the main reasons, although I wish other languages (old or new) would pick up the first idea too.

When you want to go as fast as C or C++, but you don't want memory or data race errors, and you want a package manager and integrated, very easy to use build tool set.

For me it's basically the language you choose when you want to write new project, but don't want it to explode with type error / null deref at runtime and on the other hand you don't want to deal with C segfaulting and writing all the manual memory management yourself.

Also potentially if you want speed closer to C than interpreted script, and don't mind spending a bit more time up front. (offset by the time you don't spend debugging an inexplicable crash later on)

its primary application is to bring more fun into life.