An evaluation of:
           TADS Text Adventure Development System

  Taken from Bob Newell's 'Which Authoring System is Best' FAQ

The ratings used are as follows
5 Critical.
4 Very important.
3 Important.
2 Desirable.
1 Nice.
Various weights (5 down to 1) are given to different aspects of
the language: these are self explanatory.

Release discussed: 2.2.0.5
Author contact information: Mike Roberts
73737.417@compuserve.com
(SynTax note - TADS is now freeware so ignore references regarding
registration)

Description.
TADS, the Text Adventure Development System, is the creation of
Mike Roberts, and has been in existence and has evolved over a
period of several years. TADS is an object-oriented system which
has a programming "feel" similar to a Pascal/C hybrid.  TADS is
indeed a very powerful system, and some very large works have been
published or are in progress with TADS. TADS is shareware; the
full package, minus printed documentation and debugger are
available from the archive site and the other usual places. If you
ultimately choose to work with TADS, you should register. No doubt
about it.

TADS is rich in feature and function, with a good basic library
and a complete "alternative" library, called WorldClass, also
available. Little has been left out of TADS:  there is the
equivalent of associative arrays, list-tearing functions, a
complete operator set, and much more than can be described here.

Ratings. Ratings by category for this system are:

1. Documentation, Weight 5. Rating: 4.
The TADS manual supplied to registered users is uniformly
considered to be a superb piece of work, with few deficiencies and
very high utility.  (The TADS documentation supplied with the
shareware version is barely adequate to evaluate the product;
however, this documentation is not the subject of the present
rating.)

TADS has gone through several updates since the hard-copy
registered TADS manual has been produced. The updates have been
substantial and far-reaching, making the product a ground-
breaking leader on several fronts. Supplementary documentation has
been included with each revision in the form of text files
accompanying the release. This documentation has been of good
quality, but the net result is that the documentation has become
disjointed and scattered among the hard-copy manual and the text
files.

I understand the expense and difficulty in reissuing the hard-copy
manual; at the heart of the matter lies the fact that the
hard-copy manual is the major registration incentive. But this
does not make the difficulties go away. At the more fundamental
levels, the existing manual will more than suffice, and the
prospective author will get a good head start by studying this
clearly-written and extraordinarily helpful work. It is when you
want to access the newer, more sophisticated and original features
of TADS that you wish for unified documentation.

I cannot offer an easy solution. Perhaps at some point Mike
Roberts, the creator of TADS, might wish to update the manual and
offer it to existing registered users for a reasonable price (as
he has done with supplementary documentation in the past). I'd
suggest that release 3 of TADS, whenever that might come, might be
a good point to do this.

Additionally, I do not feel the TADS documentation will "work" for
a neophyte programmer. Of course, I do not believe TADS is for the
neophyte in any case; see my comments in the appropriate ratings
section.

One other slight personal issue I have with TADS documentation is
that you can't keep it all on-line. I often like to have my source
code in one editor window and the manual in another; you simply
can't do this with something available only in hard-copy.

2. Ease of Use, Weight 5. Rating: 4.
I must qualify this rating by stating that, with sufficient study,
ease of use of TADS is quite good. It is not reasonable to expect
a powerful and complex system such as this to be easy to use
without doing your homework first.

There are some peculiarities in TADS that frustrate the newcomer
but become second nature with experience. TADS has, and indeed
requires, a plethora of verification methods which are applied
when a verb is combined with a direct and/or indirect object. For
instance, "attack monster with sword" requires that the nouns
"monster" and "sword" have methods defined which specifically
allow (or disallow) usage in the combination described with the
verb "attack."

Such peculiarities aside, the clean object-oriented structure of a
TADS program enhances ease of use to a very great extent. Even
fairly complex objects and actions can be defined quite quickly
and readily by someone with a little TADS experience. Objects lend
themselves readily to reuse, even from program to program, and
indeed a collection of such reusable, and useful, objects can be
found at the interactive fiction archive site.

TADS is enough like and not like Pascal, and like and not like C,
to be a bit confusing at the start. Although the most recent
version allows for a more strictly C-like syntax, the beginner is
best advised to work through the initial confusion. It doesn't
take long to get comfortable with this language.

