5 ms·

It's been really cool watching the design and development of the new error messages from the outside. There was significant inspiration drawn from the Elm langu

It's been really cool watching the design and development of the new error messages from the outside. There was significant inspiration drawn from the Elm language's fantastic error messages [1] and even a project that provided something similar (but not built into rustc) [2]. I've always thought that Rust's command line tooling is really top notch. The language may be complex, but the authors of rustc make it a point of pride to make it as easy as possible for users anyway. The new errors will make it that much easier to learn and be productive in Rust. Also, the community involvement in this release is really spectacular. There were 83 participants working together on the new error messages [3] and 176 total involved directly with the rust compiler just for 1.12! (ok, well, including a few bots) [1] https://internals.rust-lang.org/t/compiler-errors-for-humans/2310/10 https://internals.rust-lang.org/t/compiler-errors-for-humans... [2] https://www.reddit.com/r/rust/comments/3totkg/dybuk_the_elmlike_rustc_error_pretty_printer/ https://www.reddit.com/r/rust/comments/3totkg/dybuk_the_elml... [3] https://github.com/rust-lang/rust/issues/35233 https://github.com/rust-lang/rust/issues/35233

santaclaus 10y ago
> The language may be complex Compared to what? Edit: This was not meant as a slight, I quite like Rust's comapritive simplicity when held up to other non-GC 'systems' languages.
- duaneb 10y ago
  To answer you seriously—I think a great contrast would be the simplicity of Go. The GC and type system are both the opposite of providing complexity to the user; they provide the only way to get anything done, and it's easy to keep in your head. For the record, I prefer rust.
  - ffggvv 10y ago
    I would like to switch from go to rust. But rust's standard library isn't as mature as that of go. Do you think there are compatible crates to packages from go's standard library. I need * json/gzip/etc. * string manipulation * good unicode support (normalization, etc.) not much actually. And one important question: which one do you think is best for large projects? Both were built to deal with difficulties rising from large projects but took two opposite directions...
    - clarkmoody 10y ago
      Rust has a nice standard library, but much nice functionality comes from external crates. If you haven't yet, you should check out the Cargo tutorial[1], which is an intro to the package management and build system. I have used a JSON library, which worked well out of the box. I'm sure there are others up there for your other bullets. I will say that all strings in Rust are Unicode, so the support is there. Edit to your question about large projects: I think Rust's type system will prove to be a long-term benefit for large projects. The type system / borrow checker combination is the secret sauce of Rust. [1] http://doc.crates.io/index.html http://doc.crates.io/index.html
    - steveklabnik 10y ago
      * https://crates.io/crates/serde_json [1] * https://crates.io/crates/flate2 * https://crates.io/crates/unicode-normalization "String manipulation" is a bit broad, but Rust's string types are already pretty rich. [1]: small caveat here: this crate works on stable, but is more convenient on nightly. (Think "right now it's "go generate" but eventually it will be easier than that). We're close to stabilizing the stuff that it needs to be convenient on stable, but the earliest that could land in stable is Dec 22. (I just did this math yesterday.)
    - timClicks 10y ago
      The Rust stdlib is indeed quite a bit slimmer, largely by design AFAICT. String manipulation and Unicode sopport are very much there. Serde (https://serde.rs/ https://serde.rs/) is probably what you're looking for for serialization tasks.
    - pcwalton 10y ago
      > But rust's standard library isn't as mature as that of go. I'm not really sure that's true. Rust probably has a smaller standard library overall, but there are things that it has that Go doesn't: B-trees, native OS string encodings, functional tools, round(), etc. The bigger point is that the crates.io ecosystem readily has support for everything you're asking for, and it's much easier to pull in third-party dependencies in Rust.
      - 10y ago
- Thaxll 10y ago
  Everything besides C and C++.
  - sidlls 10y ago
    C is considerably less complex than either Rust or C++.
    - pjmlp 10y ago
      By those that use a single compiler, on a single OS and never had to deal with UB bugs.
      - sidlls 10y ago
        I regularly have used more than one compiler (Borland, cc, early Microsoft, and one or two other proprietary ones for developing drivers for embedded optics controllers), programmed for more than one OS (Linux, a RTOS flavor of Linux, MS, Apple, AIX), and have seen my fair share of UB issues. What you're referring to (programs and behaviors) is not what I was referring to (language details).
        tatterdemalion 10y ago
        I don't understand how implementation-defined and undefined behavior are not a part of the language semantics. They're specified in the language standard, and they determine how the program code will be compiled. They're clearly part of the language. The pretense that C is a simple language is equivocation, in my opinion.
        sidlls 10y ago
        Hmmm, that's a fair point, since "which C" applies, but I think that's a deficiency in the standard and larger in scope than the point I intended.
        10y ago
- nickpsecurity 10y ago
  Modula-3 with a concurrent, low-latency GC + static analysis on anything declared unsafe. That's first example that comes to mind. It nicely balanced safety, compilation speed, productivity, and runtime performance. SPIN OS was written in it that leveraged type-safe linking + its safety to pull user add-ons straight into the kernel without crashes. CVSup for FreeBSD was originally done in it as well with development experience so good vs C++ that author didn't want to give it up. https://en.wikipedia.org/wiki/Modula-3 https://en.wikipedia.org/wiki/Modula-3 So, that's my baseline if we're excluding functional programming elements. Maybe that with Design-by-Contract and SCOOP from Eiffel. I'd add borrow checker from Rust for unsafe sections as an option. Past that, you've already knocked out vast majority of issues while retaining rapid development. If functional programming, I'd start with a PreScheme (C replacement), bring it closer to Racket on static or dynamic side for power, build in safety analysis, and sugar coat it with nice syntax + standard library. Julia language did something similar to that approach with femtolisp at the core. Also easy to read and learn for a language so powerful. I currently recommend Rust over most C alternatives due to the attributes in its motto plus strong community (most important) around it. The simpler alternatives in this niche got little traction for various reasons that are more social or economic than technical. So, if you're jumping on a wave, might as well pick the one that's safe and fast by default.
- sidlls 10y ago
  I think the rust compiler's enforcement of borrowing and explicit mutability make writing non-trivial Rust code as complicated as writing the same program with code that has equivalent safety (which isn't enforced) in C++. The biggest issues I've seen lie at the safe/unsafe boundary. Things that are trivial to write without safety guarantees in C++ become more verbose (at least) in Rust.
  - pjmlp 10y ago
    But that is a common feature to Ada, Modula-3, Oberon derivatives, even Frama-C. On one hand we need to still be able to do low-level stuff on "as needed" basis, but on the other hand it needs to be hard and explicit so that route is only taken as least resort and very easy to track down, even without help from tools.
