From mboxrd@z Thu Jan 1 00:00:00 1970 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on polar.synack.me X-Spam-Level: X-Spam-Status: No, score=-1.9 required=5.0 tests=BAYES_00 autolearn=ham autolearn_force=no version=3.4.4 X-Google-Language: ENGLISH,ASCII-7-bit X-Google-Thread: 103376,28422a75b92db2c6 X-Google-Attributes: gid103376,public X-Google-ArrivalTime: 2001-12-06 15:16:46 PST Path: archiver1.google.com!news1.google.com!newsfeed.stanford.edu!news.tele.dk!small.news.tele.dk!130.133.1.3!fu-berlin.de!uni-berlin.de!ppp-2-98.cvx5.telinco.NET!not-for-mail From: "Nick Roberts" Newsgroups: comp.lang.ada Subject: Re: Smalltalk and Ada Date: Thu, 6 Dec 2001 22:59:22 -0000 Message-ID: <9uou8q$a57td$1@ID-25716.news.dfncis.de> References: NNTP-Posting-Host: ppp-2-98.cvx5.telinco.net (212.1.153.98) X-Trace: fu-berlin.de 1007680603 10657709 212.1.153.98 (16 [25716]) X-Priority: 3 X-MSMail-Priority: Normal X-Newsreader: Microsoft Outlook Express 5.50.4133.2400 X-MimeOLE: Produced By Microsoft MimeOLE V5.50.4133.2400 Xref: archiver1.google.com comp.lang.ada:17544 Date: 2001-12-06T22:59:22+00:00 List-Id: I suspect you won't find any existing comparisons between Ada and Smalltalk. One interesting observation I have made is the way in which devotees of both languages consider their language (Ada or Smalltalk) to be especially suited to 'software engineering'. Of course, I suspect different people have different ideas of what 'software engineering' means. To some it seems to be about constructing software which operates in close connection with hardware; I guess hardware engineers culturally like to supplant hardware engineering concepts onto software. Ada's areas of application tend to be very much here (more as a result of the history of the language rather than its features). To others, especially Smalltalk people I think, it is purely about the construction of software, but constructing it in ways which have analogies to good engineering principles (e.g. overspecification of a structural member's strength, as compared to redundancy and robustness techniques in a program). Smalltalk has had some remarkable successes in the building of large, complicated applications quickly (i.e. economically) yet with an unusually high level of quality (for that kind of software). Smalltalk is a great language for building (high-level) application software fast. You can start building ideas straight away: you make a list of entities in the application domain, and then make a class or object for each one; add suitable methods, and test them out, interactively; add interface components; add database and/or filing components; connect stuff up, and lo! you've got the beginnings of a solution. Because Smalltalk is strong on things like default behaviour, incremental refinement, and closeness of correspondence between the software model and the real-world model, you tend to be able to push forward rapidly, without having to keep going back and changing your design, or lots of implementational details. Smalltalk has a small syntax, and always has an 'object browser', so it can be easy to learn. However, Smalltalk has some serious disadvantages. Compilation is one. Some Smalltalks can compile to native code, but oh so slowly. Too slow to be a part of the development cycle. It is therefore useless for most low-level programming. Even then, the native code produced will never be as good as that produced by a program reasonably well written in a 'traditional' compiling language (like Ada). Another disadvantage is the fact that Smalltalk makes the assumption that the target is the host, and that this must be powerful enough to support Smalltalk's typically huge memory requirements and a full GUI. Ada has a lot of hidden strengths. It's a very practical language. It has all the (important) advantages of 'traditional' compiled languages (COBOL, Fortran, Algol, C, Pascal, Modula, C++, etc.), but with solutions to (or improvements on) most of the major practical shortcomings of these languages. Nevertheless, Ada is able to live pretty directly in traditional language environments, and can target embedded and 'tiny' environments. It can interface directly with object code produced by compilers of other languages. It is excellent at the low level, and adequate at the high level; this mix can be very potent in some circumstances. Ada has a fair few oddities and subtleties of use; it may be quite quickly learnt, but is less quickly mastered. The best mitigation for this is that Ada compilers catch a great many mistakes (that would be caught only dynamically or not at all by other languages). Smalltalk is all-pervasively object-oriented (it was the language that invented the concept). Ada 95 provides object-oriented programming facilities, but these are (almost) additional to the core language, and can generally be ignored if not required. One interesting comparison between Smalltalk and Ada is that they both support only single-inheritance (a class/object can only have one parent class). The one really big -- stark, even -- difference between Smalltalk and Ada is in standardisation: you will find that every different Smalltalk product is highly incompatible with nearly every other one; you will find that very nearly every Ada implementation is very highly compatible with all the others. You will find useful information on Ada at: http://www.adapower.com I think you will find some useful information about Smalltalk at: http://www.dnsmith.com/SmallFAQ/SmallFaq.html and: http://www.smalltalk.org.au/index.html as well as, of course, the Usenet news group: comp.lang.smalltalk Hope this gives you a little food for thought! -- Best of luck, Nick Roberts