Re: c++ "with" keyword

[dewar@gnat.com (Robert Dewar)]

> Believe that if you wish.  I'm not a betting man.  The Algol 68
> language had no implementations when it was standardized -- AFAIK the
> first delivery was 1977!

Right, but so what? Neither did Algol-60, and that was hugely successful.
The advantage of prototyping as you go along is to validate language
design features, as was done for example with Ada, but in practice the
design of Algol-68 went very smoothly (this standard appeared only 8
years after Algol-60, contrast the period of time between C and C++, or
for that matter between Ada-83 and Ada-95. 

There was in fact quite a lot of prototyping activity (AlgolW/X/Y). If you
look at C++ it is also the case that there was no implementation of C++
when it was standardized (I am not sure that there is a 100% conforming
implementation at the current time). Yes, there were prototypes of subsets,
but that was also true of Algol-68. 

> To quote Lindsey's official history: "...why it did not come into more
> widespread use, and the answer here is simple enough: because it was
> not implemented widely enough, or soon enough.  And the reason for
> that is that implementation was too hard..."  This would not have been
> the case if implementations had existed at the time of
> standardization.

The difficulty of implementing Algol-68 exists whether or not the standard
had waited to be issued till the first implementation. In fact the first
implementation appeared in the early 70's, more or less at the same time
as the revised report (really the revised report is Algol-68).

Of course if implementations had existed in 1968 that would have been nice,
but that's fantasy if you look at the history. Complex languages have always
taken a lot of time and effort to implement. 

Charles is quite right that it was not implemented widely enough or soon
enough, but that was a matter of market forces and resources (the one csae
in which a major manufacturer implemented Algol-68, which was CDC in response
to Dutch university tenders -- they invested about 100 person years of effort.
This compiler was widely used and very successful -- it was by the way the
first general purpose procedural language to have a full garbage collector).

There was certainly no phenomenon of people somehow delaying work on the
implementation of Algol-68 waiting for the standard. On the contrary, the
existence of an accurate standard early on was an enormous help in the
implementation effort (for example, our effort on the 1108 started in 1969
and would have been impossible without the standard).

The real reason for involving language design folks as early as possible is
to avoid half baked extensions that are not properly documented. I still have
not seen proper complete formal definitions of some of the GCC extensions
for example. 

What you need is language design people working hand in hand with implementors
to ensure that new features are properly designed and at the same time
implementable.

The first incarnation of a new language idea should be a fully developed
reasonably formal description of the idea, in the context of the existing
standard. This description should be developed with input from implementors
as to what is or is not implementable. Then trial implementations can be
carried out. It is also reasonable to do prototype implementations to verify
implentability as part of the initial development. This approach has been
followed very successfully in the Ada context for example.

So for me, if anyone is seriously interested in the WITH proposal (so far
I see only one advocate), the next step is to write a reasonably precise
description of what the feature is, including reasonably precise semantics
and syntax. Then that design needs to be evaulated by language design folks,
implementors and application developers to see if it makes sense. Only then
is an implementation reasonable. In the case of WITH, I think the idea is
so badly flawed that the proposal would fail at the first stage, avoiding
wasted implentation effort.