Greenspun on tcl vs lisp, is it less work to just do tcl? will lisp have longterm advantage?

[gavino]

http://philip.greenspun.com/tcl/introduction.adp toward the bottom
In the case of AOLserver, for example, Jim Davidson and Doug McKee had
only a few months to build the whole server from scratch. They wanted
users to be able to write small programs that ran inside the server
process. They therefore needed a safe interpreted language so that a
programming error by one user didn't crash the server and bring down
all the Web services for an organization.

Tcl was available. Tcl was easy to download and designed to fit inside
larger application programs. But the Tcl interpreter as distributed had
one terrible bug: it wasn't thread safe, i.e., you couldn't have two
copies of the Tcl interpreter running inside the same program at the
same time. Doug and Jim had to read through the Tcl source code and
modify it to be thread safe. So it was critically important for them
that Tcl was open-source and simple enough so as to not require months
or years of study to understand the whole system.

Compare this to Lisp. Some of the best and brightest computer
scientists raised money to build commercial Lisp implementations that
they then went out and hawked in an indifferent and confused
marketplace. They succeeded only in breaking their hearts and their
investors' wallets. A handful of academics produced free open-source
implementations, notably CMU Common Lisp (see
http://www.cons.org/cmucl/) and various versions of Scheme (see
http://www-swiss.ai.mit.edu/scheme-home.html; Scheme 48 is the closest
to Tcl in spirit). But these multi-megabyte monsters weren't designed
to fit neatly into someone else's program. Nor was there any document
explaining how to do it.

Lisp developers have the satisfaction of knowing that they got it right
30 years before anyone else. But that's about all they have to show for
40 years of hard work and hundreds of millions of dollars in government
and private funding. These days, most former Lisp programmers are stuck
using Unix and Microsoft programming environments and, not only do they
have to put up with these inferior environments, but they're saddled
with the mournful knowledge that these environments are inferior.

[wooks]

gavino wrote:

Well blow me. I have learnt something useful from a gavino post. Fair
play to you on this one.

[David Rush]

wooks wrote:

> gavino wrote:
>
> > Tcl was available. Tcl was easy to download and designed to fit inside
> > larger application programs.

...
> > Compare this to Lisp. ...But these multi-megabyte monsters weren't designed

> > to fit neatly into someone else's program. Nor was there any document
> > explaining how to do it.
>

> Well blow me. I have learnt something useful from a gavino post. Fair
> play to you on this one.

Don't count your Chickens before they're hatched. gavino is apparently
ignorant of SIOD which powered the GIMP back in the day (still does I
think), and Oz Yigit's excellent PSI which only ever had limited
distribution. Both systems are excellent small, yet complete Scheme
systems which are *eminently* embeddable. Now SIOD is only R3RS and PSI
is R4RS so they are not up to date, but then again, *neither is TCL*.

The great challenge in the old Lisp days was making Lisp code fast
enough to do heavy lifting. That challenge is still important, but
there are *lots* of applications where compute-intensive performance is
not the main requirement. There are some Schemes which do fit those
niches very well.

And that's the beauty of our endlessly fragmented implementation
community :)

david

[wooks]

David Rush wrote:
> wooks wrote:
> > gavino wrote:
> >
> > > Tcl was available. Tcl was easy to download and designed to fit inside
> > > larger application programs.
> ...
> > > Compare this to Lisp. ...But these multi-megabyte monsters weren't designed
> > > to fit neatly into someone else's program. Nor was there any document
> > > explaining how to do it.
> >
> > Well blow me. I have learnt something useful from a gavino post. Fair
> > play to you on this one.
>
> Don't count your Chickens before they're hatched. gavino is apparently
> ignorant

ahhh the useful information I was referring to was that Abelson and
Greenspun have collaborated on a book, which is available to read on
the web.

[H.]

> Don't count your Chickens before they're hatched. gavino is apparently
> ignorant of SIOD which powered the GIMP back in the day (still does I
> think), and Oz Yigit's excellent PSI which only ever had limited
> distribution. Both systems are excellent small, yet complete Scheme
> systems which are *eminently* embeddable. Now SIOD is only R3RS and PSI
> is R4RS so they are not up to date, but then again, *neither is TCL*.
>
> The great challenge in the old Lisp days was making Lisp code fast
> enough to do heavy lifting. That challenge is still important, but
> there are *lots* of applications where compute-intensive performance is
> not the main requirement. There are some Schemes which do fit those
> niches very well.
>
> And that's the beauty of our endlessly fragmented implementation
> community :)

Just in case it isn't clear -- none of that text represents gavino's
original ideas. It's straight off of the link given, Philip Greenspun's
page, copied and pasted here.