mfeldman@GWUSUN.GWU.EDU (Mike Feldman) (03/23/90)
The last number of postings have been very encouraging. Seems we've all decided to be big boys and girls, end the language jihads, and get back to the Ada technical discussions that are the real purpose of the group. Thank you all for making this group fun again! While I'm at it, let me put in two cents' worth about standards. This is not a flame, rather just a comment. I believe in standards - the analogy to the automobile was an excellent one. I do _not_ believe the whole world needs to standardize on Ada, rather that whatever languages we choose to use in the present and future be subject to standards and a validation process. At least we should try to focus on this in real systems. As a professor, I understand well the purpose of experimentation, in a lab or protoype setting, with new languages and features. To carry through the analogy with cars, there are _lots_ of experiments done with prototype cars - some of these get into production, others don't. I believe it is a sign of maturity in the industry that we can see the difference between a protoyping situation and a real, production one. A standard promotes interchageability of parts. Again, remember that many of the current engineering stanards (nuts & bolts, etc.) originated in the early days of Henry Ford's asembly lines. SAE stands for Society of Automotive Engineers. A language standard promotes interchangeability of programs across platforms and between different compilers on the same platform. It is a sign of maturity and professsionalism when the industry realizes that standards, _real_ ones, not like the Fortran and Pascal standards, are better for the health of the industry than lots of proprietary dialects. I think the tough line taken by DoD on Ada blazed the trail on this issue, but the emerging C and Modula-2 standards will follow the same basic philosophy. For contrast, have any of you ever tried porting a nontrivial Turbo Pascal program to Microsoft Pascal (let alone to Vax Pascal)? Lemme tell ya, it's no fun. The Pascal world is a chaotic babble of proprietary dialects built on top of a standard that is so minimal as to be useless. Turbo Pascal may be the de facto standard Pascal for the PC family, but what happens when you try to move that code to a Sun? You are, in the memorable words of President Bush, in deep doo-doo. (Aside: how many of you have ever looked at the Pascal standard? Why would you bother?) The Fortran standard is another mess. Since implementers are free to _superset_ the standard, they do, leading to dialect wars. And at least last time I looked, the GSA regulations specified that, for Govt. work, if you were using Fortran, it had to be a "standard" compiler. But it did _not_ say in the regs that programmers couldn't use the proprietary bells and whistles. The same story can be told about Cobol. Converting Fortran and Cobol code for other platforms is hard because people get snared into using the goodies, often because they have never looked at the standard and therefore can't distinguish goodies from non-goodies. The neat thing about the Ada, C, and Modula-2 communities is that they have all developed the discipline not to get into dialect wars. This is, for me, a very good sign. Better still, in the Ada and C worlds, most people are aware of the standard and the need to follow it. The Modula-2 standard is still in the drafting, but as an avid reader of Info-M2, I can confirm that users and vendors alike _really want the standard_ and will stick to it. More signs of maturity, IMHO. As for the change cycles with Ada: indeed, the standard needs to be updated now and then. But if the update cycles were too frequent (even if were politically possible to reach quick consensus on changes, which it ain't), there would be chaos in the compiler industry, and nobody could be sure what version they were getting. There is a fundamental tension between the virtues of adaptation and the virtues of stability. This will never go away. And Ada now has enough of a life of its own that DoD is probably no longer in a position to be as dictatorial as it once was. But if we want the benefits of stable, mature, efficient compilers, we'll have to live with infrequent changes to the standard. No free lunch, folks. About Eiffel: I like it. I like Meyer's book even better. My reservations are the same ones I have about Turbo Pascal: at least so far, the language is (sorta) proprietary. Meyer seems less greedy than Philippe Kahn, and seems to be willing to help others, especially universities and the like, develop Eiffel ports and play with the compiler technology. This is a good sign and I applaud Meyer for this. For me, Eiffel combines the virtues of OOP with the virtues of a clear, easy-to-read, Pascal- or Ada-ish syntax. Not to start a language war, but for this reason I favor it over C++. To summarize: the industry doesn't have to standardize on a single language (certainly not in the absence of a DoD telling 'em they have to). But the languages used in industry, for production systems, darn well oughta have realistic standards that users and implementers alike respect enough to stick to. This is the way things are heading; let's keep up the good work. --------------------------------------------------------------------------- Prof. Michael Feldman Department of Electrical Engineering and Computer Science The George Washington University Washington, DC 20052 +1-202-994-5253 mfeldman@seas.gwu.edu ---------------------------------------------------------------------------