Re: Why you should not use Tcl

Tim Bunce (
Fri, 30 Sep 1994 11:16:49 +0000

In article <36847d$i6j@csnews.cs.Colorado.EDU> (Tom Christiansen) writes:
>:-> In comp.lang.tcl, (mathew) writes:
>:He gives you a list of sound technical reasons for favouring Scheme over
>:hack jobs like Perl and Tcl:
>:>:But Perl and Tcl do have serious syntax-related problems in the areas
>:>:of syntactic overloading, error recovery, scoping, and quoting.
>:...and that makes him a "fanatic"?
>Perhaps. It *does* make him moderately uninformed, however. Perl's error
>recovery has always included an exception paradigm, albeit without
>continuations. Its scoping has always been better than C's. As for the
>rest, it may have some credibility a few years ago, but really isn't up to
>spec with v5.0 of perl, which many are using. embeddible perl
>interpreters in C or C++ apps, dynamicly loaded C or C++ or Perl modules,
>limited type checking, tremendous namespace protection, both static and
>dynamic scoping, true references, object-oriented features like function
>and operator overloading, global and instance constructors and destructors
>as well as inheritance and (potentially transparent) method invocation for
>class instances -- and you'll see there's much more to it than you perhaps
>have realized. I strongly suggest that you look into it again before you
>make all these so-called "syntax-related" problems associated with Perl.

That sound like a good excuse to post this (from the Perl 5 docs):

--- snip ---

Perl version 5 is nearly a complete rewrite, and provides the following
additional benefits:

* Many usability enhancements

It is now possible to write much more readable Perl code (even within
regular expressions). Formerly cryptic variable names can be replaced
by mnemonic identifiers. Error messages are more informative, and the
optional warnings will catch many of the mistakes a novice might make.

* Simplified grammar

The new yacc grammar is one half the size of the old one. Many of the
arbitrary grammar rules have been regularized. The number of reserved
words has been cut by 2/3. Despite this, nearly all old Perl scripts
will continue to work unchanged.

* Lexical scoping

Perl variables may now be declared within a lexical scope, like "auto"
variables in C. Not only is this more efficient, but it contributes to
better privacy for "programming in the large".

* Arbitrarily nested data structures

Any scalar value, including any array element, may now contain a
reference to any other variable or subroutine. You can easily create
anonymous variables and subroutines. Perl manages your reference
counts for you.

* Modularity and reusability

The Perl library is now defined in terms of modules which can be easily
shared among various packages. A package may choose to import all or a
portion of a module's published interface. Pragmas are defined and used
by the same mechanism.

* Object-oriented programming

A package can function as a class. Dynamic multiple inheritance and
virtual methods are supported in a straightforward manner and with very
little new syntax. Filehandles may now be treated as objects.

* Embeddible and Extensible

Perl may now be embedded easily in your C or C++ application, and can
either call or be called by your routines through a documented
interface. The XS preprocessor is provided to make it easy to glue
your C or C++ routines into Perl. Dynamic loading of modules is

* POSIX compliant

A major new module is the POSIX module, which provides access to all
available POSIX routines and definitions, via object classes where

* Package constructors and destructors

The new BEGIN and END blocks provide means to capture control as
a package is being compiled, and after the program exits. As a
degenerate case they work just like awk's BEGIN and END when you
use the -p or -n switches.

* Multiple simultaneous DBM implementations

A Perl program may now access DBM, NDBM, SDBM, GDMB and Berkeley DB
files from the same script simultaneously. In fact, the old dbmopen
interface has been generalized to allow any variable to be tied
to an object class which defines its access methods.

* Subroutine definitions may now be autoloaded

In fact, the AUTOLOAD mechanism also allows you to any arbitrary
semantics to undefined subroutine calls. It's not just for autoloading.

* Regular expression enhancements

You can now specify non-greedy quantifiers. You can now do grouping
without creating a backreference. You can now write regular expressions
with embedded whitespace and comments for readability. A consistent
extensibility mechanism has been added that is upwardly compatible with
all old regular expressions.

Ok, that's definitely enough hype.

--- snip ---

Tim Bunce.