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.
>Ruby and JavaScript have modern dependency managers (bundler and npm/yarn). They're easy to get working cross-platform.
Ruby is easy to get working cross-platform? The only fully supported platforms are Linux and OS X (and really only the Linux-like parts of OS X). Ruby on Windows is a trainwreck, and other platforms are not supported at all. Meanwhile C++ runs on everything and the toaster. Ruby might have many strengths but cross-platform support is not among them.
Compared to a C++ project which relies on a half-dozen external libraries each with their own build system? Yes, in my experience. I've spent too much of my life converting autoconf scripts to Visual C++ project files.
But Rust is definitely quite reasonable to get working on Windows, especially pure Rust, but small C extensions are OK as long as OpenSSL isn't involved. Usually I can just cross-compile or build using Travis CI.
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.
> If one just wants simplicity, why not pick C, or even Basic-80? They are simpler than Go.
It's very simple to write bad C. Writing safe, correct C with no security vulnerabilities is surprisingly hard, which is a major reason why most OSes need to apply regular security patches.
Rust gives you speed, concurrency and memory safety at the same time. This is not free: You need to know about values, references, stacks and heaps. And you need to write your code so that objects have a single, clear owner. It also helps to be somewhat familiar with generic types and functions like `map`—some old-school C programmers might have issues with parts of Rust, but C++ programmers (or C programmers who know JavaScript) should be fine.
If you're willing to pay that price, and spend a week or two making friends with the borrow checker, Rust is a fantastic and versatile tool. But for many programmers and applications, that price may be too high.
Rust will hopefully remain simpler than C++. But it's always going to be more complex than Go or Ruby. I have no idea whether Rust will wind up simpler or more complex than modern JavaScript, though. :-)
My point exactly. Being simple is nice, but not enough.
This is why I (ironically) offered to use Basic-80, which is even simpler than Go, replying to a text that suggests to choose Go over Rust for Go's simplicity.
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)
Yes - and frustration. Breaking cycles with weak references and so forth. But on the plus side, once you know this stuff well modern C++ makes so much more sense.
Can you give some examples of "this stuff"? As a recent entrant to the world of C++ I would be curious to hear those areas I should investigate to get to that point. You mentioned breaking cycles with weak references so it is it mostly understanding how C object model is implemented and/or anything else? Any resources or book you found helpful to find that enlightenment? Cheers.
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.