From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 13144 invoked by alias); 5 Jan 2003 12:28:36 -0000 Mailing-List: contact gcc-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Archive: List-Post: List-Help: Sender: gcc-owner@gcc.gnu.org Received: (qmail 13136 invoked from network); 5 Jan 2003 12:28:34 -0000 Received: from unknown (HELO nile.gnat.com) (205.232.38.5) by 209.249.29.67 with SMTP; 5 Jan 2003 12:28:34 -0000 Received: by nile.gnat.com (Postfix, from userid 338) id 02E54F2D5D; Sun, 5 Jan 2003 07:28:22 -0500 (EST) To: aph@redhat.com, dewar@gnat.com Subject: Re: c++ "with" keyword Cc: gcc@gcc.gnu.org Message-Id: <20030105122822.02E54F2D5D@nile.gnat.com> Date: Sun, 05 Jan 2003 12:44:00 -0000 From: dewar@gnat.com (Robert Dewar) X-SW-Source: 2003-01/txt/msg00205.txt.bz2 > 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.