The only benefit you claim for Tcl that doesn't also apply to scheme
is #3. You would like to type...
func arg1 arg2
instead of
(func arg2 arg2)
Ok, a minor but perhaps valid point if you want dumb users to use it
like a shell.
I've often thought that if I ever wrote a Scheme shell, I would
provide an option to put in a line prefix and suffix to lines just to
satisfy this point. You might do something like this...
$ scheme
> (write 'foobar)
'foobar
> (set! prefix "(")
(> set! suffix ")")
(&)> write 'foobar
'foobar
As you see, by setting the prefix and suffix variables a "(" and ")"
would automatically be prepended and appended to each line you
type. The prompt would change to "(&)" to remind you that this is in
effect. If you wanted a shell like a Unix shell that runs other
processes you might change it to "(run &)" which would automatically
call the run procedure on anything you type in. This would allow you
to type ls -l at the prompt and have it work.
····@peanut.jpl.nasa.gov (Will Duquette) writes:
> Here's what Tcl/Tk buys *me*.
>
> I have no interest in writing large programs solely in Tcl to Tcl/Tk.
> There are indeed better languages out there for that purpose.
> However, in my work we have a developed a number of APIs for a variety
> of obscure tasks. These are generally coded as C libraries. By
> writing Tcl extensions for these libraries, I get the following
> practical advantages:
>
> 1. I can build a Tclsh with my own extensions.
>
> #1 is crucial. The libraries I work with use threads. You can't
> dynamically load a threaded library into a program that's compiled to
> be single-threaded and have it work--not on Solaris at least. If I
> could not build my own executable, Tcl would be useless to me.
>
> 2. I can write simple programs using these libraries without
> pulling out the compiler, writing Makefiles, and so forth.
> This is particularly useful for testing.
>
> Many languages can provide this, I'm sure.
>
> 3. I can exercise these libraries interactively, one command at a
> time, in a shell-like environment.
>
> Proponents of Scheme and similar languages have pointed out
> that they can do this in their language as well. And yet,
> psychologically anyway, Tcl feels simpler to me. I'd rather
> type
>
> myfunc arg1 arg2
>
> than
>
> (myfunc arg1 arg2)
>
> Moreover, I'd rather tell users of my extended shell to type
> the former rather than the latter. I guess that's the issue:
> If you want to use a Tcl-based shell as a means of typing
> commands, you can ignore the rest of Tcl; the commands look
> like the kinds of commands you might type into any other
> command-line oriented program.
>
> 4. I'm using a language with sufficient popular support that I
> know I can get help if I need it. Tcl may never be the most
> popular language in the world, but it's popular enough that
> it's not going to vanish overnight, either.
>
> Go look at
> "http://www.yahoo.com/Computers_and_Internet/Programming_Languages/"
> sometime, and see how many links they list for each language.
> This is at least a rough measure of the current amount of
> public interest in each language. I don't claim it measures
> usage, of course.
>
> You'll notice that I've made no arguments about Tcl as a *language*.
> Pragmatically speaking, though, it enables me to get my job done
> easily, efficiently, and well.
From: Kelly Murray
Subject: Re: Ousterhout and Tcl lost the plot with latest paper
Date:
Message-ID: <5jelch$5dd$1@sparky.franz.com>
In article <···············@aalh02.alcatel.com.au>, ·············@alcatel.com.au (Chris Bitmead uid(x22068)) writes:
>>
>> The only benefit you claim for Tcl that doesn't also apply to scheme
>> is #3. You would like to type...
>>
>> func arg1 arg2
>> instead of
>> (func arg2 arg2)
>>
>> Ok, a minor but perhaps valid point if you want dumb users to use it
>> like a shell.
>>
There are many "top level" Lisp interfaces that accept "func arg1 arg2"
in place of (func arg2 arg2), and do completion of the function names
and can prompt for their arguments BY NAME as well.
Common Lisp also has :keyword arguments, which these "top level" interfaces
can also do completion on. For example, the function open() takes a
pathname and keyword arguments :direction :element-type :if-exists.
Furthermore, in some window based systems, any object visible on a window
will be mouse senstive in this prompting context,
and can be "clicked" on to supply the arguments to the function,
and in some cases, it can restrict the items which are highlighted to
be only those of the appropriate type to the function!
You can't tell me that isn't a high-level command interface.
That is the power that Lisp gives to the "environment"
-kelly murray ···@franz.com http://www.franz.com