Re: Language Efficiency

[dewar@cs.nyu.edu (Robert Dewar)]

Fergus notes the comparison of peformance of Prolog and Mercury, and states
that Mercury is up to 70% faster:

(The feature in question is the ability to write `read(X), call(X)',
which can call any predicate with any arguments depending on the input.)

But how can forbidding a feature POSSIBLY mean that you can compile faster.
If it is possible to compile faster if read(x) and call(x) are avoided, then
surely a prolog compiler can just look at your program, see if you use these
features, and use one of two totally different compilation strategies
depending on the answer.

Of course I understand that this makes implementation harder, and it is
indeed true that you have to work very hard to deal with difficult
problems, but you often can deal with them  much better than you might
imagine.

Another example from SNOBOL-4

In SNOBOL-4, when you access any variable by name, as in the access to 
Q in  the assignment

 	R = Q

you have to check if Q is input associated (and if so, read from a file), and
if it is trace associated (and if so, call a user defined trace routine).
Similarly the assignment to R may write to a file or call a userdefined
trace procedure. The I/O associations and trace associations are completely
dynamic, and it is impossible to tell at compile time whether any given
reference needs the extra tests.

Yes, without ANY loss of dynamic flexibility, the 370 SPITBOL compiler
does these tests with precisely ZERO overhead in the most common case
where the variables R and Q are never associated. ZERO doesn't just mean
small, it means ZERO!