This is really cool, actually. And the reason I think it's actually good to be high on HN, not just the 'ooooh rust, upvote derp!' is this:

This is a point release that they don't need to do - on the grounds that it's not a bad time to do one, but it should help in the future to do point releases quickly if there is a real need to (security, etc).

There's a commitment in the rust team to making life really really good for developers, and I appreciate that a lot.

I have Travis builds against nightly, beta and stable on Linux and Mac. I have to say, with the exception of OpenSSL breaking on Mac recently (fixed with OpenSSL 0.8), I haven't had a compiler failure or bug introduced in any of my tests in the time since 1.0 (at least I can't remember one).

Even these, which obviously effected others, didn't effect my code. Cudos to the Rust team for being on top of this!

  Date:   Sat Aug 22 11:45:08 2015 -0700

Question for you guys: I'm planning to putting down some time into learning java for the higher stuff along with C the coming year. I know the very basics of C and java, but after looking into the documentation for rust I got that feeling of "oh man, this really looks fun to get into."

Is Rust "mature" enough to start to dabble with and actually put down some hours into (and thus replace C in my plan)? Only hobby projects so far.

The two imaginary futures I daydream about where performance is a concern are robotics and serious AI algorithms (RL especially). I'd assumed I'd need serious C (or C++) chops for the embedded development of the first, and real access to GPU parallelism for the second.

Does anybody have experiences to share using Rust like this?

Honest question from a non C++ developer: what's the main point of Rust? What's the primary reason for choosing it over any other language? When would it be most appropriate to choose?

Rust is a replacement for C++. It is meant to be a modern, general-purpose systems language, where "systems" generally means anywhere you need to be close to the metal. This includes areas like embedded systems and high performance computing. Modern means it has features and tooling you expect from languages in 2016. For example, on a language level, Rust has type inference, sum types, pattern matching, proper generics, and a decent macro system. A modern language should also be memory safe, and Rust opts to ensure memory safety at compile time with the borrow checker (as opposed to runtime with a garbage collector like in most languages). As for tooling, it also has a proper package manager, which believe me, is incredible compared to handling dependencies in C++.

So why would you choose Rust? If you need to use C++, because you need performance, or low-level access to memory, or any other reason, then you should choose Rust instead, because it's better for all the reasons listed above. The biggest strike against Rust compared to C++ is library support--people have been writing C++ and C libraries for decades, and Rust is a new language, so it won't have the same level of support.

I suppose if I identified with any language, C++ would be it. I have the most knowledge and experience writing code in that language. I've been learning Rust lately and have written a few toys with it. I'll share my thoughts.

1. The main benefit of Rust is its nearly cost-free safety guarantees. It's much harder to write code that is prone to UB with Rust than with C++. The comparison is almost silly, in fact, from that perspective. It comes with a runtime cost (e.g. drop flag checks, bounds/other memory access checks) in some cases, but for all cases other than those requiring even that last bit of performance this cost is tiny in comparison with the work the rest of the program is doing and well worth it in my opinion.

2. The primary reason for choosing it over any other language is context dependent. This leads me to my last point.

3. It would be fine to use for anything, really, but I think in the sense of "most appropriate" that you mean, it's "most appropriate" for systems programming that needs to be as fast as C++, but not necessarily melt-the-metal fast. Primarily this is because: a) it's as fast as C++ in almost all cases (and probably faster than equivalently-safe C++ in at least some cases) and b) it's much less likely I'll write code that smashes stacks, has data races, blows up memory or does a bunch of other crap that's trivial in C++ (or other languages). Even in cases where melt-the-metal fast is necessary it seems possible to do in Rust, but it just takes a lot of effort. That's deliberate on the part of the Rust developers, and it's difficult to argue against the reasoning behind it.

Where Rust might really shine is helping a new generation of programmers write performant code that is safe without having to learn by trial-by-fire.

I wrote a Donald Trump text to speech server in Rust. It's blazingly fast. If I'd written it in Python, it'd have taken seconds to generate audio. If I'd written it in C++, it'd likely have memleaked or segfaulted since I'm not skilled or patient enough to write safe C++.

Rust is pretty much the coolest thing ever in my opinion. It's easy and fun to write. Cargo is the best package manager ever, and makes importing library code a breeze. I've never had multithreaded code warn me when I don't lock it correctly. It's so awesome.

(wrt my Rust app, as soon as I load test and redesign the UI I'm going to share it on HN. It's pretty ridiculous and we have a lot of fun with it at work.)

Compared to C++:

- A fantastic package manager for your dependencies

- Easy build system

- A nicer language

- Memory safe

- Just as fast

- A way stronger compiler that will prevent you from making mistakes that you can make in C/C++ very easily

All in all more then enough benefits to make it worthwhile to switch unless there is a very good reason not to.

Rust is a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety.

Featuring

  * zero-cost abstractions
  * move semantics
  * guaranteed memory safety
  * threads without data races
  * trait-based generics
  * pattern matching
  * type inference
  * minimal runtime
  * efficient C bindings

That is from the Rust front page. HTH.

It's difficult to answer this question with 'one main reason'. Rust is what you get if you build a language that is intended to operate in the same space as C and C++, but benefits from the last 30 years of advances in programming languages.

Some things that are better as a result of things that are hard to do right in C++:

* Compiler monitors ownership of memory

* Compiler monitors ownership across threads

* Generics aren't handled as templates, and you can explicitly describe support using things like * trait bounds

* Macros are useful but need to operate on something more like the AST rather than text tokens

* A richer type system can help you express much more in the types (Rust enums)

Rust is basically a safe C++, written by people who like functional languages. Also, it has an official package manager in Cargo, something that C++ lacks completely.

As such, it targets essentially the same niche as C/C++.