Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!sdd.hp.com!samsung!spool.mu.edu!news.nd.edu!mentor.cc.purdue.edu!purdue!haven!ni.umd.edu!uc780.umd.edu!cs450a03
From: cs450a03@uc780.umd.edu
Newsgroups: comp.lang.misc
Subject: RE: Dynamic typing (part 3)
Message-ID: <25MAR91.23124852@uc780.umd.edu>
Date: 25 Mar 91 23:12:48 GMT
References: <1021@optima.cs.arizona.edu> <1492@sheol.UUCP>
Sender: usenet@ni.umd.edu (USENET News System)
Organization: The University of Maryland University College
Lines: 52

Wayne Throop   >   (and, I presume  >-]  )
David Gudeman  >-
>-] As late as Algol 68, the arguments are mostly about whether
>-] things can, *in principle*, be compiled;
>- Yep, psychotic fixation on efficiency.  They weren't arguing on
>- whether something could be _implemented_, they were worried about
>- producing machine code.
>It seems clear that David is misinterpreting the above statement.  There
>is NOT a fixation on efficency evident here...  the phrase "can, in
>principle, be compiled" means exactly what David means by "can be
>implemented" in this context. 

Well, I wouldn't call it psychotic, more of a blind spot.  

I posted an earlier article on J (the one about run-time syntax
checking).  Just to give you the creeping horrors, consider the
following line of code:

  x=. +x 1 2 3 ,(*(x=./) 4 5 6) x 7 8 9 (x=.+) 10

Here's how it would parse:

  x=. +x 1 2 3 ,(*(x=./) 4 5 6) x 7 8 9 (x=.+) 10
  x=. +x 1 2 3 ,(*(x=./) 4 5 6) x 7 8 9 (+) 10
  x=. +x 1 2 3 ,(*(x=./) 4 5 6) x 7 8 9 + 10
  x=. +x 1 2 3 ,(*(x=./) 4 5 6) + 7 8 9 + 10
  x=. +x 1 2 3 ,(*(x=./) 4 5 6) + 17 18 19
  x=. +x 1 2 3 ,(*(/) 4 5 6) + 17 18 19
  x=. +x 1 2 3 ,(*/ 4 5 6) + 17 18 19
note: */4 5 6  <-->  4*5*6
  x=. +x 1 2 3 ,(120) + 17 18 19
  x=. +x 1 2 3 ,120 + 17 18 19
  x=. +x 1 2 3 ,137 138 139
  x=. +/ 1 2 3 ,137 138 139
  x=. +/ 1 2 3 137 138 139
  x=. 420
  420

In this case, implementing machine code is trivial -- the whole line
boils down to the constant 420.  However, one could easily replace any
of the objects on the above line with a variable, or a read from
standard input, etc.   Not that any of that would be particularly
meaningful in this case.

Now, the line of code I choose is particularly ill-conditioned, which
makes it ideal for pointing out that things can be implemented which
do not have an efficient implementation for all cases.  I think that a
lot of things might have been knocked out of ALGOL, not because they
could not be implemented, but because they didn't map well into the
framework the implementors were using.

Raul Rockwell