3 ms·
> Rust, C++, Haskell, Scala will never be good at that because they're too damn complicated (although each of them make the nasty parts a little less painful!)
by pcwalton 12y ago
> Rust, C++, Haskell, Scala will never be good at that because they're too damn complicated (although each of them make the nasty parts a little less painful!)
Why is Rust too complicated to allow you to do low-level hacking?
- eloff 12y agoI mean too complicated for writing, reading, and maintaining and generally just working with from day to day. It costs too much time to do the same thing.
- pcwalton 12y agoAgain, what specifically? I ask because this has not been my experience writing several hundreds of thousands of lines of Rust code, nor has this been the experience of anyone I have helped get up to speed. Moreover, I believe there is no feature in Rust that is not necessary to achieve safety without sacrificing performance.
- cantankerous 12y agoHundreds of thousands of lines of Rust? Out of curiosity, what kind of software are you writing in Rust? ... And can I get in on some of that? ;-)
- Ygg2 12y ago> Hundreds of thousands of lines of Rust Just a very concurrent browser engine ;) One that does everything in parallel. Basically every task that can be parallelized becomes parallel (rendering, JS execution, CSS matcher, etc.). Also you can, there is Github for Servo (said parallel browser engine project by Mozilla). https://github.com/mozilla/servo/wiki/Design https://github.com/mozilla/servo/wiki/Design
- dbaupp 12y agoThe compiler and Mozilla's experimental rending engine Servo: - https://github.com/rust-lang/rust/ https://github.com/rust-lang/rust/ - https://github.com/mozilla/servo/ https://github.com/mozilla/servo/ (The 'contributors' graphs suggest that pcwalton has added/removed more than 1 million lines of code in those two repos combined.)
- asattarmd 12y agoThe Rust compiler :) He is part of the Rust team and writes Servo.
- coldtea 12y agoCan you be any more vague?
- axaxs 12y agoI don't think it's bad, but to me(and only to me), disappointing. I'm a long time mozilla fan...heck a Netscape fan really. Go was a pleasure to learn, there were no 'gotchas' initially...just a small, easy to reason about language. Rust...with its arrows, angle brackets, pattern matching, etc. seemed just so complex to fit in my brain. I'd love to be proven wrong and try again, but the docs aren't the best. And I know Rust isn't 'released' yet. But if you are defending it, I feel like it should be at a very learnable state. Do you have plans for a 'tour', for a play by play like Go offers that can bring others up to speed? Further(and this is really reaching while I got you)... my favorite part is cross compilation and being able to deploy a single binary anywhere. I tried to compile something in rustc once, but when I moved it to an older box, it failed to run. Will rust offer such stable static compilation in the future?
- coldtea 12y ago>Rust...with its arrows, angle brackets, pattern matching, etc. seemed just so complex to fit in my brain. It's 2014 already. Angle brackets, arrows, and pattern matching are 1990 level language technology. Heck, even a dynamic front-end language like Coffescript has these kind of things nowadays.
- axaxs 12y agoI'm not saying you're wrong nor will I argue about it as in the end it really comes down to taste I feel. To me, and perhaps to others, these things make a language harder to read/use, regardless of how pervasive...
- coldtea 12y agoWhile some of it can come to taste, I think having higher abstractions (as long as they don't leak) is beneficial to reading/using a language. Like, objectively. And foreach vs for is not a leaky abstraction. Nor is pattern matching vs traditional checking and extracting the values. So their value is not geting lost on having corner cases that the equivalent "based on primitives" code wouldn't have. If anything they make the operation even more explicit. So I think a lot of it comes down to getting familiar with them. While something made of "first principles" might be more instantly familiar, it will be harder to reason about because of its low-level ness as the code size increases. Case in point, assembly. It's quite primitive language with very few constructs, so it's easy to learn to use. But an actual high level "if" or function call is much easier to grasp at once than checking 10-20 lines that implement the same thing in assembly (even if you have trained yourself to see the assembly "pattern" for a function call, etc).