3. Parser, Weight 5. Rating: 4.
The parser is built-in and very good, understanding a wide variety
of constructs and long sentences. Multiple objects, pronoun
antecedents, indirect objects, varied word order, compound
sentences, and much more, are easily interpreted by the parser. A
number of methods and functions are present by which default
parser behavior can be modified or overridden, including one
routine that allows you to fully substitute for the parser should
you so wish (this should be pretty rare).

The down-side of the parser is that it is built into the source
code, not the libraries; and further, with source code not
generally available, you're going to have to live with the parser
and ancillary functions as-is. Some authors, particularly those
wishing to write in languages other than English, have stated that
this is a problem to varying degrees. For most authors, and
particularly for the prospective new author, this should be a
minor concern until a very advanced level is reached or unless you
are not writing in English, in which case the issue is a little
more serious (but hardly fatal).

4. Support, Weight 4. Rating: 5.
Support for TADS can be obtained in three ways: from the author by
e-mail; via the newsgroup; or via the TADS support BBS in
California. E-mail support has been reported to be a little spotty
due to Mike Roberts' busy schedule. The support BBS has been
successful for the relatively few that have used it, although
there are some problems here - you can't call at rates higher than
2400 bps, and it's a long distance or international call for most
people. News group support, however, is really good, as there is
enough developed TADS expertise among people willing to help out
that a good source of advice is readily available.

Discussion of TADS in recent months has been significantly less
than discussion of Inform. Whatever may be the reasons, this does
not imply a decline in the fortunes of TADS. In fact, the 1995 IF
contest drew as many TADS entries as Inform entries. TADS
expertise, at a high level, remains readily available on the
newsgroup.

5. Language Depth, Weight 4. Rating: 5.
Language depth is extraordinary. About the only thing that seems
to be missing is floating-point numbers, and these are likely to
be of limited utility in an IF piece (suitable workarounds are
usually at hand). TADS functions for string and text processing
are very complete, perhaps approaching the completeness of the
Perl language. Array and list manipulation is provided. Available
function calls cover just about everything you might need, from
determining if an object has a particular property to changing the
default behavior of the parser. TADS has a large number of
functions which deal with direct and indirect objects in a
sentence.  These are a mixed blessing, as will be discussed later.

Again, with language depth comes inevitable complexity. Having all
these features available means, if you wish to use them, having to
learn how to do so. Yet, the features are layered well enough that
for the most part, the prospective author can learn them one at a
time, as they are needed.

One thing that sets TADS apart from the other systems is that
there is a choice of "standard" libraries. The libraries supplied
with TADS are generally considered to be quite good, reasonably
adaptive and flexible, and in any case can have components easily
substituted or modified. However, an alternative set of libraries
exists, called WorldClass. These libraries, written by Dave
Baggett, are very complex and extensive, providing for improved
environment modeling and character interaction. It is an
understatement to say that these libraries require some study;
and, since they are very large, they do significantly impact both
the run-time performance and the run-time portability of the
completed game. Nonetheless, a master-work such as The Legend
Lives would have been somewhat more difficult to produce without
these powerful but demanding alternative libraries.

6. Portability, Weight 4. Rating: 4.
TADS runtimes for a number of Unix systems, the Mac, and the PC
are all up-to-date. Support for the Amiga has lagged, and has not
been present for other systems.

In the old days of the pure "TADS vs. Inform" debates, TADS was
down-rated by some newsgroup correspondents because it would not
run on some of the less common computer systems, which, despite
having small market share, still represented a substantial number
of potential players. I think this case was overstated, but
nevertheless I rate TADS as 4 for portability rather than 5
because other major systems do support more platforms. However, we
really must remember that a TADS game can be played by a good 98
or 99 percent of the computing public, should they have an
interest.