- allengeorge 10y ago
  It's...not an easy language. Not unapproachable by any stretch, but it's got surface area. The thing that (currently) trips me up the most is figuring out when when I've to dereference something, and why, when I've to pass a reference to something and why, etc. Sometimes I do end up with a touch of operator soup.
  - tatterdemalion 10y ago
    > The thing that (currently) trips me up the most is figuring out when when I've to dereference something, and why, when I've to pass a reference to something and why, etc. Sometimes I do end up with a touch of operator soup. This is a very common experience! One of the goals this year is to ease this painpoint.

santaclaus 10y ago

> The language may be complex Compared to what? Edit: This was not meant as a slight, I quite like Rust's comapritive simplicity when held up to other non-GC 'systems' languages.

duaneb 10y ago
To answer you seriously—I think a great contrast would be the simplicity of Go. The GC and type system are both the opposite of providing complexity to the user; they provide the only way to get anything done, and it's easy to keep in your head. For the record, I prefer rust.
- ffggvv 10y ago
  I would like to switch from go to rust. But rust's standard library isn't as mature as that of go. Do you think there are compatible crates to packages from go's standard library. I need * json/gzip/etc. * string manipulation * good unicode support (normalization, etc.) not much actually. And one important question: which one do you think is best for large projects? Both were built to deal with difficulties rising from large projects but took two opposite directions...
  - clarkmoody 10y ago
    Rust has a nice standard library, but much nice functionality comes from external crates. If you haven't yet, you should check out the Cargo tutorial[1], which is an intro to the package management and build system. I have used a JSON library, which worked well out of the box. I'm sure there are others up there for your other bullets. I will say that all strings in Rust are Unicode, so the support is there. Edit to your question about large projects: I think Rust's type system will prove to be a long-term benefit for large projects. The type system / borrow checker combination is the secret sauce of Rust. [1] http://doc.crates.io/index.html http://doc.crates.io/index.html
  - steveklabnik 10y ago
    * https://crates.io/crates/serde_json [1] * https://crates.io/crates/flate2 * https://crates.io/crates/unicode-normalization "String manipulation" is a bit broad, but Rust's string types are already pretty rich. [1]: small caveat here: this crate works on stable, but is more convenient on nightly. (Think "right now it's "go generate" but eventually it will be easier than that). We're close to stabilizing the stuff that it needs to be convenient on stable, but the earliest that could land in stable is Dec 22. (I just did this math yesterday.)
  - timClicks 10y ago
    The Rust stdlib is indeed quite a bit slimmer, largely by design AFAICT. String manipulation and Unicode sopport are very much there. Serde (https://serde.rs/ https://serde.rs/) is probably what you're looking for for serialization tasks.
  - pcwalton 10y ago
    > But rust's standard library isn't as mature as that of go. I'm not really sure that's true. Rust probably has a smaller standard library overall, but there are things that it has that Go doesn't: B-trees, native OS string encodings, functional tools, round(), etc. The bigger point is that the crates.io ecosystem readily has support for everything you're asking for, and it's much easier to pull in third-party dependencies in Rust.
    - 10y ago
Thaxll 10y ago
Everything besides C and C++.
- sidlls 10y ago
  C is considerably less complex than either Rust or C++.
  - pjmlp 10y ago
    By those that use a single compiler, on a single OS and never had to deal with UB bugs.
    - sidlls 10y ago
      I regularly have used more than one compiler (Borland, cc, early Microsoft, and one or two other proprietary ones for developing drivers for embedded optics controllers), programmed for more than one OS (Linux, a RTOS flavor of Linux, MS, Apple, AIX), and have seen my fair share of UB issues. What you're referring to (programs and behaviors) is not what I was referring to (language details).
      - tatterdemalion 10y ago
        I don't understand how implementation-defined and undefined behavior are not a part of the language semantics. They're specified in the language standard, and they determine how the program code will be compiled. They're clearly part of the language. The pretense that C is a simple language is equivocation, in my opinion.
        sidlls 10y ago
        Hmmm, that's a fair point, since "which C" applies, but I think that's a deficiency in the standard and larger in scope than the point I intended.
        10y ago
nickpsecurity 10y ago
Modula-3 with a concurrent, low-latency GC + static analysis on anything declared unsafe. That's first example that comes to mind. It nicely balanced safety, compilation speed, productivity, and runtime performance. SPIN OS was written in it that leveraged type-safe linking + its safety to pull user add-ons straight into the kernel without crashes. CVSup for FreeBSD was originally done in it as well with development experience so good vs C++ that author didn't want to give it up. https://en.wikipedia.org/wiki/Modula-3 https://en.wikipedia.org/wiki/Modula-3 So, that's my baseline if we're excluding functional programming elements. Maybe that with Design-by-Contract and SCOOP from Eiffel. I'd add borrow checker from Rust for unsafe sections as an option. Past that, you've already knocked out vast majority of issues while retaining rapid development. If functional programming, I'd start with a PreScheme (C replacement), bring it closer to Racket on static or dynamic side for power, build in safety analysis, and sugar coat it with nice syntax + standard library. Julia language did something similar to that approach with femtolisp at the core. Also easy to read and learn for a language so powerful. I currently recommend Rust over most C alternatives due to the attributes in its motto plus strong community (most important) around it. The simpler alternatives in this niche got little traction for various reasons that are more social or economic than technical. So, if you're jumping on a wave, might as well pick the one that's safe and fast by default.
sidlls 10y ago
I think the rust compiler's enforcement of borrowing and explicit mutability make writing non-trivial Rust code as complicated as writing the same program with code that has equivalent safety (which isn't enforced) in C++. The biggest issues I've seen lie at the safe/unsafe boundary. Things that are trivial to write without safety guarantees in C++ become more verbose (at least) in Rust.
- pjmlp 10y ago
  But that is a common feature to Ada, Modula-3, Oberon derivatives, even Frama-C. On one hand we need to still be able to do low-level stuff on "as needed" basis, but on the other hand it needs to be hard and explicit so that route is only taken as least resort and very easy to track down, even without help from tools.
allengeorge 10y ago
It's...not an easy language. Not unapproachable by any stretch, but it's got surface area. The thing that (currently) trips me up the most is figuring out when when I've to dereference something, and why, when I've to pass a reference to something and why, etc. Sometimes I do end up with a touch of operator soup.
- tatterdemalion 10y ago
  > The thing that (currently) trips me up the most is figuring out when when I've to dereference something, and why, when I've to pass a reference to something and why, etc. Sometimes I do end up with a touch of operator soup. This is a very common experience! One of the goals this year is to ease this painpoint.