Relay-Version: version B 2.10 5/3/83; site utzoo.UUCP
Posting-Version: version B 2.10.2 9/18/84; site gumby.UUCP
Path: utzoo!watmath!clyde!burl!ulysses!allegra!mit-eddie!genrad!panda!talcott!harvard!seismo!uwvax!gumby!g-inners
From: g-inners@gumby.UUCP
Newsgroups: net.lang
Subject: Standardization
Message-ID: <283@gumby.UUCP>
Date: Thu, 7-Feb-85 18:59:49 EST
Article-I.D.: gumby.283
Posted: Thu Feb  7 18:59:49 1985
Date-Received: Sat, 9-Feb-85 08:54:25 EST
Organization: U of Wisconsin CS Dept
Lines: 47

Indeed, there is no accepted standard for Pascal.  The original is
incomplete, and the extensions are largely incompatible.  Why does
this happen?  Is it bad?  How can it be avoided (if bad)? These are far
more interesting topics than the current low-content argument about 
whether Original C is different from Current C (this is true for any 
language I can recall), or whether an ISO Standard is a standard
(clearly in some sense it is).

The root of incompatability would appear to be an incomplete or flawed
orginal design.  The missing OTHERWISE in Pascal's CASE, or the
a =- 2/ a = -2 ambiguity in C are examples.  Implementors attempt
to correct these problems.  Since many implementations occur simultaneously
and without communication, these corrections differ.  Once this occurs,
incompatability is impossible to root out.  If I am to produce an
upward-compatable parallel processing variant of Pascal, which version
do I base it on?  If it is the original, I've joined the problem (yet
another extension of the original...).  If it is based on another
extension,  it will not be upward compatable with any of the others.

Basing the choice on the most popular version may be a good idea, but
'most popular' need not be 'the best'.  Extensions may also be incomplete
or flawed.  My ideas may be incomplete or flawed.  ISO Standards (or ANSI,
for that matter) may be incomplete or flawed.

I'm going to advance the thesis that sticking to Standards or attempting
to be compatible may be a BAD thing in some cases.  There are clear
advantages to being able to port either one's actual programs or at
least one's knowlege about programming in a language.  However, Computer
Science in general, and language design in particular, is nowhere near
advanced enough for a good standard to be advanced.  There is so much
room for advancement and improvement that locking into a standard would
be counter-productive.

I'm not claiming that standards should be actively ignored.  It would
be good if those things on which there is wide agreement could be
standardised.  However, is the right way to handle conformant arrays
well enough understood for a standard to be adopted?  Certainly this
is not the case for concurrent programming!

On the other hand, differences are often silly (is it OTHERWISE, OTHERS,
or ELSE in a CASE statement?).  Perhaps new compilers should attempt
to standardise on 'all of the above'.  It would certainly be more productive
than arguing about it.
				-- Mike Inners

"If wide portability was the determining factor, we would all be using
    FORTRAN on OS/360!  :-)."