rust-prehistory VS unix-history-repo

There’s a rust-prehistory repo preserving Rust’s compiler code at very early stage. You can see how Rust looks like at that time.

https://github.com/graydon/rust-prehistory is another good resource, particularly the doc/notes directory. All kinds of good stuff in there that looks pretty different than today. I also liked Marijn's talk, The Rust That Could Have Been.

There's also this repository depending how far back you want

If, on the other hand, you’re interested in pre-modern Rust, there’s always this repo: https://github.com/graydon/rust-prehistory

For some snapshots on the history of the language up to 1.0 check out: https://brson.github.io/archaea/. For some really ancient stuff check out the graydon/rust-prehistory/ repo. Also looking at the oldest commits and issues on the Rust repo can be pretty interesting. It's a great public resource.

As Graydon Hoare notes in the comments on GitHub this wasn't the first repo so the real history goes back even further. He's also shared a "prehistory" repo [1] which is interesting to browse. The first commit [2] in _that_ repo is from 2008 but Graydon mentions starting work back in 2006.

Anyway in a sense this repo represents Rust in the real world rather than in gestation, so seems apt to call it the birthday.

[1] https://github.com/graydon/rust-prehistory

[2] https://github.com/graydon/rust-prehistory/commit/1969e085e3...

Early Rust was very different (example). It is almost certain that modern Rust took a lot of cues from Go. And, as above, Go was obviously heavily inspired by C, just like your language. So, all told, where you landed is likely very much what is expected.

The pre-git history was imported as https://github.com/graydon/rust-prehistory

Two other links related to ancient Rust:

* https://github.com/graydon/rust-prehistory -> the code from before the rust-lang/rust repo

* https://youtube.com/watch?v=79PSagCD_AY -> a talk I gave around the 1.0 release giving my personal perspective on the history.

Oh heck, one more fun one: https://github.com/brson/archaea

There is also https://github.com/dspinellis/unix-history-repo (Continuous Unix commit history from 1970 until today)

FWIW, ls in Research-V6 back in 1975 had 10 options. https://github.com/dspinellis/unix-history-repo/blob/Researc...

By BSD 3 in 1980 it had 11 options. https://github.com/dspinellis/unix-history-repo/blob/BSD-3-S...

The thing is, we can see even from the 1970s 'ls' how the Unix model doesn't meet the goal "to chain these simple programs together to create complex behaviors".

There is no option to escape or NUL terminate a filename, making it possible to construct a filename containing a newline which makes the output look like two file entries.

The option for that was added later.

There's also the issue that embedded terminal codes will be interpreted by the terminal.

This is what it looked like about 7-8 years earlier: https://github.com/dspinellis/unix-history-repo/blob/BSD-1/e...

RA92 (1989): 16 ms / 8.3 ms.

Note that the RL02 (and V7) and RA92 mentioned in the article are separated by about a decade.

[1] https://github.com/dspinellis/unix-history-repo/blob/Researc...

The earliest version I could find [1] is already written in C.

[1] https://github.com/dspinellis/unix-history-repo/blob/Researc...

Here's a 1997 citation for "top cpu processes." It's not as close to the original 1984 release as I would like, but it's better than Wikipedia. https://github.com/dspinellis/unix-history-repo/commit/aee34003d7964653c44c31f5bf6bcf136b32c4f3

> The “why” goes into the PR and more importantly, engineering documentation and inline comments

This just ensures that the “why” is lost when someone comes looking years later.

From experience, SCM metadata is far more durable than just about any other work product we produce. Five decades later and RCS commit info was still available for the Unix sources, and history could be reconstructed: https://github.com/dspinellis/unix-history-repo

I’ve used 35-year-old commit messages to help understand a long-standing issue, decades after all other related organization tooling and data had disappeared.

P.S. I remember I looked into early versions of C (they survived in Unix historic releases) and that, finally, revealed to me why C does something really stupid and conflates arrays and slices (pointers). Initially C had no arrays! Or, rather, what it called arrays were, actually, pointers. “Normal” arrays were added at some point, but because these weird slices/pointers were already there that caused endless confusion. It wasn't resolved before C became popular and after that it was too late. Go repeated that mistake with slices, of course.