SAHARBAUGH@ROO.FIT.EDU (05/21/91)
I have read with interest the BB conversations about Ada vs C++. I received by mail an advertisement for Franz Lisp. It says, among other things: "if you're trying to develop complicated applications with C++, you're working too hard. It's a good introduction to object- oriented programming, but it doesn't have the built-in functionality of the world's most advanced OOP tool: Allegro CL Common Lisp with CLOS." It goes on to mention Multiple inheritance, custom facilities, persistent storage, object-oriented databases, dynamic redefinition of classess and methods, generic functions and says "(it) is the most powerful object-oriented programming language available today." Vendors are expected to overstate the worth of their product, the legal term is "puffing", BUT are we missing something by not discussing Franz Lisp in the same context as C++ when discussing the "vs Ada" language issue? sam harbaugh saharbaugh@ROO.FIT.EDU -----------
jls@netcom.COM (Jim Showalter) (05/23/91)
>Vendors are expected to overstate the worth >of their product, the legal term is "puffing", >BUT are we missing something by not discussing >Franz Lisp in the same context as C++ when >discussing the "vs Ada" language issue? There are a number of OO languages that are "purer" than C++. That's been one of the criticisms leveled at C++, in fact: that in order to maintain compatibility with C a lot of compromises had to be made that aren't necessary in a from-scratch language design (such as Eiffel and, probably, Franz Lisp). The reason I tend to focus primarily on C++ vs Ada is that C++ is becoming a de facto OO standard at a distressingly rapid pace and, as such, represents what I think is the single largest competition to Ada in cutting-edge OO and software engineering in the commercial sector. Seeing as how it is my personal vision that Ada be used to build lots and lots of large complex systems that have nothing to do with the government sector, I'm committed to offering a credible rebuttal to C++ whenever and wherever possible. It's not that it is impossible to engineer a complex system in C++, it's just that Ada is at least equally capable of doing so, and is a far more mature and robust option, so why not use it? -- **************** JIM SHOWALTER, jls@netcom.com, (408) 243-0630 **************** *Proven solutions to software problems. Consulting and training on all aspects* *of software development. Management/process/methodology. Architecture/design/* *reuse. Quality/productivity. Risk reduction. EFFECTIVE OO usage. Ada/C++. *
chuck@brain.UUCP (Chuck Shotton) (05/25/91)
> The reason I tend to focus primarily on C++ vs Ada is that C++ is > becoming a de facto OO standard at a distressingly rapid pace and, > as such, represents what I think is the single largest competition > to Ada in cutting-edge OO and software engineering in the commercial > sector. Seeing as how it is my personal vision that Ada be used to > build lots and lots of large complex systems that have nothing to > do with the government sector, I'm committed to offering a credible > rebuttal to C++ whenever and wherever possible. It's not that it is > impossible to engineer a complex system in C++, it's just that Ada > is at least equally capable of doing so, and is a far more mature > and robust option, so why not use it?> -- > **************** JIM SHOWALTER, jls@netcom.com, (408) 243-0630 **************** I think the single, most important reason that C++ is overtaking Ada as the OO language of choice is the very thing that makes Ada the DoD choice. Ada's extreme standards process works to its detriment in introducing new changes to the language. C++ came out of nowhere, without any of the bureaucratic nightmares levied on Ada. A few, innovative people added REAL object oriented extensions to C and tossed it on the market. Ada 9X may very well turn into Ada 20X by the time any compilers hit the street. Let me say that I am in no way a supporter of C++, nor a detractor of Ada. (I've worked on the Space Station program for the past 4 years and done nothing but Ada development.) However, C++'s support for object-oriented pardigms such as inheritance, true methods, and dynamic binding are much closer to "true" OO development than the work-arounds that Ada supports. You can hardly argue that a generic or a task type can completely substitute for a true class definition with instance variables, methods, and inheritance. Ada requires too much of a burden to be placed on coding conventions and programming style and provides too little support for "objects" in its current state to be considered a "real" object-oriented language. There's just no adequate support inherent in the languge. I won't argue the point that Ada is far superior when it comes to large system development. This is a fact, plain and simple, and C++ cannot hold a candle to Ada's abilities to decompose a problem into managable pieces and insure the consistency between them. However, Ada is not all things to all programming tasks, and one of the things it isn't is an object oriented programming language. Information hiding, strong typing, and generics does not an OOP make. Maybe when Ada 9X's support for procedures as arguments, etc. becomes available, this comparison between C++ and Ada as OOPs will be a little more on target. But until then, there is no comparison. Defending Ada, tooth and nail, on EVERY application is a no-win situation. Ada CAN'T do some things as well as other languages. ----------------------------------------------------------------------- Chuck Shotton Internet: cshotton@girch1.med.uth.tmc.edu "Your silly quote here." UUCP: ...!buster!brain
jls@netcom.COM (Jim Showalter) (05/30/91)
>I won't argue the point that Ada is far superior when it comes to large system >development. This is a fact, plain and simple, and C++ cannot hold a candle >to Ada's abilities to decompose a problem into managable pieces and insure >the consistency between them. However, Ada is not all things to all programming >tasks, and one of the things it isn't is an object oriented programming >language. From the above paragraph, we have these two statements: 1) Ada is a superior language for engineering large complex systems. 2) Ada is not particularly supportive of OOP. These two statements lead to the following conclusion: 3) OOP is largely irrelevant when it comes to engineering large complex systems. Now, far be it from me to actually MAKE this claim [;-)], I'm merely pointing out that it is the inevitable subtext of the above paragraph. Given that this claim has been made, I'm interested to see what sorts of real-world data can be used to support or refute it. I keep hearing that OO this and OO that are going to solve the software crisis and feed all the world's children (much like structured programming was going to do 20 years ago...), but where is the DATA? How many practitioners of so-called "pure" OO out there in net-land have success stories to tell about projects on the order of 250KSLOC on up, preferably doing something difficult like real-time process control or heterogeneous/distributed computing? And the second, perhaps more important question I have is: on such projects, to what degree did OO truly play a role (how much of the code was based on inheritance and polymorphism, etc) vs more traditional programming idioms? I volunteer to provide success stories for similar projects successfully completed NOT using "pure" OOP (data encapsulation and information hiding were certainly used, but inheritance and polymorphism were not). -- **************** JIM SHOWALTER, jls@netcom.com, (408) 243-0630 **************** *Proven solutions to software problems. Consulting and training on all aspects* *of software development. Management/process/methodology. Architecture/design/* *reuse. Quality/productivity. Risk reduction. EFFECTIVE OO usage. Ada/C++. *
ted@grebyn.com (Ted Holden) (05/30/91)
In article <9105211321.AA05681@ajpo.sei.cmu.edu> SAHARBAUGH@ROO.FIT.EDU writes: >Vendors are expected to overstate the worth >of their product, the legal term is "puffing", >BUT are we missing something by not discussing >Franz Lisp in the same context as C++ when >discussing the "vs Ada" language issue? >sam harbaugh saharbaugh@ROO.FIT.EDU You're not missing much. Franz Lisp does not include the low-level power and flexibility of C/C++, the immediate handles into every kind of UNIX functionality, the immediate applicability of every new development in the industry... A lot of the discussion revolves around the phrase "reusability of code". The best book available on the topic is the Programmer's Connection catalog, the most major catalog for programmer/developer/designer tools in the mini/micro world. You'll find about a fifth to a half a column's worth of aftermarket stuff available for each of the other languages, and several whole pages for C, such is the dominance of C/C++ in America's market at present. Future medium-large systems will be parallel machines made from these same microchips, and will be programmed with similar software. C++ is the best compromise available for the next ten years or so. LISP may or may not be a better language if you could confine yourself to one platform and one class of programs to write forever, but life isn't like that. Ted Holden HTE
chuck@brain.UUCP (Chuck Shotton) (05/31/91)
In article <1991May30.004144.24252@netcom.COM>, jls@netcom.COM (Jim Showalter) writes: > >I won't argue the point that Ada is far superior when it comes to large system > >development. This is a fact, plain and simple, and C++ cannot hold a candle > >to Ada's abilities to decompose a problem into managable pieces and insure > >the consistency between them. However, Ada is not all things to all programming > >tasks, and one of the things it isn't is an object oriented programming > >language. > > >From the above paragraph, we have these two statements: > > 1) Ada is a superior language for engineering large complex systems. > 2) Ada is not particularly supportive of OOP. > > These two statements lead to the following conclusion: > > 3) OOP is largely irrelevant when it comes to engineering large complex systems. > > Now, far be it from me to actually MAKE this claim [;-)], I'm merely > pointing out that it is the inevitable subtext of the above paragraph. > First, the only point being made in 1 and 2 above is that Ada is well suited to supporting the decomposition of systems into manageable pieces, and it doesn't provide the same level of SYNTACTIC support for OOP as other professed OOP languages. Don't put words in my mouth. The third conclusion is simply a faulty conclusion from the intent of the first 2. I'd like YOU to explain to netland how to support dynamic inheritance at runtime in Ada without resorting to manually-supported coding conventions. I've had a direct hand in the management, design, and implementation of about 250,000 lines of Ada over the past 2 or 3 years on NASA's SSE contract. We used OOD techniques such as Buhr diagraming, etc. and coded according to the design. BUT THAT DOESN'T MAKE THE CODE OBJECT ORIENTED. The whole point of the comparison between C++ and Ada hinges on the semantic interpretation of the term "object-oriented." To most Ada-literate individuals, "object-oriented" refers to the concepts of information hiding and specific design methodologies. To others (C++, academia, etc.) "object-oriented" connotes message passing, inheritance, dynamic binding, methods, classes, etc. Ada does NOT provide direct support via language constructs and run-time behavior to support all of these concepts. The burden is placed on the programmer to implement "message passing" and there is no way to safely (consistenly) implement dynamic binding. Rather than degenerate into a "mine's bigger than yours" comparison of two vastly different languages (and programming paradigms), it would be more constructive to discuss how to implement TRUE object-oriented features within the current limitations of Ada. I'd be interested in hearing suggestions for supporting the aforementioned list of "alleged" object oriented language features using plain vanilla Ada. This could actually be useful on some real projects. ----------------------------------------------------------------------- Chuck Shotton Internet: cshotton@girch1.med.uth.tmc.edu
jls@netcom.COM (Jim Showalter) (06/01/91)
chuck@brain.UUCP (Chuck Shotton) first wrote: >> >I won't argue the point that Ada is far superior when it comes to large system >> >development. This is a fact, plain and simple, and C++ cannot hold a candle >> >to Ada's abilities to decompose a problem into managable pieces and insure >> >the consistency between them. However, Ada is not all things to all programming >> >tasks, and one of the things it isn't is an object oriented programming >> >language. I [jls@netcom.com (Jim Showalter)] then responded that the obvious conclusion to be drawn from the above paragraph was that OO is apparently basically irrelevant to developing large systems. chuck@brain.UUCP (Chuck Shotten) then responded: >First, the only point being made in 1 and 2 above is that Ada is well suited >to supporting the decomposition of systems into manageable pieces, and it >doesn't provide the same level of SYNTACTIC support for OOP as other professed >OOP languages. Chuck, let me try again. When I read the first paragraph above, what I hear is "Ada is far superior to C++ for large system development" AND "Ada is not an object oriented programming language". Correct me if I'm wrong, but don't these two statements in conjunction essentially say "Ada, which is not an object oriented programming language, is nevertheless far superior to C++ for large system development"? If so, why do you deem it unreasonable for me to go one step further and conclude "The usefulness of the 'pure' OO paradigm for actually building large systems may well be overstated" (a conclusion I came to years ago)? I'm reading the same text you're writing--please help me to understand why we are in such disagreement. >I'd like YOU to explain to netland how to support dynamic inheritance at >runtime in Ada without resorting to manually-supported coding conventions. I never claimed that Ada was a so-called "pure" object-oriented language; not surprisingly, what you describe above is hard to do in Ada. What I HAVE claimed, repeatedly, is that this is in all likelyhood not much of a deficit, particularly since what CAN be done and HAS been done in Ada is stuff like building, on time and on budget, mega-SLOC distributed real-time systems that meet all of their performance requirements (can you make similar claims for any of the predominant "pure" OO languages?--this is not a flame: I'm honestly asking if anybody can supply similar success stories for significant projects written in C++, Smalltalk, Eiffel, etc [I asked a similar question a week or so ago, and have so far received no responses]). I have long believed that the most significant payoff from using an OO language was in its general support for ABSTRACTION (e.g. narrow interfaces, hidden data, etc), not in its specific support for inheritance and polymorphism. Focusing on interfaces and design, suppressing inessential details, and enforcing it all through the compiler is the big win that gets you 90% (or more) of the way toward a well-engineered system. Support for inheritance is just icing on the cake. Don't believe me? Consider, then, a new language, C++--. This language retains the support for inheritance and polymorphism offered by the current C++ language, but it is defined in such a way that the .h files cease to exist, as do the notions of private and protected data. Now, you tell me--what would be the relative usefulness of this hypothetical language in comparison to, say, Ada, which HAS private data and a spec notion analogous to C++'s .h files? I think the answer is obvious--as soon as the support for abstraction capture and enforcement is removed, the remaining benefits of the language are minimal, even though what remains supports inheritance, dynamic binding, and all that jazz. I'm not saying that inheritance is useLESS, just that we should strive to assign accurate relative weights to the various language features, and first concentrate on getting the MOST useful features across to the widest possible audience. To run off trying to spread the gospel about the wonders of multiple inheritance in an industry where I have actually heard a well- paid developer at a Large American Corporation ask (in all honesty): "What is an interface?" seems to me to be a misguided expenditure of energy and time. >The whole point of the comparison between C++ and Ada hinges on the semantic >interpretation of the term "object-oriented." To most Ada-literate individuals, >"object-oriented" refers to the concepts of information hiding and specific >design methodologies. To others (C++, academia, etc.) "object-oriented" connotes >message passing, inheritance, dynamic binding, methods, classes, etc. Ada >does NOT provide direct support via language constructs and run-time behavior >to support all of these concepts. The burden is placed on the programmer to >implement "message passing" and there is no way to safely (consistenly) implement >dynamic binding. And the burden is placed on the OO academic to demonstrate that any of this is of any use in building real systems. It is probably a good idea to keep in mind that the entire industry is NOT yet convinced that the OO paradigm is the One True Way, that there are horror stories of projects going terribly awry by embracing too uncritically the whole OO sales pitch (things, for example, sometimes run too slowly to meet the original requirements...), that there is some evidence of a growing backlash against OO because it has turned out in at least some cases to have been oversold (as is the way with most One True Ways), and so forth. Just because a cause generates a lot of press and a lot of true believers doesn't make it RIGHT. It has been my observation that OO fervor needs to be tempered with pragmatism based on real-world experience, or it leads to disappointment. >Rather than degenerate into a "mine's bigger than yours" comparison of two >vastly different languages (and programming paradigms), it would be more >constructive to discuss how to implement TRUE object-oriented features within >the current limitations of Ada. I'd be interested in hearing suggestions for >supporting the aforementioned list of "alleged" object oriented language features >using plain vanilla Ada. This could actually be useful on some real projects. I believe there are several pre-processors available for Ada that add these very features to the language at relatively low cost. I've never felt the need for such features, so I've never looked into what these pre-processors actually do, but I've heard that they're pretty useful. -- **************** JIM SHOWALTER, jls@netcom.com, (408) 243-0630 **************** *Proven solutions to software problems. Consulting and training on all aspects* *of software development. Management/process/methodology. Architecture/design/* *reuse. Quality/productivity. Risk reduction. EFFECTIVE OO usage. Ada/C++. *