Lambda the Ultimate

One of the bibliography entries in the paper is particularly interesting:

"Simonyi, Charles: Method and System for Generating and Displaying a Computer Program. U.S. Patent No. 5790863, 1998."

What aspect of Abstract Syntax Trees or their representation could now result in a lawsuit? I'm with Knuth Knuth from "All Questions Answered":

"I’m against patents on things that any student should be expected to discover. There have been an awful lot of software patents in the U.S. for ideas that are completely trivial, and that bothers me a lot. There is an organization that has worked for many years to make patents on all the remaining trivial ideas and then make these available to everyone. The way patenting had been going was threatening to make the software industry stand still.

Oleg's recent post certainly shows that certain strains of Scheme like Bigloo are going visual in a big way comparing four different GUI libraries: Biglook, Tcl/Tk, Swing and GTK!

It's tempting to follow Simonyi's lead and make R5RS hygienic macros more palatable by rendering them, their arguments, and application results graphically as trees. The macro pattern language with all its "..." 's is a little hard to read sometimes.

make R5RS hygienic macros more palatable by rendering them, their arguments, and application results graphically as trees.

It seems certain that someone already wrote a thesis on this... But if not, reusing some of the ideas behind XSLT GUIs can be a good direction to explore.

I guess I'll have to read that paper, though I don't see how a paper with a title that long could possibly be "sober and simple".

Haven't been able to find anything along these lines yet.

It seems like everything you need to display Scheme AST's visually is there under the Stratego umbrella. Case Study 3 Visualization, displaying Abstract Syntax Trees with Graphviz-Dot shows you how to do it. (from the Stratego Documentation page) There is no Scheme grammar in the SDF grammarbase, but a Scheme grammar shouldn't be too difficult to add.

I'm currently trying to get up and running with Stratego but there doesn't seem to be any real introduction like a graded series of examples of increasing complexity. The TigerCompiler looks like the best place to begin.

> reusing some of the ideas behind XSLT GUIs can be a good direction to explore.

Could you suggest the name of one.
I'm not sure what you mean.

The Program Transformation Wiki has a page on AspectOrientedProgramming, one among many other TransformationSystems. IntentionalProgramming and DiSTiL are there too.

>>.... reusing some of the ideas behind XSLT GUIs can be a good direction to explore.

I think I see what you mean, just as the XSLT GUI allows to immediately see the results of the transformation, a Scheme macro GUI could do the same. This would also be cool for partial *application of functions*.

Having got used to partial application of functions in Haskell I tried it out in Scheme but it's hard to see what you're doing when the partial applications and compositions start getting complex because there is no type checking to verify before run time that all the types are synchronized. It's like driving in a heavy fog. Dynamically typed Perl6 with it's function currying is probably going to have the same problem.

I've heard that the reverse mapping from the efficient internal closure representation to textual code is available in one of the Schemes, I believe Gambit? I've also seen something similar in Tubes which uses textual Scheme S-Expressions to represent a persistent closures for mobile-distributed programming. (current location not known) I wonder whether the efficient closures of the ILX extension for .NET's VM can be easily decompiled into textual source.

(Note also that Sheard's Accomplishments and Research Challenges in Meta-Programming (section 5) critiques the use of strings (Perl) and s-expressions (Lisp, Scheme) for program representation in meta-programs.)

One representation technique not presented in Sheard's section 5 is using inheritance and the Iterator pattern.