[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