Replies to replies.

[David Manifold]

On Tue, 27 Oct 1998, Thomas M. Farrelly wrote:

> So 'foo.c' will be all over a reflective system.

To anyone:  There seem to be many different kinds and extents of
reflection.  Is it possible to clarify and distinguish these? 

[snip]

What do you mean by "categorisation"?

> > > > The system will be complete when these goals are accomplished:
> > > > * a powerful, extensible, abstract specification system
> > > > * extend it to specify low-level hardware
> > > > * extend it to specify translation from itself to low-level hardware
> 
> Agreement. If "a powerful, extensible, abstract specification system" is
> so powerful, then why does it need to be extensible? What if it wasn't
> powerfull at all but just extensible. Then you could make it as
> powerfull as needed. ( it only needs an 'add_power' option :)

Good point.  But I think TUNES' power comes from scalability, which
includes extending the system as well as limiting it (removing features).
Orthogonality of all properties makes this possible.

> > To realistically do this (which I agree is our goal), we need a
> > "superlanguage" which is more expressive than every other language.  In
> > this superlanguage other languages are implemented, then automatic
> > translators are made between them.  Programmers should ideally write any
> > new code in the superlanguage itself.  Programs in the superlanguage can
> > combine concepts from any of the lower languages.  Of course, programs
> > that do that will not be fully translatable into the less expressive
> > languages.  The superlanguage itself will not require any of the other
> > languages to run.  It will include the machine hardware as one of the
> > sublanguages, and translate directly to that.
> 
> Partial agreement. This superlanguage must be the meta translator right?

The superlanguage is a universal representation of every other language.
It allows you to write translators between arbitrary languages, but does
not require them.  (Just as you can have an integer and a float without
necessarily having a conversion between them)

> > > My thinking is that more ultimate progress would be having the word
> > > processor have real intelligence mechanisms, and AI is the enabling
> > > technology for this.
> > 
> > You'd have to be more specific.  I'd be satisfied if my word processor
> > wasn't an isolated module, but was just integrated with my system.
> > 
> 
> module schmodule. If it wasn't integrated what would it be? No system is
> an island.

What I meant was: AI is unnecessary, what we need instead is OO done
right.  Instead of writing applications with functionality presented for
the user, they should be many smaller tools presenting their functionality
to users and other programs alike.  

Example, the calculator applet with most GUIs does not export an API. 
Hmm, that's because most programming languages have integer math built in. 
Wait, that means we have integer math functionality duplicated in our
system once for each language, and again for the calculator applet...
instead we want an "integer math" module with a customizable interface: It
works with users, or with any language.

When you repeat this design with file I/O, generic data structures, and
common algorithms you end up with huge savings in duplication of
functionality.  The goal is for every application [and language, and
protocol] to be designed as part of a standard library instead of as a
single-use.  And we present the entire system as the standard library and
let users access it directly.  That should be all the user interface we
need: Just allowing some way of users interacting with the stuff that's
already there.

> Anyways, this AI trend may in the best case lead to total confusion. For
> confirmation of that fact check out the com.ai.* discussions. No hard
> feelings to those who would like an AI-OS. You may find that what you
> really wanted was reflection.

...we want the computer to do what we tell it... maybe do some stuff on
its own without having to tell it...(but we still want to tell it how to
figure out what to do on its own)... call it AI if you want.  I think this
reuqires reflection (self-programming) as well as unifying programming
language with user interface (see above).  Sort of what Brian was saying
about "the computer operating at the level of the user thinking about
programming".

David Manifold <dem@pacificrim.net>