7. Run Speed, Weight 4. Rating: 3.
TADS run-time speed is fine for smaller games built with the
standard libraries, on most "reasonable" computing platforms.
Noticeable problems result, however, with larger games, especially
games built with the "World Class" libraries (although this latter
comment is based only on the single example available). Large
libraries provide large object sets and vocabularies, and while
these add immeasurably to the depth of the system it is not
without a price. Some players using lower-end machines have called
large games "unplayable" or "unbearably slow." I think these
criticisms are too extreme and perhaps reflect a tendency toward
impatient play rather than measured enjoyment of an IF work.
Nevertheless, there is some truth here. The TADS run-time on
larger works is very clearly the slowest in its class.


8. Literature Library, Weight 4. Rating: 5.
Extensive literature exists in TADS (there is a separate document
detailing this which appears on the newsgroup from time to time).
Much literature is available in source code format, ranging from
Colossal Cave to Legend itself. There is enough for the
prospective author to be able to find an example for just about
any sort of programming construct or problem. TADS' strong
literature library is a very important distinguishing factor.

9. Debugging Features, Weight 4. Rating: 4.
The TADS source level debugger, supplied with the registered
version to PC and MAC users, is everything you would expect of a
debugger. Breakpoints, conditional breakpoints, expression
evaluation, variable modification, branching, etc., are all
supported smoothly. The rating would be even higher were it not
for two problems which are more logistical than technical. The
debugger is not available for other platforms (less serious
point), but apparently has not been kept up to date for the major
platforms (serious indeed).

For registered users, picking up a new debugger version (which
must match the compiler version) has been a matter of a long-
distance call to the TADS support BBS, Hi-Energy BBS, in
California. In recent times however, more current versions of the
system have been placed on the Internet and the BBS lagged. I
still do not have a debugger for TADS 2.2.0.5, which is the latest
release.

Perhaps a better method of updating and distribution can be worked
out. This is the only real flaw in the debugger, and it has
nothing to do with its utility or technical merits.

10. Future Prospects, Weight 3. Rating: 3.
I am sure to get criticism about this relatively low rating for
TADS future prospects. While TADS is very much alive, very viable,
widely used, and well supported, new releases have become more and
more infrequent. This, I am sure, has to do with Mike Robert's
busy schedule more than with any lack of interest on his part.
Yet, this, coupled with the general unavailability of source code,
lead me to the conclusion that future developments could be
limited. Mike has projected some features for an eventual 2.3
release, but there is no release date and no one really expects to
see it soon.

11. Object Orientation, Weight 3. Rating: 5.
Object orientation in TADS is as "pure" as one might like
(although you can quibble about things like classes and
instantiation of a class object being equivalent). TADS supports
class definitions, multiple inheritance, overriding, encapsulation
of data, messaging in a very general sense, and all the regalia of
object orientation.

Reduced to practical terms, this makes TADS very well suited to
the purpose at hand, very much easier to work with, and very much
more logical in structure. Mike Roberts deserves the highest
praise for the quality of this implementation.

TADS was, a few years ago, my first experience with object-
oriented programming. Predictably, it was a little frustrating
until I got the hang of it, more than once I wished for my old,
procedural systems, but in the end, I found myself wondering what
the problem really was, and why on earth would anyone ever want to
do it the old way any longer? For the prospective new author,
there will likely be some learning necessary here, but it will
stand one in good stead for a very long time.

12. Game Size, Weight 3. Rating: 4.
TADS can produce very large works, yet I rate this category just
below top level because the large works carry along significant
portability problems which are just now being partially solved.

The Legend Lives when it was released was the largest TADS work
ever. It used the special WorldClass libraries and, on the PC
platform, depended on a protected-mode version of the runtime in
order to be usable. This runtime was plagued with so many
compatibility problems that newsgroup discussion of Legend
centered (most unfortunately) on problems with running the game
rather than with the quality of the game itself.


It can be argued rightly that DOS compatibility problems are the
fault of DOS, Windows, the myriad incompatible memory management
systems used to get around the DOS memory usage limitations, and
all those problems with which PC users are all too familiar.
Nonetheless, the PC represents probably 90 percent of the playing
platforms, and the IF run- time system simply must deal with this.
A more stable version of the runtime has been released but will
not run on sub-386 PC models. So, TADS can produce very large
games, but there will be issues to consider. Of course, as a
practical matter, it is still possible to write a large game (as
opposed to an enormous one) within the limitations of the
"standard" TADS runtime environment, and this will meet the needs
of most authors very readily.

