petcher@skvax2.csc.ti.com (03/17/89)
The first thing we must do is agree on the definition of the term "general purpose language." Opinions will vary, but in general the characteristics of such a language are that it can 1.) add, subtract, multiply, and divide. 2.) store the results of the above operations. 3.) Branch to one of two different program paths based on the results of the above operations. Anything else is gravy, including bitwise logical operations (some of which are *damn* hard in Ada!) The outcome of this is, technically, you can do anything in any "general purpose" language, and you can do it without writing a compiler or interpretter for some other language. You *can* do pipe stress analysis in LISP, and you *can* do AI programming in FORTRAN (YOU can! Don't ask me to!) However, certain languages are optimized for certain applications. I use C a lot, and it is wonderful for what I do, because it allows working with high level structures and low level bit flipping in the same problem space. However, there probably isn't a thing I've done in C that couldn't have been done in any general purpose language, even BASIC. It's just that the sort of software I write, and the programming style I use, agree best with C. Other sorts of software are easier in FORTRAN, or LISP, or even ADA. Probably even more important than what language is most appropriate for a given application is what language is the programmer most comfortable with. People will go out of their way to use the language they like best, no matter how inappropriate it is for the task at hand. In a lot of cases, that's OK, though it can generate maintainability problems. Now that I've rambled at length about *my* philosophy, we must get back to the real world. If you get a contract from the government that says you must use Ada, then all this discussion about convertability from other languages becomes quite academic, doesn't it? Malcolm Petcher
mcdonald@uxe.cso.uiuc.edu (03/18/89)
>The first thing we must do is agree on the definition of the term "general >purpose language." Opinions will vary, but in general the characteristics of >such a language are that it can 1.) add, subtract, multiply, and divide. >2.) store the results of the above operations. 3.) Branch to one of two >different program paths based on the results of the above operations. >Anything else is gravy, including bitwise logical operations (some of which >are *damn* hard in Ada!) The outcome of this is, technically, you can do >anything in any "general purpose" language, and you can do it without writing >a compiler or interpretter for some other language. I would like to propose one thing that a "general purpose" language should allow: incremental compilation. That is, it should be possible, in a legal program, to write a program such that, at run time, a user can input code in the language, and have it compiled and execute, and be able to do anything a programmer could do feeding the input into a compiler. This need only be true "in principle", as obviously for a large language writing a compiler is a large task. I am not aware of any (normally compiled as opposed to interpreted) languages where this is true. Forth comes close, but C and Fortran and Cobol and Pascal and friends all seem to make it impossible, although it takes only a tiny little change to C (i.e. make it legal to cast a data pointer to a function pointer, and be able to execute that function) to make it possible there. For many C implementation it is de facto possible. What about Ada? (I have not the foggiest idea about the answer.) Doug McDonald