[FoRK] l.py --- musing about lisp implementations

[rst at ai.mit.edu]

Jeff Bone writes:
 > It seems very clear to me that we're just polishing turds in pursuing  
 > this course of language evolution.  If you want fundamental  
 > improvements in programming language expressivity and hence programmer  
 > productivity, you have to approach things from a fundamentally  
 > different model of computation.  Erlang (join calculus), Haskell and  
 > other typed functional languages (equational reduction), Prolog (logic  
 > and Horn clauses), APL (linear algebra), and so on do this.  Yet  
 > Another Lisp does not.

You could also attack problems that weren't important in the past,
and that good solutions aren't really available for yet.  Graham's
advertising this as "the language for the next hundred years."  Well,
when I think about the challenges of not the next hundred years, but
the next twenty, I think about:

  *) Exploiting hardware with hundreds or thousands of cores,
     non-"von-Neumann" computational pipelines (as in current
     GPUs), and exotic nonuniform communications interconnects.

  *) Growing in a different direction, exploiting more loosely
     coupled parallel arrays in bulk operations over massive
     amounts of stored data (a la Google's MapReduce, BigTable,
     and --- no doubt --- the more interesting stuff they still
     have under wraps).

  *) Providing stronger guarantees about security-related properties
     (e.g., the various blog pages that are increasingly easy to find
     about various ways to use the Haskell type system to flag potential
     SQL injection attacks).

  *) Computational agents distributed on a planetary scale, in a manner
     robust against network partitions and the like, in part at remote 
     sensor nodes where there are strong constraints on power consumption
     and network connectivity. 

(Note that this might well include playing with new computational
models as well, as noted particularly wrt the security issue; it's
just a question of different emphasis...)

Arc, by contrast, seems so far to be addressing the problems of the
last century, and not in a way profoundly different that's gone before;
the differences with other Lisp dialects are so far mostly syntactic,
and, say, Dylan went a whole lot farther in that direction, without
tossing macros out the window...

rst