Interestingly, one of the pages you link (http://mumble.net/~jar/tproject/) links a paper (grep "1986: Kelsey dissertation on rewrite-based compilation ") that shows the implementation of a compiler with multiple frontends (BASIC, Scheme, Pascal) using only source-to-source) transformation.

I find this interesting because in a certain way, this reminds me of how the go assembler works (https://www.youtube.com/watch?v=KINIAgRpkDA).

For those who haven't seen the talk: basically the go compiler works on the assumption that pretty much all computer, in a way, move memory from one address to another, generate and handle interrupts, have call/return instructions and so on. Thus, the go compiler emits (IIRC) some sort of "intermediate assembler" (somehow similar to llvm's intermediate representation, but simpler) and then proceeds to "translate" such assembler to various platform native assembler. I clearly remember Rob Pike (in the talk) saying "so the task of supporting a new platform becomes a task in text processing" (okay, maybe it was worded a bit better).

This might be a bit tangential, but it is interesting how some "new" ideas aren't that new after all. But I guess this is due to Rob Pike's deep experience and history with computers.

There are some more bits of T-ness here: http://mumble.net/~campbell/t/ related to the T Revival Project, which itself is in need of reviving.

It says on the revival project page [1] that the plan was to make T R5RS compatible. That is probably why they abandoned T to make Scheme 48 [2]

I am also interested in the revival of this language, but I don't see what the point of that would be. Does anyone here feel the same way?

[1] http://web.archive.org/web/20070103020434/http://mumble.net/...

[2] http://s48.org/

It was verified as part of VLISP project. So, I've been keeping papers on PreScheme, Scheme48, and VLISP in case anyone wants to redo them with modern techniques. Another commenter, hga, helped me find a few I didn't have before with the specific algorithms. The basic ones are on the bottom here:

https://en.wikipedia.org/wiki/PreScheme

PreScheme itself is possibly worth reviving esp with ref counting or Rust's type of no-GC safety. I know another LISP, Carp, is trying to do something like the latter.

Thanks for the reminder, I loved rereading this article.

Even though I read this years ago, I'm still having vertigo when reading the last part. So many people, so many ideas .. so much inspiration.