Announcement

Collapse
No announcement yet.

Rust 1.21 Released With Minor Updates

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts

  • Rust 1.21 Released With Minor Updates

    Phoronix: Rust 1.21 Released With Minor Updates

    For fans of the Rust "safe, concurrent, practical systems language", the Rust 1.21 update is available today with some modest updates and additions...

    Phoronix, Linux Hardware Reviews, Linux hardware benchmarks, Linux server benchmarks, Linux benchmarking, Desktop Linux, Linux performance, Open Source graphics, Linux How To, Ubuntu benchmarks, Ubuntu hardware, Phoronix Test Suite

  • #2
    Rust technically seems amazing.
    It's just too bad about the ugly syntax. It looks way too much like Ruby, eww.

    Comment


    • #3
      Originally posted by uid313 View Post
      Rust technically seems amazing.
      It's just too bad about the ugly syntax. It looks way too much like Ruby, eww.
      Now that I've been learning Rust, I don't find it's syntax that ugly. Originally it looked odd indeed, but now when I know what it means, it is not that bad at all. BTW I've never written any Ruby at all.

      Comment


      • #4
        Originally posted by uid313 View Post
        Rust technically seems amazing.
        It's just too bad about the ugly syntax. It looks way too much like Ruby, eww.
        Every syntax choice has been made based on how well it can explicitly express the intent of the action being performed though. As a systems language, there's really no other syntax that would suitably convey all the information that Rust's syntax is currently conveying. After all, we spend more time reading code than writing it, so the less ambiguity in syntax, the better. About all you could change are which characters to convey what information.

        Although I don't see how it looks like Ruby. Ruby's syntax looks more like Python than Rust, which looks kind of like a functional, modern day C++.

        Comment


        • #5
          Originally posted by mmstick View Post
          Although I don't see how it looks like Ruby. Ruby's syntax looks more like Python than Rust, which looks kind of like a functional, modern day C++.
          I looked into what Ruby looks like and I must agree with this.

          Comment


          • #6
            For some insight on what the Rust community is doing at the moment, a lot of work is being put into the current impl period event.

            - Week 1 Newsletter
            - Week 2 Newsletter

            The major focuses at the moment are:

            1. Faster compile times & improved incremental compilation
            2. Finally implementing Non-Lexical Lifetimes
            3. Making Lifetimes easier to work with, in general
            4. Stabilizing SIMD support
            5. Improving bindgen
            6. Improving docs & stabilizing the most popular crates
            7. Various improvements to Rust's book, documentation, cargo, rustup, RLS, etc.
            8. Quickly pushing through and implementing accepted RFCs

            Overall, it's a very well-coordinated effort.

            Comment


            • #7
              Originally posted by mmstick View Post

              Every syntax choice has been made based on how well it can explicitly express the intent of the action being performed though. As a systems language, there's really no other syntax that would suitably convey all the information that Rust's syntax is currently conveying. After all, we spend more time reading code than writing it, so the less ambiguity in syntax, the better. About all you could change are which characters to convey what information.

              Although I don't see how it looks like Ruby. Ruby's syntax looks more like Python than Rust, which looks kind of like a functional, modern day C++.
              Yes, I get that the typing system would need to be a bit different from what I am used to.
              Even so, I find the syntax a bit weird.
              I don't like the implicit returns. I like explicit return statements.
              Also I am not sure what a `impl` is, everything is abbreviated.
              Like is `impl` a class, trait or interface?

              Comment


              • #8
                Originally posted by uid313 View Post

                Yes, I get that the typing system would need to be a bit different from what I am used to.
                Even so, I find the syntax a bit weird.
                I don't like the implicit returns. I like explicit return statements.
                Also I am not sure what a `impl` is, everything is abbreviated.
                Like is `impl` a class, trait or interface?
                Impl is implement. A lot of things are abbreviated in other languages. int, bool, var, etc, func, ifdef, etc.. I think it's more consistent (like why in Java you say boolean for boolean but int for integer int or in js, why variable is var but function is function). Just my thoughts.

                Comment


                • #9
                  Rust is more functional, and if you've done any functional programming with Lisp, Haskell, Clojure, Scala, even Swift, Ruby or Python, you should be in friendly territory. I'm not sure I would call the Syntax Ruby-like. It seems closer to C++ with lambdas, and the let expression is similar to Haskell, so functional programming again.

                  Comment


                  • #10
                    Originally posted by mmstick View Post

                    Every syntax choice has been made based on how well it can explicitly express the intent of the action being performed though. As a systems language, there's really no other syntax that would suitably convey all the information that Rust's syntax is currently conveying. After all, we spend more time reading code than writing it, so the less ambiguity in syntax, the better. About all you could change are which characters to convey what information.

                    Although I don't see how it looks like Ruby. Ruby's syntax looks more like Python than Rust, which looks kind of like a functional, modern day C++.
                    I don't really have a problem with Rust's syntax but that's overstating the case by far. There really isn't a reason that for example
                    Code:
                    fn foo(bar:i32) -> i32 {
                        //stuff
                    }
                    is intrinsically any better than
                    Code:
                    i32 foo(i32 bar) {
                        //stuff
                    }
                    at conveying the important information, it arguably looks prettier but there isn't some objective advantage to this. Similarly anywhere else it breaks from C-Style syntax where features are equivalent. Obviously Rust enums, match expression, the way the impl/type system stuff works, and other rust specific features require their own special syntax, but it's just a bit much to declare Rust syntax the only way to go.
                    Last edited by Luke_Wolf; 13 October 2017, 03:51 AM.

                    Comment

                    Working...
                    X