Announcement

Collapse
No announcement yet.

Rust Gets A 2018 Roadmap, Big "Productivity" Edition Planned This Year

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

  • Luke_Wolf
    replied
    Originally posted by uid313 View Post
    Technically it seems like an amazing language with the things it offers, like it offers safety and security.
    But as a developer, it looks really tricky to use and with an awkward syntax reminiscent of Ruby, yuck.
    It's not C-Style syntax but I would be loathe to call it awkward, anyone who knows a language using C-Style syntax can quite easily piece together what is going on in Rust code and it is no harder to write than C-Style syntax, we're not exactly talking Lisp here. it's a really easy transition.

    Now on the other hand learning to write correct code is a pain in the ass, and that's the biggest challenge Rust gives you.

    Idiots who think that OOP is about class hierarchies will have to wake up to the fact that no that's not what it means (it means modelling your programs around real world objects and concepts, rather than focusing on the procedures), and everyone and their mother is using Interface-Based-Polymorphism nowadays instead, with traits being a vastly more powerful version of the interface concept... but again that's about learning to write correct code.

    Leave a comment:


  • Khrundel
    replied
    Looks like there will be some breaking changes. They mention opt-in editions, to use new features one must add edition="2018" to cargo.toml

    Leave a comment:


  • GunpowaderGuy
    replied
    Originally posted by mmstick View Post

    Compile-time executions & pi types won't make any existing features redundant. They solve different problems.
    ctfe can be used to build a borrow checker as a library ( https://medium.com/@bhuztez/emulate-...g-db4b5e94449f ); first class types can make generics redundant ( as explained in the zig programing language website ) , if my understanding is correct , both features coupled with first class modules can be used to emulate traits / classes ; and they also reduce the need for macros , directly ( again , as in zig ) , and indirectly ( no traits means no custom derive )

    Edit : almost forgot , cfte can also be used as a replacement for link time optimization , which cretonne is going to lack
    Last edited by GunpowaderGuy; 03-12-2018, 11:51 PM.

    Leave a comment:


  • mmstick
    replied
    Originally posted by GunpowaderGuy View Post
    thank you for sharing that ! Any idea what will happen to the soon to be redundant features ? Or which of the ones i mentioned have been discussed as being potentially redundant ?
    Compile-time executions & pi types won't make any existing features redundant. They solve different problems.

    Leave a comment:


  • GunpowaderGuy
    replied
    thank you for sharing that ! Any idea what will happen to the soon to be redundant features ? Or which of the ones i mentioned have been discussed as being potentially redundant ?
    Last edited by GunpowaderGuy; 03-12-2018, 09:48 PM.

    Leave a comment:


  • mmstick
    replied
    Originally posted by GunpowaderGuy View Post
    I wonder if they would accept some features such as compile time function execution and first class types ( aka https://ziglang.org/) with the goal of obsoleting many more ( macros , generics , procedural macros , maybe converting the implementation of traits and the borrow checker into libraries ) ; maybe in a future version 2.0 ?
    This is already being discussed / worked on. There's no need for a 2.0 release, because it can be fully implemented in a forward-compatible manner. The issues to watch are:

    - const generics: https://github.com/rust-lang/rust/issues/44580
    - const fn: https://github.com/rust-lang/rust/issues/24111
    - pi types: https://github.com/rust-lang/rfcs/issues/1930

    Leave a comment:


  • jacob
    replied
    Originally posted by GunpowaderGuy View Post
    I wonder if they would accept some features such as compile time function execution and first class types ( aka https://ziglang.org/) with the goal of obsoleting many more ( macros , generics , procedural macros , maybe converting the implementation of traits and the borrow checker into libraries ) ; maybe in a future version 2.0 ?
    Rust does have compile-time execution through procedural macros. It's not exactly easy to use or particularly well suited for simple cases such as pre-generating tables etc.; but it's there and many things can be built on top of it. The main shortcoming of Rust's type system is that it doesn't support HKTs as first class types in the way Haskell does. I would love to see this added. The rest of your points don't make much sense to me: the borrow checker is a static analysis pass built into the compiler, how exactly would you "convert that into a library"? Same thing for the traits?

    Leave a comment:


  • GunpowaderGuy
    replied
    I wonder if they would accept some features such as compile time function execution and first class types ( ala https://ziglang.org/) with the goal of obsoleting many more ( macros , generics , procedural macros , maybe converting the implementation of traits and the borrow checker into libraries ) ; maybe in a future version 2.0 ?
    Last edited by GunpowaderGuy; 03-12-2018, 09:33 PM.

    Leave a comment:


  • miabrahams
    replied
    Originally posted by uid313 View Post
    Technically it seems like an amazing language with the things it offers, like it offers safety and security.
    But as a developer, it looks really tricky to use and with an awkward syntax reminiscent of Ruby, yuck.
    The awkward syntax and brutal correctness requirements before the compiler will accept the code are the price you pay to ensure your code is correct when it compiles. You trade off time up front when writing code and the dividend is paid in the form of less debugging after the fact. This is a clear benefit to many projects. If your model is that Rust is "tricky to use" but C is "not tricky to use," then you don't know C very well.

    Leave a comment:


  • shmerl
    replied
    Doesn't remind me Ruby at all. Except may be for using | | in closures.

    Leave a comment:

Working...
X