Become a fan of Slashdot on Facebook


Forgot your password?

Rust 1.6 Released ( 75

An anonymous reader writes: The Rust team has announced the release of version 1.6 of their programming language. The biggest new feature is that libcore — the Rust core library — is now stable. "Rust's standard library is two-tiered: there's a small core library, libcore, and the full standard library, libstd, that builds on top of it. libcore is completely platform agnostic, and requires only a handful of external symbols to be defined. Rust's libstd builds on top of libcore, adding support for memory allocation, I/O, and concurrency. Applications using Rust in the embedded space, as well as those writing operating systems, often eschew libstd, using only libcore." Other features worth noting: disallows wildcards for dependencies, there are a ton of stabilized APIs, timer functions that use milliseconds have been deprecated, and the parser will warn you if a failure was caused by Unicode characters that look similar but are interpreted differently.
This discussion has been archived. No new comments can be posted.

Rust 1.6 Released

Comments Filter:
  • New version (Score:3, Funny)

    by Anonymous Coward on Friday January 22, 2016 @02:21PM (#51352029)

    They have to introduce a new version every now and then because they run out of people to recommend Rust to. A new version allows them to recommend it to themselves in times of scarcity.

  • by Anonymous Coward
    We could call it CRust.
  • by 110010001000 ( 697113 ) on Friday January 22, 2016 @02:26PM (#51352065) Homepage Journal
    The Rust team has announced a new language, called Frick. This new language will build upon the lessons learned from Rust and provide the ability for developers to leverage security, the Cloud, and the IoT. Your knowledge of Rust is now obsolete and support for Rust has been dropped.
  • WTF? (Score:5, Insightful)

    by sunderland56 ( 621843 ) on Friday January 22, 2016 @02:28PM (#51352087)

    Since when is stability a feature? Isn't stability a basic requirement for software, especially in a programming language?

    If it takes up to release 1.6 for things to become stable, I'm probably not interested.

    • Re: (Score:2, Insightful)

      by Anonymous Coward

      If it takes up to release 1.6 for things to become stable...

      Libstd has been stable. This is equivalent to "libc" that C/C++ programmers are familiar with. This new "stability" is libcore, a minimal core library needed to compile. The GCC equivalent of this is the "low-level runtime library" (libgcc.a +

      This is important because many popular Rust projects targeting embedded hardware and operating systems have appeared. For these applications libstd is not desirable, and to date they've been relying on an unstable core. Now they have a stable libco

    • by HiThere ( 15173 )

      According to the link (to the rust site) several of the features of the core library are still marked as unstable. So either their documentation is out of date, of the core library still isn't stable.

    • No, except for compiler plugins, you can only compile code using stable interfaces with the official 1.6 release compiler. If you are on the nightly channel, you can use unstable things too. "unstable" is basically a playground to test features of a software before it gets "officially" included into the stable part of the language.

    • by narcc ( 412956 )

      Isn't stability a basic requirement for software, especially in a programming language?

      Apparently not. Just as an example, Python, the darling of Slashdot, can't even seem to maintain stability between minor versions. Just so you know I'm not picking on a fad language, consider that C# and other .NET has had countless breaking changes of the years. In the world of programming, fads and trends rule the day, stability be damned.

      Rust is bucking the trend. If you're looking for a reason to bash it (because no one should like something you don't like) look elsewhere. It's actually meeting your

  • Beware of Rust. (Score:5, Interesting)

    by Anonymous Coward on Friday January 22, 2016 @02:35PM (#51352141)

    The Rust home page makes it sound like Rust is some sort of a panacea. It leads one to believe that they'll get the power of C++, but with greater "safety".

    But the more I look into Rust, the more uneasy I start to feel.

    Despite all of the claims about how Rust is safer and leads to better code, the Rust compiler and standard library, both of which are implemented in Rust, are full of bugs []! Don't forget that this is Rust code written by people who ought to know Rust better than anyone else; they designed the language after all! If they can't write non-buggy Rust code, then we shouldn't expect less-talented Rust users to be able to do any better.

    It's also a big problem that there's only one implementation. If you run into a bug with it, and they don't fix it promptly, then you're likely fucked. At least with C++ there are multiple high quality implementations from different vendors. You can use GCC and Clang on most platforms. Then there are other systems like Intel C++, MSVC++, and so forth. You aren't left at the mercy of a single implementation when you use C++.

    The syntax of Rust is unremarkable. It's like a bad version of C++ in many ways. Its resource management approach is also inflexible and impractical, despite the claims that it's one of Rust's most significant benefits. You're typically better off using modern C++ techniques. You'll get just about the same amount of safety, but with much fewer headaches. Even C++'s standard library, which is not known for being very good, is often better than Rust's.

    It took them forever to get Rust 1.0 released. They were constantly changing their mind about anything and everything. While some evolution of a programming language is to be expected, all we saw from them was spastic thrashing about. It got so bad that you couldn't write code on a Monday and reliably have it compile by the following Friday! The fact that it took libcore up until release 1.6 to "stabilize" just goes to show how bad things were. The supposed "stable" release was full of non-stable interfaces!

    The Rust community gives me a particularly bad feeling. They're rather tyrannical about enforcing their code of conduct. They even have a moderation attack squad [] to go after anyone they deem to be an enemy! I've never seen this kind of orchestrated control exerted over the community of any other programming language. This sets off warning alarms for me.

    There's no reason to use Rust, in my opinion. You're better off with C++, or D, or Java, or Scala, or C#, or Go, or Swift, or one of the many other non-Rust languages out there. The language isn't very good, the standard libraries aren't very good, there's only one implementation, and the attitude of the community is downright frightening. I think you're better off not using Rust.

    • by e r ( 2847683 )
      1. It takes about ten years for any programming language to get good. Look at C++, Java, C# and everything else.
      2. Rust has a lot of really good ideas with a lot of potential.
      3. My only problem with it right now is that it seems like everything is wrapped in a promise so I end up calling "unwrap()" on just about every function call-- extremely obnoxious! This may just be a noob mistake on my part, perhaps with experience I'll learn idioms that obviate the need to "unwrap()" everything.
      • by mandolin ( 7248 )

        I agree, if we change "about ten years" to "at *least* ten years". Tongue only slightly in cheek. C++ took 25 years (C++11) to become, IMO, a compelling improvement over C.

        I disagree with basically everything the coward said -- particularly wrt the Rust community which I think is great -- but I don't use Rust (yet), either. The things that irk me the most about Rust are the lifetime annotations, the fact that it's non-trivial to write a linked-list implementation, and a few issues that will go away after

      • unwrap() is for prototyping; it's like a try/catch, but you just panic if something fails. Again, super handy for prototyping, but typically a mistake to use. Use try!() if you're writing a lib, or match (ie case switch) on the values returned by the function. Ones that can fail will usually return values wrapped in one of two enums: Err(val) or Ok(val). aka a Result The ones that can fail but don't return a Result will typicall return an Option... Same idea, data wrapped in one of two enums: None(), or S
        • In fact, its okay to use unwrap() if the Err case only appears on an internal error, where you'd assert() ed in C++.

    • by nmb3000 ( 741169 )

      Are you the same AC that was posting FUD about Rust [] the other day? A bunch of the same baseless complaints and the same reference to a "moderation attack squad".

      Don't forget that this is Rust code written by people who ought to know Rust better than anyone else; they designed the language after all! If they can't write non-buggy Rust code, then we shouldn't expect less-talented Rust users to be able to do any better.

      Nonsense. Being an expert in a language says nothing about how well you understand or can implement a solution for a given problem. If anything, that GitHub page should give someone reassurance that the project is actively maintained, that bugs are filed and solved (nearly 14,000 closed issues versus 2,300 open).

      It's also a big problem that there's only one implementation.

      Nonsense. This is called a referen []

    • by tgv ( 254536 )

      I've been toying with Rust, and I'm impressed. It's not a language for every application, but it's a good competitor for many.

      Of course there are bugs. Do you know how many bugs gcc has had? Gazillions. I remember sticking to 2.95 for a loooong time.

      The syntax is great. Why should it be remarkable? It's compact, and as readable as any other C-like syntax. And it has some great (semantic) features. Traits, iterators, function application, it's what C++ should have done instead of rely on STL.

      I haven't seen a

    • by Anonymous Coward

      But the more I look into Rust, the more uneasy I start to feel.

      Ok, this post is already a couple of days old, so it's unlikely that anyone will really read this response, but the above is a shining example of trolling and I'm bored enough that I'll feed the troll a bit, if only to bring the OP's technique to light. The hallmark of good trolling is the use of otherwise unremarkable facts in ways which are wildly out of context, disingenuous or dishonest, in order to further one's views, and the OP does it in spades. In this case, the goal is to denigrate everything abou

  • by UnknownSoldier ( 67820 ) on Friday January 22, 2016 @02:55PM (#51352323)

    We need to update Murphy's Laws for the new millennium:

    * "Those that don't understand C are condemned to re-invent it, poorly."

    Almost applies to every C derivative: C++, Rust, Obj-C, etc. /me ducks :-)

    With apologies to Henry Spencer's "Those who do not understand Unix are condemned to reinvent it, poorly."

    • by djbckr ( 673156 )

      Well, I'm not so sure I agree with that. Here's my take. I've taken a recent interest in Rust and Go. I've done C programming on and off for about 20 years along with quite a few other languages. I think C++ is just a big screw-up, and I appreciate what Rust is trying to accomplish. But, I don't think Rust is ready for prime-time yet and the development process seems really slow. I like the ideas they are coming up with. I think the trouble with it is that it doesn't seem to have a strong enough backing and

      • About habits of dropping things: I still do think its very bad that mozilla dropped its XUL framework. Probably windows users won't notice as their computers are turned into tablets with a mouse, but still I would appreciate if I had some xml based way to create native-like UI, and not the usual "web" stuff.

        So I hope that rust won't meet a similar fate.

    • I agree wholeheartedly with your comments for reinventions of C. However, I believe rust is going to be the surprise language of the decade. First, the fact that rust is changing does not bother me. It is a new language, after all. I just think they used the word "stable" too early. I am about 1/2 way through the rust book. I've had to learn some very new (to me) concepts but I would expect that from a language that claims genuinely new capabilites, and I now see how the promises of no segfaults and
      • I just think they used the word "stable" too early.

        Rust really changed heavily until May 2015 when 1.0 was released, so googling for common questions is very hard, as you get presented with largely outdated answers. So its really good they stabilized it, whatever now "stable" means. But the release 1.0 (or 1.6 or whatever) compiler only compiles stable interfaces. This way, 100% of your code can be compiled with stable rust.

    • Although Unix was not originally written in C (I had to look this up []), it was re-written and ported using C fairly early. Arguably, Spencer's aphorism is as much about C as Unix. I think we can regard C-like languages and *NIX operating systems as "brothers".

  • by Anonymous Coward

    There, I said what we're all thinking.

  • The biggest issue I have with Rust is the set of external libraries that you need to install with the Cargo tool. It isn't as much that we have the tool to install only the libraries you need, but going in the list of libraries. That are suppose to be in the approved repository, there are a lot of them with descriptions that makes me worry about using them.

  • In what ways is this programming language relevant again? My memory is a little rusty.

Order and simplification are the first steps toward mastery of a subject -- the actual enemy is the unknown. -- Thomas Mann