News for hackers. Stuff that matters.
Re:Lively Linear Lisp – 'Look Ma, No Garbage' (1992) by pjmlp on Saturday July 06, 2019 @12:26PM (#20370401)
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.
Re:Lively Linear Lisp – 'Look Ma, No Garbage' (1992) by pcwalton on Saturday July 06, 2019 @01:51PM (#20370847)
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

Re:Lively Linear Lisp – 'Look Ma, No Garbage' (1992) by pjmlp on Saturday July 06, 2019 @05:03PM (#20371943)
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.

Re:Lively Linear Lisp – 'Look Ma, No Garbage' (1992) by pcwalton on Saturday July 06, 2019 @05:06PM (#20371963)
We absolutely stand on the shoulders of giants here. Hopefully nobody will think that Rust invented substructural type systems.
Re:Lively Linear Lisp – 'Look Ma, No Garbage' (1992) by bch on Saturday July 06, 2019 @01:44PM (#20370805)
> 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, ... :)

Re:Lively Linear Lisp – 'Look Ma, No Garbage' (1992) by pjmlp on Saturday July 06, 2019 @05:04PM (#20371950)
There is a Rob Pike talk where he praises the compile times of the Algol compiler he was using as a student for example.
Re:Lively Linear Lisp – 'Look Ma, No Garbage' (1992) by fao_ on Tuesday July 09, 2019 @11:42AM (#20392883)
The TUHS mailing list is great for this
Re:Lively Linear Lisp – 'Look Ma, No Garbage' (1992) by bch on Tuesday July 09, 2019 @12:18PM (#20393389)
Re:Lively Linear Lisp – 'Look Ma, No Garbage' (1992) by p_l on Saturday July 06, 2019 @01:53PM (#20370862)
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.
Re:Lively Linear Lisp – 'Look Ma, No Garbage' (1992) by fao_ on Saturday July 06, 2019 @04:37PM (#20371783)
Can you give some examples?
Re:Lively Linear Lisp – 'Look Ma, No Garbage' (1992) by p_l on Saturday July 06, 2019 @05:20PM (#20372036)
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/7d7c6a97f815e9279d08cfae...)

Re:Lively Linear Lisp – 'Look Ma, No Garbage' (1992) by pjmlp on Saturday July 06, 2019 @05:05PM (#20371957)
Inferno and Limbo, for example.