Texas Instruments on Scheme (1984) | Hacker News Reader

Texas Instruments on Scheme (1984)

groups.csail.mit.edu

65 pointssoegaard13 comments

Really good article. Interesting to see what the issues were with Scheme back then. Funny that they loved continuations, but still hadn't figured out how to do them "in the general case". It is the general case of continuations that makes Scheme inefficient, just like lazy evaluation is Haskell's Achilles heel.

The TI comments about lexical and dynamic scoping are also interesting; makes me appreciate how newLisp dealt with it. Although newLisp is officially "dynamically" scoped, I recently realized that Lutz snuck Lexical scoping in there; the dynamic scoping is actually limited by the lexical scope. And by Lexical scope, I'm not talking about the context/module system, although that is a part of it. I mean real lexical scope.

If not for continuations, I wonder if Scheme would have taken off more than it has. Also it was interesting seeing that T and NIL hadn't become #true and #false yet.

I don't think the author was talking about the general case of continuations -- he was talking about the general case of unwind-protect in the presence of continuations -- what Schemers nowadays call dynamic-wind.

Some schemes now have delimited continuations [1], and with Dybvig behind the wheel of Chez scheme I wouldn't be surprised if they show up there as well.

It is a superior construct in every way. The performance and memory usage, even for the simplest usage, is way better, and because they are delimited they are easier to reason about.

1: guile, scheme48, racket's scheme lang (using rackets native delimited continuations together with their r6rs Lang)

Thanks for the reference, I'll look into that. How does the performance and memory usage of deliminted continuations compare to implementing the control flow constructs directly?

Which are you comparing to? They are quite specialised, and are probably expensive as far as control operators go, but delimited continuations beat undelimited continuations every day of the week.

I remember benchmarking the coroutine generator from srfi-125 (??), and already for the simplest case the delimited continuations in guile (compared to the undelimited ones in the reference implementation) were about 3x faster.

Is Scheme still used by Texas Instruments?

Cadence SKILL, which is heavily influenced by Scheme, is still actively used to extend functionality of the EDA tools. Other languages commonly seen used in TI is Perl, Tcl, C (obviously), assembly and Python.

Thanks for info.

Cadence? Any relation to Chez Scheme?

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

(Look at the box at the right?)

Don't think so. Here, Cadence refers to "Cadence Design Systems". "Cadence Research Systems" seems less clear. In any case, Chez Scheme was the long-term project of Kent Dybvig.

SKILL is such a weird language. It tries to be both a C and a Scheme, and ends up at a surprisingly ok compromise. I quite enjoyed working with it, which was beneficial since most of my colleagues did not...

Cadence has two separate languages, SKILL and SKILL++, using the same runtime. SKILL is derived from Franz Lisp, which is dynamically scoped. SKILL++ is influenced by Scheme. SKILL++ has lexical scoping and has an object system. Both languages allow a postfix notation that makes it superficially familiar to non-Lisp languages. IMHO, the Lisp style is more usable and readable.

SKILL++ is actually a pretty compliant Scheme, with a lot of compatibility to SKILL and quite a bit of Common Lisp added on top. What makes it a bit funny is the clever parser, which allows both prefix syntax as in

(setq x (plus a b))

as well as

x = a + b

(which just reads as the former expression). Personally, I prefer the Lisp style much - except for math expressions.

I love seeing these old bbs message pop up. Ones written in a terminal, formatted with fmt.

Reply on news.ycombinator.com