
Texas Instruments on Scheme (1984) - soegaard
https://groups.csail.mit.edu/mac/ftpdir/scheme-mail/HTML/rrrs-1984/msg00010.html
======
MycroftJones
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.

~~~
Johnny_Brahms
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)

~~~
MycroftJones
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?

~~~
Johnny_Brahms
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.

------
soegaard
Is Scheme still used by Texas Instruments?

~~~
svendbt
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.

~~~
satya71
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.

~~~
_ph_
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.

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

