[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]


On Wed, Feb 19, 2003 at 09:11:42AM -0500, Kevin Kelleher wrote:
> Why not talk about Tunes -- what has kept it stalled for all these years?
Thanks a lot for the question, Kevin.
One part of the answer is my own psychological (or psychiatric) problems:
I am good at having very abstract ideas, I can do well fiddling low-level
code, but there's a gap in my proficiencies at the tactical level.
One could say that I'm applying Reisner's Rule of Conceptual Inertia:
        If you think big enough, you'll never have to do it.

But more interesting to discuss here are some of the technical challenges
in Tunes that I've pushed back trying to actually tackle, and that could
deserve whole new research projects altogether:

* Developing a rewrite engine with first class patterns and environments
 I have barely written a simple extensible pattern matcher; there is a lot
 to experiment and formalize, here.

* Developing a generic metaprogramming / language transformation framework.
 Tunes hasn't done much about it -- there is a number of other projects that
 seem promiseful, though (Stratego?)

* Devising and experimenting with some linear/region-based type system so as
 to specify effects in a way that allow to specify what happens when
 processes are being considered at multiple nested levels of abstractions,
 with meta-level objects controlling the representation of base-level objects
 (and so on). Hopefully to be used to build robust concurrent and logic
 programming subsystems out of region-linear continuations as a building block.

* Experimenting with multiaspect programming, dynamic change in program
 representation, semi-automatically reconciling diverging aspects, etc.

* Devising tools for distributed management of multiple versions of code
 from multiple sources, while automatically keeping enough traces of
 historically accepted coherent combinations so that you can keep old code
 running at any moment (and even replay the bootstrap history of the system).

* Formalizing the notion of expressive power in presence of interactions
 (I haven't seen Peter Wegner's intuitions backed with clear enough formalism)
 See my 1999 articles as hints of how one can formalize the fact that
 while metaprogramming brings nothing to closed interaction-less systems
 (where Turing machines are universal), there is a whole world of expressive
 power to formalize when there are interactions. [e.g. a logical approach
 in terms of interactive invariants expressible with the language, or a
 algorithmic complexity approach in terms of cost of developing a program
 through iterative steps of functionality] -- and how metaprogramming wins
 big in such setting (note that even in the Turing Machine setting,
 metaprogramming is precisely what allows some languages to be universal.
 Oh, and for reasonable definitions of universal, C is NOT a universal
 programming language -- and neither is ML.). Hopefully, from such a
 formalization of expressive power, we can get an idea of how to better
 structure a programming environment (mind you, when you're considering
 interactions, it's not just about programming languages anymore).

* Experimenting with orthogonal persistence of code, and
 managing storage in a mostly orthogonally persistent system.
 Also - in a reflective system, how to ensure robustness of the
 orthogonally persistent data despite possible system bugs,
 yet at the same time allow dynamic update of the code infrastructure?
 This supposes fine grained virtualization of the system,
 and separation of it into domains of fault containment.

* Semi-automating of data schema evolution by metaprogramming
 based on the history of code modifications.
 Where you don't write code, but grow a system,
 many problems and solutions appear that are unthinkable with static systems.

* Experimenting with semi-automated reversible metaprogramming: program
 transformations that can be reversed to as to allow automated migration.

Well, you get the idea.
But our initial problem is still bootstrapping the system.
At least now Brian Rice is working on it.
As for me, my problem is still bootstrapping my mind.

[ François-René ÐVB Rideau | Reflection&Cybernethics | http://fare.tunes.org ]
[  TUNES project for a Free Reflective Computing System  | http://tunes.org  ]
In a five year period we can get one superb programming language.
Only we can't control when the five year period will begin. -- Alan Perlis