Modern Languages vs the Ancient... (Was Metaprogramming)

[Rudolph van Graan]

Hi Guys,

This whole topic interest me greatly. Unfortunately I've not been  
part of the Lisp generation ;) - my only experience in Lisp stems  
from the fact that I had to make emacs work for me. To date Lisp is  
the greatest mystery ever. I've managed to salvage one good book  
which someone else threw away, written in 1982 "Lisp" by Winston and  
Horn. What amazes me is the type of problems solved in the late  
seventies. From the TOC:

Chapter 18: Lisp in Lisp (Building an interpreter)
         24: Symbolic pattern matching
         26: Rule based expert systems and forward chaining
         30: Procedure writing programs

etc

What worries me is that the "old" languages managed to do things that  
are nearly impossible or very difficult (in my opinion) to do in  
modern languages. How come the Javas and C#'s etc lost these  
abilities and be called modern?

I've noticed a VERY disturbing pattern emerging lately in the java  
world (Unfortunately I do a lot of Java consulting with one leg in  
the very muddy Websphere world), it is as though people have now  
started to discover that you can "reconfigure" your code outside your  
code. So essentially you write these little XML files describing the  
behaviour of something. They might look like this (Taken from http:// 
static.springframework.org/spring-webflow/docs/1.0-rc3/reference/flow- 
definition.html#flow-xml the very popular spring framework for J2EE) :

     <flow start-state="displaySearchForm">
         <view-state id="displaySearchForm" view="searchForm">
             <transition on="submit" to="processFormSubmission"/>
             <transition on="cancel" to="processCancellation"/>
         </view-state>

         ...
     </flow>

(This describes the flow of a web page submitting into something).  
The problem here is that the XML is *external* and independent to the  
code that actually do something. The issue for me is that the code  
behind this is coupled to the behaviour in such a way as to make it  
inseparable. (Above you might have a web form containing 3 fields,  
the "submit" must understand about these 3 fields). So in order to  
change the flow, you will have to create code that understands the  
flow... Hence the flow is coupled, *tightly*, to the code behind the  
flow. Now the XML is not compiled or verified except in structure and  
so you cannot find problems until you actually test or deploy. In the  
past the names above would have been classes or instances and the  
compiler might pick things up as wrong. Now they have lost this  
important ability.

It looks to me as though they have now managed to invent a (bad)  
scripting language sitting above Java essentially imitating what we  
had in ASP/JSP/VB ten years ago, but far worse because XML is not a  
language but a data structure...

Back to my original point - what kind of abilities did we lose going  
from Lisp/Smalltalk into the VB's/Delphi's/C++ into Java/C# etc that  
are now being reinvented in a bad way in the new "languages"?


Rudolph