13. Distribution Policy, Weight 3. Rating: 4.
The TADS license allows unrestricted shareware distribution of any
TADS game, which will cover the needs of the majority of authors.
Commercial distribution requires a separate arrangement with TADS
creator Mike Roberts, which I am told is generally quite easy to
arrange.

14. Programming Skill Required, Weight 3. Rating: 3.
Assigning this rating is an attempt to reflect the reality of TADS
measured against its purpose and intent. TADS does not claim to be
intended for novice programmers, although I think the
documentation understates the amount of knowledge necessary.
(Professionals in this field, including myself, tend to assume
that non-professionals are a lot more advanced than is really the
case.)

But TADS does not claim to be a simple or unsophisticated system,
and indeed it is not. Quite the opposite is true. TADS is a
state-of-the-art, Tier 1 system, and this imposes some definite
requirements on the prospective user.

I do not believe that a non-programmer can be very successful very
quickly with TADS. It is not out of the question for TADS to be
someone's "first" language; but in that event, the documentation
won't do. The documentation implies a certain level of programming
knowledge which is quite a bit beyond beginner level. I don't rate
TADS "4" on programming knowledge required because of its
complexity for a beginner. Neither do I rate it "2" because a
sophisticated language of this type cannot be expected to be
elementary and easy.

The prospective TADS user had better bring to the party an
intermediate knowledge of C or Pascal (not Basic, thank you).
Guru-level knowledge isn't required, but familiarity with
programming concepts and more than a little experience using them
is highly recommended.

15. Cost, Weight 2. Rating: 4.
I must admit that in assigning this rating I'm making an implicit
judgment of price vs. value. TADS is not free, it is shareware,
and the registration is currently US $40.00 plus some shipping
charges. For this you receive the excellent but somewhat out-of-
date printed TADS manual, and some extra utilities including a
source-level debugger, if you are a PC or MAC user. Nearly
everyone agrees that the $40.00 asking price for TADS is more than
fair, and that Mike Roberts treats customers well and fairly.
There are a few people to whom cost is a major factor, whether on
philosophical or "impoverished student" grounds, but for most the
cost of TADS is a non-issue.

16. Source Code, Weight 2. Rating: 2.
Source code for TADS is available only upon acceptance by Mike
Roberts of your signed non-disclosure agreement, and Mike
understandably limits distribution of the source. Source code, for
the majority of authors, can be said to not be available.

17. Compiler Speed, Weight 2. Rating: 5.
I did a series of benchmarks a while back, comparing TADS and
Inform for compilation speed on a number of hardware and operating
system configurations. TADS compilation was extremely fast even on
slower systems, and nearly instantaneous on new, fast systems.
(The test case was the ubiquitous port of Colossal Cave.) The
compile speed on my Pentium 133 running Linux is literally
breath-taking. DOS compile speed is about twice as slow but still
blazingly quick.

(When I first published these results, I received a number of "so
what" responses ... the point being that run-time speed was far
more important than compile speed. True enough; yet, I find a lot
of advantage in being able to compile quickly and quickly
eliminate syntax errors and the like. Of course, there can then be
the afore-mentioned temptation to write sloppily: :):

18. Compiler Platforms, Weight 2. Rating: 4.
I rate this 4 instead of 3 because most of the "world" is covered
with DOS and MAC compilers readily available (and Linux and Sun as
well). I recognize the frustration of Amiga users, whose versions
have lagged; and I know there are other systems which are not
covered. But the mainstream is well supported at this point.

19. Dynamic Object Creation, Weight 1. Rating: 5.
Recent developments within TADS have made dynamic object creation
and destruction, name-changing, etc., very easy to accomplish.
Distinguishing between identical objects (lottery tickets,
mailboxes, etc.) is also done quite readily.

Summary Comment.
TADS is mature, quite bug free, stable, and has been in use for
some time. Support is excellent, documentation is good, and the
language is powerful and highly object-oriented. TADS demands
study and some patience in order to unleash its inherent
potential.  This patience will be well rewarded. The prospective
serious IF author will not go wrong with TADS. Not at all.












                              - o -