Re: Alternatives to C: ObjectPascal, Eiffel, Ada or Modula-3?

[Adam Beneschan <adam@irvine.com>]

On Mar 24, 1:00 pm, Warren <ve3...@gmail.com> wrote:
> Adam Beneschan expounded innews:bf27602c-09c5-45e4-97c1-608bf9729cbb@s2g2000prd.googlegroups.com:

> >> I smell an interpreter!
>
> >> >> This doesn't meet my criteria for what I'd call an interpreted
> >> >> language.  For that, I'd assume that the interpreter reads the
> >> >> original source statements, or some sort of tokenized form that
> >> >> bears a close relation to the original source statements, while
> >> >> running the program.  
>
> >> That's a pretty narrow view.
>
> >> Usually ppl talk of "interpreted" vs "native code execution".
> >> It would be incorrect IMO to call p-code natively executed
> >> code.
>
> > So it's executed by an interpreter.  That doesn't make the *language*
> > compiled into p-code an INTERPRETED LANGUAGE, which is what we were
> > talking about---not any old "interpreter".
>
> >                                       -- Adam
>
> So by your definition, my "tokenized basic" isn't interpreted either?
> It saves as an intermediate byte code also. So did GWBASIC IIRC. But
> nobody would say that GWBASIC wasn't interpreted.

Please read carefully what I wrote earlier: "For that, I'd assume that
the interpreter reads the original source statements, or some sort of
tokenized form that bears a close relation to the original source
statements, while running the program."

I don't know what GWBASIC's intermediate byte code looked like.  But
if it was, in essence, an encoded representation of the source---"that
bears a close relation to the original source statements", to quote
myself---then it's an interpreted language.  p-code does not bear any
such relation to the Pascal source.  I know that the question of "how
close is the byte code to the source" is a fuzzy one.


> Sorry, but if any "execution" requires the help of an interpreter,
> it is "interpreted" at some level(s), even in Java's case.
>
> Now if the O/S could load and hand control over control to the
> loaded code (exec) without involving a separate process, then
> that would be different. Otherwise, I still smell an interpreted
> "language".

I think your definition of "interpreted language" is too broad to be
meaningful.  Suppose I had a Pascal compiler that generated code for a
processor that is no longer manufactured.  So I write a program that
emulates that processor.  That's effectively an interpreter, but does
that make Pascal an interpreted language?  Not in any meaningful
sense.  And what's the difference if the interpreter is for a
processor that no longer exists, or for a processor that never existed
such as the p-machine?

To relate it back to the topic of discussion: I think it was you that
claimed that it was meaningless to compare C/C++ results to Java, C#,
or Pascal (variants) because the latter were "largely interpreted
languages".  To be meaningful, a statement like that has to be talking
about the language as a whole, not just one or a few idiosyncratic
implementations of a language.  Some languages are definitely designed
to be interpreted---APL, Perl, and Lisp all allow you to build strings
or list structures at runtime that can be executed, and then execute
them.  Also, all of those languages support variables whose types can
change during execution, making it difficult to generate efficient
machine code.  I don't know much about Java, but I believe it was
designed to be interpreted (by a virtual Java machine) on different
platforms, although apparently it can be compiled; I don't know
whether the language design prevents it from being compiled into code
that's as efficient as other languages.  I don't know anything about
C#.

Pascal, on the other hand, doesn't have any of the characteristics
that make "interpreted languages" what they are.  Its variables are
statically typed, and there is no built-in facility for parsing and
executing a Pascal statement at runtime.  Whatever other features
there may be that are interesting about "interpreted languages",
Pascal doesn't have them.  In short, Pascal, as a *language*, is a
traditional compiled language and there is absolutely no basis for
putting it into the "interpreted language" category, period.  The fact
that one popular implementation of this language used a virtual
machine and an interpreter for that machine is irrelevant.

                                     -- Adam