4 ms·

> These quotes foreshadow the goals of Rust 20 years later, whose eventual intent was to realize both the doesn't-require-a-garbage-collector property of linear

> These quotes foreshadow the goals of Rust 20 years later, whose eventual intent was to realize both the doesn't-require-a-garbage-collector property of linear logic with the efficiently-sharing-data-is-still-possible property of traditional systems languages by separating these concepts into ownership (covering the former) and borrowing (covering the latter, and built on top of ownership). The idea of borrowing is not original to Rust in any way, and is found from the first application of linear logic to PL type systems in Wadler's "Linear types can change the world!" onward, including Vault, Cyclone, etc. Any system without it would be impractical for writing real programs.

pjmlp 7y ago
It appears that just like there are those that think C was the genesis of systems programming, with very little attention being given to what happened 15 years earlier and beyond Bell Labs walls, in 20 years from now same might apply to Rust and the languages that were its inspiration.
- bch 7y ago
  > It appears that just like there are those that think C was the genesis of systems programming, with very little attention being given to what happened 15 years earlier This is why I think it’s important to get familiar and listen to Old Masters like Rob Pike, Brian Kernighan, John Ousterhout, and even war stories of Richard Stallman, and chase down their references and get familiar with them, too. It’s not that there’s nothing left to do, but an awful lot has been done. We can at least learn from it... > and beyond Bell Labs walls As I cite Pike, Kernighan, ... :)
  - pjmlp 7y ago
    There is a Rob Pike talk where he praises the compile times of the Algol compiler he was using as a student for example.
  - fao_ 7y ago
    The TUHS mailing list is great for this
    - bch 7y ago
      The Unix Heritage Society - https://minnie.tuhs.org/mailman/listinfo/tuhs https://minnie.tuhs.org/mailman/listinfo/tuhs
- pcwalton 7y ago
  Rust does have some theoretical innovations, however. Probably the most significant one that comes to mind is the solution to the problem posed in Dan Grossman's "Existential Types for Imperative Languages". A simple example of the problem: taking a reference to the value inside an Option is unsafe if the Option gets mutated and invalidates that reference. Previous solutions like Cyclone just disallowed taking those kinds of references entirely, or had only immutable data, both of which are way too restrictive. Rust's innovation was to track immutability vs. aliasing at a fine-grained level per use site via uniqueness paths to solve this specific problem (which ends up solving a whole bunch of other problems too). I'm not claiming the techniques are novel (borrowing rules are similar to fractional permissions for example), but I'm not aware of their application to this specific problem prior to Rust. (I could be wrong though! There's a lot of work on substructural type systems out there.) For a good overview of the prior art and how Rust relates, section 1.1 of the RustBelt paper goes into detail: https://plv.mpi-sws.org/rustbelt/popl18/paper.pdf https://plv.mpi-sws.org/rustbelt/popl18/paper.pdf
  - pjmlp 7y ago
    You guys are doing a bunch of research bringing affine types to mainstream, to the point that other languages are paying attention and copying your efforts to the extent their languages allow it, even if there are some bumps still. My point was more towards to future generations being unaware of such ideas that eventually came into Rust. For example, as you describe Cyclone had its issues. Still if Cyclone did not exist, probably Rust as idea would never happen. Same applies to ATS, and all other languages that served as inspiration for an idea that eventually became Rust, and then took a path of its own.
    - pcwalton 7y ago
      We absolutely stand on the shoulders of giants here. Hopefully nobody will think that Rust invented substructural type systems.
- p_l 7y ago
  A lot of people who think of C as genesis and end of systems programming also tend to ignore what was done in Bell Labs, too... even by the team behind C.
  - fao_ 7y ago
    Can you give some examples?
    - pjmlp 7y ago
      Inferno and Limbo, for example.
    - p_l 7y ago
      Like sibling comment noted, Inferno and Limbo. Then there's Alef, Newspeak, Bell Labs fork of C (separate from ISO C if mostly compatible), few other languages I believe, the whole original Unix phhilosophy often is forgotten as well... I recall Brian Kernighan alluding to some of this in his humorous (but true!) mention of "first Go commit" (https://github.com/golang/go/commit/7d7c6a97f815e9279d08cfaea7d5efb5e90695a8 https://github.com/golang/go/commit/7d7c6a97f815e9279d08cfae...)
kibwen 7y ago
At no point did I allege that the idea of borrowing was original to Rust. :P We both contributed to Rust at the same time, Cameron! You know well that nobody involved with the creation of the language had any qualms about acknowledging prior art. :)

