Re: Writing fast compilers II rs/6000

[From comp.arch -John]


Herman Rubin:
            I do not happen to know a language which will let you write 'a
            matmult b' (except possibly APL, which has its quirks.) [...]
            Also, why not allow the use of |x| for abs(x) or whatever the
            type calls for? This was not done initially because the
            vertical bar was not available as a character; that is why
            Fortran used * for multiplication and ** for exponentiation.


Thomas M. Breuel:
      The trouble is that too many language designers get caught up in
      syntax and paradigms. It makes no real difference whether you write
      |x| or abs(x); if anything, the latter syntax is preferable because
      it is simpler to understand how it gets parsed. As long as you can
      write function calls with an unlimited number of arguments (you
      cannot in old BASIC or APL), syntax doesn't matter much.


Presumably you can in newer BASICs. (As an aside, HP Basic for the HP
2000 had matmult back in the '70s.) Also, newer APLs allow function
calls with an unlimited number of arguments (these include APL2,
Dyalog APL, the now defunct Sharp APL, and related dialects, like J).


      The important questions about a programming language are:


        * What kind of type system does it have?
        * Does it have inheritance?
        * Does it have automatic type conversions?


Also, how robust are the primitive types?


        * Does it have an exception system?
        * What kind of module system does it have?
        * Does it have side-effects?


And, is it necessary to use side-effects to write non-trivial
programs?


        * Is it lazy or eager?


Or, "is it possible to write conditionals in the expression syntax"?


        * What kind of runtime-overhead does it require?


Note that for some languages this will vary significantly depending on
the problem domain.


        * Does it have operations with "undefined effects"?


And, how extensive are these?


        * Does it have automatic storage management?


And does it have real-time performance characteristics?


        * Does it have first-class closures?
        * Does it have first-class argument-lists?


And, does it have first-class data-selection primitives?


        * Does it have macros or EXTEND-SYNTAX?
        * Does it have EVAL or COMPILE-AND-LOAD?


And, if it compiles, does it compile to machine code or an
intermediate language? Likewise, if it evals, does it have some sort
of tokenizing methodology, or must it reparse from raw text each time?
(Yeah, this might be considered part of the "what kind of runtime
overhead does it have?" question.)


        * Does it support persistence?


And how well does it support mass storage media? (e.g. how
transparent is this? is data on mass storage treated as first class?)


And, how well does it support arbitrary communication? (e.g. internet
protocols)...


And then there's practical, but transitory, things like how well can
it be tied to existing programs written in other languages? And how
good is the programming environment?


--
Raul <rockwell@socrates.umd.edu>
--

Return to the comp.compilers page.
Search the comp.compilers archives again.