············@gmail.com wrote:
> Is TCL derived from Logo? Is it thus a distant, estranged member of the
> Lisp family?
Ok, more on it here
http://www.levenez.com/lang/history.html
and here
http://wiki.tcl.tk/1318
············@gmail.com wrote:
> ············@gmail.com wrote:
> > Is TCL derived from Logo? Is it thus a distant, estranged member of the
> > Lisp family?
>
> Ok, more on it here
>
> http://www.levenez.com/lang/history.html
>
Funny how the chart shows that Tcl appeared out of nowhere. I think its
because the chart doesn't track command shells as languages. Where is
sh, ash, bash, csh, tcsh? Or even DOSs crude .bat files? Tcl got its
early influence from these (maybe not DOS). See:
http://wiki.tcl.tk/Tcl%20Heritage
Once started, tcl like other languages started borrowing good ideas
form others. But as I've said before, tcl still feels like the command
line. It rarely strays from its original design philosophy.
It's also comparatively easy to emulate Logo in Tcl (the other way
round would probably be more difficult). See
"Turtle graphics the LOGO way" http://wiki.tcl.tk/1097 and
"Turtleshell" http://wiki.tcl.tk/1107
············@gmail.com wrote:
> Is TCL derived from Logo? Is it thus a distant, estranged member of the
> Lisp family?
You'll have to do much better than that to get a good flamewar going.
(comp.lang.tcl deliberately trimmed.)
Tcl is clearly descended from the shell-scripting school of
programming.
The key identifying feature of these languages is the reversal of the
quotation rules typical in programming languages.
Lisp, Fortran, Algol, and descended languages use symbolic variable
names to denote values. Numeric literals are allowed without quotation.
In order to include text in a literal way, it must be quoted; Fortran,
C, Pascal, etc. include quoting structures that allow for character and
string literals (Hollerith and format strings in Fortran). Lisp goes a
bit further, allowing a generic "quote" operator to include essentially
any Lisp object as literal data.
Command shells typically interpret ordinary text literally. In order to
use names to represent other values, and explicit "textual
substitution" operator must be used. In the case of Tcl, as in UNIX
shells and Perl, the prefix character $ is used.
To me, this dollar sign is the key design clue that a language is NOT
meant to support abstraction. The fact that you have to deliberately
indicate "I'm being abstract here" as opposed to indicate "I'm
expressing myself literally here" shows a bias toward literalism that
can only frustrate the attempt to express algorithms in abstract
generality.
This is as unlike Lisp as can be imagined.
············@gmail.com wrote:
> Is TCL derived from Logo? Is it thus a distant, estranged member of the
> Lisp family?
TCL is a member of the Unix shell family. It works by tokenizing
command lines. Its evaluation involves a lot of run-time string
processing. It's completely different from Lisp.
TCL has some brackets and braces, but these are character string
delimiters.
The C preprocessor also recognizes parentheses as character string
delimiters. In C you can write
MACRO((1, 2), (3, 4))
to call a two-argument macro defined as
#define MACRO(A, B)
The A parameter receives the token sequence (1, 2), and B takes on (3,
4). But these are not lists at all, but flat sequences of textual
items. The parentheses are actually represented. The C preprocessor
does check that the parentheses are balanced, which can be achieved by
simple counting, and ensures that commas within parentheses are not
treated as macro argument separators.
TCL is similar. When you write {x {1 2} {3 4}} it means the string "x
{1 2} {3 4}". The braces are part of that string. They have to balance,
of course, which requires scanning. When that string is evaluated as a
command, it will be scanned again, and broken into 3 items: the word x,
and the strings "1 2" and "3 4". It's quite disgusting. :)
C does disgusting token things only at compile time in its
preprocessor. In Lisp, we don't even tolerate that. Compile time is
object-based perfection with access to the full language. Macros can
even be compiled into native machine code.
A Lisp expression is scanned once, in its entirety, when it first
encounters the Lisp implementation. Thereafter, it ceases to be text.
From: Donald Arseneau
Subject: Re: Is TCL a descendent of Logo?
Date:
Message-ID: <yfipsp0tq9d.fsf@triumf.ca>
"Kaz Kylheku" <········@gmail.com> writes:
> A Lisp expression is scanned once, in its entirety, when it first
> encounters the Lisp implementation. Thereafter, it ceases to be text.
Thinking that is different from Tcl belies an ignorance of Tcl.
--
Donald Arseneau ····@triumf.ca
Donald Arseneau wrote:
> "Kaz Kylheku" <········@gmail.com> writes:
>
> > A Lisp expression is scanned once, in its entirety, when it first
> > encounters the Lisp implementation. Thereafter, it ceases to be text.
>
> Thinking that is different from Tcl belies an ignorance of Tcl.
Are you referring to the Tcl_Obj kludge? Oh boy.
Kaz Kylheku wrote:
> Donald Arseneau wrote:
>> "Kaz Kylheku" <········@gmail.com> writes:
>>> A Lisp expression is scanned once, in its entirety, when it first
>>> encounters the Lisp implementation. Thereafter, it ceases to be text.
>> Thinking that is different from Tcl belies an ignorance of Tcl.
> Are you referring to the Tcl_Obj kludge? Oh boy.
He isn't. But the definition of "once" is somewhat different in Tcl than
in Lisp. This make it a bit easier to embed foreign languages in Tcl
(not that I'm saying it is hard in Lisp, you understand) at the expense
of more reparsing (the Tcl language is used as a little language inside
itself). What is more interesting is how similar these things can end up
looking even though they are fundamentally diffferent.
Donal (who wouldn't say that Tcl descends from Lisp; it's just a great
source of cool language features to plunder^W"borrow".)
[f'ups set]