pjmlp 7y ago

It appears that just like there are those that think C was the genesis of systems programming, with very little attention being given to what happened 15 years earlier and beyond Bell Labs walls, in 20 years from now same might apply to Rust and the languages that were its inspiration.

bch 7y ago
> It appears that just like there are those that think C was the genesis of systems programming, with very little attention being given to what happened 15 years earlier This is why I think it’s important to get familiar and listen to Old Masters like Rob Pike, Brian Kernighan, John Ousterhout, and even war stories of Richard Stallman, and chase down their references and get familiar with them, too. It’s not that there’s nothing left to do, but an awful lot has been done. We can at least learn from it... > and beyond Bell Labs walls As I cite Pike, Kernighan, ... :)
- pjmlp 7y ago
  There is a Rob Pike talk where he praises the compile times of the Algol compiler he was using as a student for example.
- fao_ 7y ago
  The TUHS mailing list is great for this
  - bch 7y ago
    The Unix Heritage Society - https://minnie.tuhs.org/mailman/listinfo/tuhs https://minnie.tuhs.org/mailman/listinfo/tuhs
pcwalton 7y ago
Rust does have some theoretical innovations, however. Probably the most significant one that comes to mind is the solution to the problem posed in Dan Grossman's "Existential Types for Imperative Languages". A simple example of the problem: taking a reference to the value inside an Option is unsafe if the Option gets mutated and invalidates that reference. Previous solutions like Cyclone just disallowed taking those kinds of references entirely, or had only immutable data, both of which are way too restrictive. Rust's innovation was to track immutability vs. aliasing at a fine-grained level per use site via uniqueness paths to solve this specific problem (which ends up solving a whole bunch of other problems too). I'm not claiming the techniques are novel (borrowing rules are similar to fractional permissions for example), but I'm not aware of their application to this specific problem prior to Rust. (I could be wrong though! There's a lot of work on substructural type systems out there.) For a good overview of the prior art and how Rust relates, section 1.1 of the RustBelt paper goes into detail: https://plv.mpi-sws.org/rustbelt/popl18/paper.pdf https://plv.mpi-sws.org/rustbelt/popl18/paper.pdf
- pjmlp 7y ago
  You guys are doing a bunch of research bringing affine types to mainstream, to the point that other languages are paying attention and copying your efforts to the extent their languages allow it, even if there are some bumps still. My point was more towards to future generations being unaware of such ideas that eventually came into Rust. For example, as you describe Cyclone had its issues. Still if Cyclone did not exist, probably Rust as idea would never happen. Same applies to ATS, and all other languages that served as inspiration for an idea that eventually became Rust, and then took a path of its own.
  - pcwalton 7y ago
    We absolutely stand on the shoulders of giants here. Hopefully nobody will think that Rust invented substructural type systems.
p_l 7y ago
A lot of people who think of C as genesis and end of systems programming also tend to ignore what was done in Bell Labs, too... even by the team behind C.
- fao_ 7y ago
  Can you give some examples?
  - pjmlp 7y ago
    Inferno and Limbo, for example.
  - p_l 7y ago
    Like sibling comment noted, Inferno and Limbo. Then there's Alef, Newspeak, Bell Labs fork of C (separate from ISO C if mostly compatible), few other languages I believe, the whole original Unix phhilosophy often is forgotten as well... I recall Brian Kernighan alluding to some of this in his humorous (but true!) mention of "first Go commit" (https://github.com/golang/go/commit/7d7c6a97f815e9279d08cfaea7d5efb5e90695a8 https://github.com/golang/go/commit/7d7c6a97f815e9279d08cfae...)

kibwen 7y ago

At no point did I allege that the idea of borrowing was original to Rust. :P We both contributed to Rust at the same time, Cameron! You know well that nobody involved with the creation of the language had any qualms about acknowledging prior art. :)