Ada vs LISP vs C vs ...

Ada vs LISP vs C vs ...

[petcher]

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

Re: Ada vs LISP vs C vs ...

[mcdonald]

>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