Important System goal: incremental development

Francois-Rene Rideau
Fri, 23 Oct 1998 01:09:14 +0200

>>: Brian
>: Tril

>> Since the Tunes system's hll is 'reflective' as a primary feature, the
>> generation of arbitrary languages should be little more than trivial.
Dynamic creation and use of domain-specific languages (DSL) is indeed a major
feature allowed by reflection (see clever use of LISP/FORTH "macros").

>> Since any language is equivalent to a calculus of atoms, this allows the
>> richer type system which is desirable and should be available.
Well, the whole interest of reflection is that there be no definite "atoms";
that is, you can always compile and decompose computations
into more primitive concepts.
"atomicity" becomes a relative, not absolute, concept (still a useful one).

>> These
>> languages would probably be generated incrementally towards specific
>> application-development.  Their semantics could therefore be checked
>> incrementally long before their application to some object, and would
>> persist beyond most object's lifetimes.  That is my intended means of
>> static type-checking.
Yes. The ability to constrain is part of the expressiveness of a language.
The ability to dynamically build new constraints (e.g. type systems for
those DSL) is also a feature of reflective programming.

> The 'incremental' approach (called 'refinement' by Fare) is a vital part
Uh, incrementality is an essential aspect of programming.
Refinement is but one very important technique to achieve incrementality
while preserving correctness and focusing on the most important things first,
and considering more particular details later ("analytic" programming).
Building new objects from existing objects by combining them and
applying constructors (usual "synthetic" programming) is incremental, too.

> * Orthogonality, means you can change only what is nenneded, and no more.
> * Fine-grain means you can make very small changes
Well "finer-grained" means that you can achieve the same effect with
smaller changes in one language than in the other. Hopefully,
reflection allows for asymptotic finest grain.
Orthogonality indeed means that change in a feature don't imply change
in another feature.
Looks like orthogonality and fine-grain are more deeply related
than usually admitted.

> * Persistence means you don't have to save the changes manually
No. That's *orthogonal* persistence.
Persistence just means that you can save things :)

> * The system is abstract for natural visualization
Not sure what this means. More like a UI issue.

> * Human-readable notes and documentation can be integrated with
> objects and their source
Notes are to be considered fully part of the (dynamically extensible) source!
Or may they consistently be kept external? Looks hard to me.
However, there might be several different kinds of notes and associated
concepts of stripping the source. Imagine multi-lingual notes,
translations of each other or not, with explanations, rationales,
tutorials, examples, disclaimers, copyrights, historical notes,
jokes, todo lists, bug reports, etc, all at a fine grain...
ultimately, we'll need an AI to manage all this mess :)

> * Multidimensionality: Every object is accessible from many different
> places.
I guess you're talking about something akin to aspect-oriented programming,
like there being multiple ways to view objects?

> * Dynamic reflection lets you experiment with changes in realtime, with
> undo, so the user can easily find out exactly what to change.
In development systems. You may also extract "static" (sub)systems
when you're sure the semantics won't change, and need speed or space
for performance and/or embedded systems.

> * Distributed collaborative development is built-in, so your changes can
> be immediately available for others.
That would be cool. A Tunes 1.2 feature, I wish.

> * Check out other features for yourself.  I suspect every one of them
> contributes to the "integrated-Bazaar" in some way.

## Faré | VN: Уng-Vû Bân   | Join the TUNES project! ##
## FR: François-René Rideau |    TUNES is a Useful, Not Expedient System     ##
## Reflection&Cybernethics  | Project for a Free Reflective Computing System ##
Some people will argue that since there's no evidence either way whether
the smurf fboinks or not, it's ok to firmly believe that indeed it does.