Although I can reference alot of things, I'll only mention two here:

Scientific American, September 1994, article "Software's Chronic
Crisis" note page 92.

Comdex Spring 1995, Power Panel "What's Wrong with Software
Development".  An audio tape of this power panel can be obtained from
Conference Copy at (717) 775-0580. Tape #903A-05.

    I attended this power panel and didn't get a chance to make a
comment and ask a question or two.

    Alot of important topics were touched on but it became apparent
there was no workable solution being brought forward that would satisify
everyone. The audience reduced it's size near the end, with many
realizing this.

The Comment:
        Whether I'm a programmer or user, I think I should be able to
define the objective and let the system come up with an answer or two.
I believe the system, if it needs to, should present me with further
questions or interfaces to allow me to better define the objective. And
if need be, the system might connect to a network or direct with a
resource system, regardless of distance, to get the information it
needs, to reach the objective. The language(s) one programs in should
not be an issue but an option.

The Question:
        Is it possible that everyone is to close, to subjective, to see
the solution? Can't see the forest for the trees?

*** IMPORTANT - This document is an earlier published work and does not
    contain current information. It is posted here as a reference only.
                           BEGIN DOCUMENT

                   A Virtual Interaction Core (VIC)
                              for an
                     A.I. - Alternating Interface
   Knowledge Navigational Mapping and Exploration/Expression Tools
                      The Knowledge Calculator

                  Copyright 1994 By: Timothy V. Rue


              (see copyright notice at end of document)

         This paper present a method for mapping and navigating
knowledge. The form of knowledge representation is only limited to
the abilities of the system it is used on and devices attached and
accessed by the system, this includes robotic devices as well as yet
to be developed devices. The only other limitations are system
architecture, speed, memory, and storage but these are improving in
time with technological advancements.
         The vision of this paper is to produce a "knowledge
calculator". A system not only able to navigate current knowledge but
calculate new realms of knowledge.
         With the mass amount of knowledge today, there exist yet to
be accessed or explored areas of the currently possible, waiting for
someone to conceive, pursue, calculate, and establish. Many of todays
problems have solution but not the man/mind power to consider all the
available possibilities. And advanced but distant realms of knowledge
receives even less thought, for lack of enough established base
knowledge. Fiction is the classification given to distant
possibilities. But it is clear much of the fiction of yesterday
is now a fact of reality.
         Mans imagination is the direction of knowledge exploration
and establishment and is not limited to the base of established
knowledge. However, much of mans knowledge advancing efforts are put
into establishing small steps in the evolution of knowledge (in
comparison to all that is possible). And these small steps are
constrained by the limit of current established and accessed
knowledge. The problem:  filling in the possible knowledge maps
between point "a" (current knowledge) and point "b" (new knowledge)
at the limited speed of mans mental rate and knowledge accessing
ability and willingness. To be clear, computing power continues to be
an ever increasing aid in research and development, but missing is the
ability of computers to apply imagination in searching for solutions.

         The purpose of the knowledge calculator is to help solve this
problem and at the speed, knowledge accessability, and computation
abilities of computers.
         The "theory base" is that there exist the possible, both
known and unknowned, the real and the currently just imagined. But
knowledge is only a representation of part(s) of the possible and in a
form that can be communicated. Given enough parts, new knowledge can
be calculated, established and built upon into distant (under current
methods) advanced new knowledge.
         The "theory" is: There exist constants within the process of
mans imagination which can be identified and used to map and navigate
knowledge, both current and projected. That this process can be
applied to a computer system to allow the speed and knowledge access
abilities of a computer to greatly aid in the direction and
development of knowledge.

         Although human imagination has no limits, human communication
does. Imagination constants may be identified but communication
requires the ability to map and navigate what imagination creates.
         Some examples of knowledge mapping and navigational tools
would include language definitions (including programming languages),
the dictionary, math, physical world and fantasy world maps, technical
manuals, library references, etc.. One of my favorite examples of a
knowledge map is the Thesaurus.
         Computer programs are a form of knowledge navigation,
mapping, and communication. Consider image generation software, it is
built upon and makes use of many established knowledge maps.From
minerals to computer electronics, from the concept of "on and off" to
hardware switches and the software to flip the switch. Knowledge that
can be mapped and communicated through textual formats (as is the
format of most of mans communicated knowledge.) But the results of the
application software, an image, is not as easily communicated in
textual format. Showing how mapping and navigation can go beyond it's
own mapping format to express a non-textual format.
         Now consider an artist and his mineral based paints as he
produces a painting, and consider the differences in the processes,
results, time and accuracy in the creation of an image by the painter
and the software operator. Each brush stroke is placed with intent by
the painter. The image software user only needs to do some of the
work, perhaps not knowing what he will get. * It is well worth noting
that there are cases where artifical Intelligence/Life programs have
uncovered missing or new knowledge and at the supprise of the user.
         Leonardo da Vinci, known as a painter but was also a
sculptor, architect, musician, engineer, mathematician, and scientist.
Consider his works and the question of "what mental tools did he use
in his imagination process? And what could man have achieved had
Leonardos imagination process been applied by computers?"

         A word of caution is in order. It is inherent with such a
system capable of making use of imagination processes to be able to
produce everthing between pure fiction to pure fact as well as alot of
garbled nonsence. As a result of this, it would be easy to view the
system as producing foolishness and genius. Also possible, in a
dedicated manner, the system can perform an established set objective
over and over, not using imagination processes but just the
functionality of the system, and with certainty.

         I followed the field of artifical intellegence for many years
after I began developing what is contained in this writing. At times I
saw what appeared to be important steps in the direction of my work
only to realize the needed "connection" was not being identified. Much
the same as Graham Bell and the telephone, only it took an accident
for that "connection" to happen. But with this line of research an
accident is a great deal less likley to happen, if at all possible.
Technology has evolved, Object Oriented Programming and Neural Nets
have captured the focus and efforts of many, and I realize these are
useful and powerful tools. And I have no doubt much of the same ground
will be covered again with these new tools. There will always be new
tools, but I have to come to the conclusion that if the "connection"
was not made with earlier tools capable of doing so, little reason
exist to believe new tools will lead to the "connection." And
considering the trend of the newer system user interfaces (icon
driven) the possibility seem to grow smaller.


    Philosophy, though important, is a matter requiring more writing
than I currently have time for, so I'll leave it up to skeptics,
critics, writers and available works. But it is this time and resource
limitation that has inspired me to write this paper, so I may present
this system to others with the available time and resources to
development it into a tool of benefit to knowledge advancement.

However, I feel it's important to touch on a few things.

1) There is the possible in physical reality, within and beyond
   our current knowledge.

2) We define our reality and create tools based on what we define.
   Then we use these tools to refine and/or re-define our reality.
   Knowing our definitions and tools are not perfect but serve us to
   control physical reality better and better. This process or cycle
   is a "constant".  We discard or replace some tools for better
   tools. We can also go the other direction by replacing better
   tools with inferior tools (constrain).

3) To completely understand and control physical reality something
   changes. The "constant" is understood and applied by choice.

   The question of "how to do something?", also becomes a choice.
   The question of "what to do?" becomes the main question.

To do something:

3) What to do? Let's do this objective.  One of the questions will be
   "which direction?" Doing means movement and time.

2) We use the constant, set the motion in the direction we want, and
   apply constraints (tools) to reach the objective.

1) There is the possible in physical reality, within and beyond the
   current "constraints" of what we are doing.

    The biggest constraint man is faced with today, is the information
knowledge bottle-neck. We have more knowledge than we can properly
process. And this is causing limitations on the decisions and
direction we take with knowledge and technology. As the game of chance
grows, so does the stakes. The best, currently possible, decisions are
likley to happen less and less, unless. :-)

    The "constant" does not change, the constraints do. Identify the
constant and use it to process and change the constraints to fit the
objective (what to do).  Or another way, define the objective, XOR the
constant to expose the constraints. Objective XOR constraints =
constant. Constant XOR constraints = objective

    Within the environment of computers the smallest information
element capable of change is the bit, represented as "1" or "0" and
the control that determines the state. The ultimate control being the
state of the power switch. A switch externally controlled but also
considered "1" or "0". Between the smallest element and the most
powerful we have the space and speed of the possible, (within the
constraints of the computer environment.) From all "0" all the time
to all "1" all the time, there exist the possibilities. From
uselessness to usefulness to uselessness. Three states exist for
the smallest information element, not used, "1", and "0". Hydrogen.

The Questions:  What exactly is the constant and how can we apply
the constant within the constraints of a computer to remove the
information knowledge bottle-neck constraint?
    Answering these questions is the ultimate objective of this
paper and effort that has lead to this paper.

    The constant requires direction, movement, and "constraints that
can be changed" to obtain the objective.

                         The Possible
Primary      Constant - direction,  movement,  and constraints
Secondary     Physics - time,       energy,    and matter

Primary  Programming  - process,    decision,  and input/output
Secondary Programming - sequence,   selection, and iteration

           E=Mc - Einstein      -  E = Energy
                                    M = Matter
                                   c = Light squared

          T1=T2k - Spinoza       - T1 = nonmystical thought
                                   T2 = physical reality
                                    k = the active constant

T1(I+E)=vT2(k) - Di Silvestro  - I = degree of intent
                                   E = degree of effort
                                   v  = velocity of conversion

      E+Mc = the constant         T1+T2k = the constant

              (T1(I+E))+(vT2(k)) = the constant


    We define our understanding of reality (physics). Then we build
computers using the tools of physics. Through computers we represent
and process concepts originating from our thoughts. Using the tool
of computers to process concepts, we refine and/or re-define our
perspective of reality. We have been using the constant without
completely identifying, understanding, and controlling it.

    The Virtual Interaction Core (VIC) is an effort to identify and
use the constant within the constraints of a computer. There is the
theory and there is the application. The application does not yet
exist that I know of. But the parts do exist, or at least enough of
the parts, to know the VIC configuration is beyond theory. The
creation of the application requires some alteration and integration
of the existing parts. The depth of the described functionality may
not be quite correct but the only way to determine this is to create
the VIC and use it to find any errors or exception that cannot be
handled. It should be able to handle exceptions (those within the
inherent constraints of the system) and in finding one or more
exception failures should signal the existance of an error(s).
    I do not claim this is the best, complete, or absolute minimum
(primary) required configuration of a VIC, but it is a start and can
be used both productively and to determine what needs change. I do
believe there is an ultimate limit to the number of commands and
command options required, and that this limit is a small set as it
should be.

    Sometimes I think the VIC concept is stupid. One of two reasons -
it is basicly so simple I find it hard to believe it has not been
done (but where is it?) or it can easily become to complex (but only
by choice). Then I realize this is inherent as this is inherent with
computer technology (physics) and programming (representation of

**  Power is obtained through structure control of the primary  **
**   elements and their changing relationship to one another.   **


    The knowledge calculator consist of three levels of development:

    First, for a system to be capable of making use of the processes
of imagination it must have virtual interaction ability. And here we
begin by identifying and defining the "gears and bearings" required of
virtual interaction. The "gears and bearings" include the ability to
access, process and store knowledge in a format understandable by man.
This is the VIC level.

    Second, we develope the "cycles and lubricants", the knowledge
navigation tools that represent the processes of imagination. The
pre-requisite of doing this is to use the "gears and bearings" to
establish constants of imagination. This is the Alternating Interface

    Third is the development, access, and processing of established
knowledge bases or maps. This is where the end user makes use of the
navigation tools to automate the processing of knowledge maps to
generate the knowledge paths from point "a" to point "b". This is the
Knowledge Calculator level.

    There is also a fourth level of development but this level goes
beyond the abilities of computers. It's the human decision to act on
what is calculated. To do something with it, as is so with human
decision to flip the power switch of a computer.

    The concept is for the end user to define the knowledge objective
and let the system explore and present the possibilities and perhaps
methods of proof to establish validity, if the objective requires
verification (non-fiction).
    In short, the idea is to use the imagination process to access and
calculate new knowledge from available knowledge bases or maps. And to
automate this through the power of computers and attached devices.


    Before getting into the "gears and bearing" it may be important to
note the computer system and additional software that was in mind when
I defined the "gears and bearings". The computer is the Amiga for its
multi-tasking abilities. The additional software is the freeware shell
program "Csh" for its functionality and available source code (using
the system with Csh has been the strong consideration.) And the
commerical software "AREXX" for its use of the Amigas Multi-tasking
and Interprocess Communication abilities. The VIC is a set of shell
commands that communicate with each other through files. On the Amiga
it might be good to produce this as pure code.


    It is important to understand that the virtual interaction core,
by itself, has limited power. The objective is to make possible the
"connection" by providing the functionality to do so and the virtual
interaction core benefits from the additional functionality of other
command line shell type programs. Programs that can be automated or
controlled by external calls, such as AREXX compatable programs, only
add to the potential power of the virtual interaction core.
    Consider AREXXs ability to integrate and automate application
programs. And the ability of Csh to add functionality to the command
line interface and access AREXX. Now, add the ability to automate the
imagination process and ability to access and process established
knowledge. Imagine Automating command line, or Csh script, creation
and/or execution. Automating AREXX program creation and/or execution.
Automating compiled language code generation and/or compling.
Automating applications execution and control directly, through Csh
scripts, or through AREXX programming. All done without the need for
the end-user to know anything about programming but only the ability
to define the objective.

    And it is here where the title "Alternating Interface" is
conceived. Through integration and automation it becomes possible for
the end user to use the many different user interfaces as tools for
defining and refining the objective as well as tools for the system in
its reaching the knowledge objective.

    Doing all this (and more) should be considered a major
undertaking, because it is. However, by using a virtual interaction
core with a text based primary user interface, it becomes possible to
do this in small parts. As more parts are added, the ability of the
system grows. And with the right combination of parts and knowledge
maps, automation begins.

    NOTE: It has always been the intent to make the VIC available as
freeware so the evolution of a knowledge calculator has the greatest
possible growth rate. It should be understood that this paper and the
V.I.C./A.I./K.C. is an identification of constants in nature, both
physical and imagination, and defined in term of the constraints of
computers. Legal copyrights and patents are a product of mans
imagination and produce constraints more often to profit financially
but can at the same time greatly reduce benefits received. Legalities
can produce a mess that prevents any advancements. This would be a
great injustice to the betterment of mankind.
    Nature, both physical and that of imagination cannot be
copyrighted or patented. Knowledge bases/maps and output/results can
be copyrighted and/or patented. Know the difference, understand and
respect my intentions and reasons behind the objective of the VIC
being Freeware!
    Teamwork is very important for everyone!

    I have no doubt it has long been possible to create such a Virtual
Interaction Core and there are probably such programs, programming
languages, and systems very capable of doing such. But simplicity,
versatility, cost and end-user ease of use are factors taken into
consideration. Though I have some programming background, the line of
work I've been involved with has not allowed me to better pursue
development. After six years of having this in sight and always
knowing there will come the level of development that is much more
than one person can handle, I believe its time to let it out for
others to develope (the inspiration of this paper.)

                       LEVEL 1 DEVELOPMENT

     GEARS and BEARINGS of a Virtual Interaction Core (VIC):

    One may recognize similarities of the concepts and usage of the
parts in the "gears and bearings" with existing programs, languages
and commands. But keep in mind that it is the sum-total of the parts,
the virtual interaction ability, that is the objective.
    Many of the concepts and facets of the parts have existed for some
time, even having established standards to follow. These standards
should be considered beneficial because it is the agreeing upon
standards that makes communication possible. However, in my search for
existing programs and shell commands, I have found there is always
something missing or preventing the "connection" from happening. That
it is the integration that makes possible the "gears and bearings",
the configuration of a VIC.
    Also, keep in mind the ability to build upon the VIC, other user
interfaces. That the VIC is intended to provide the functionality for
"connection" with knowledge maps and other programs and the use of
imagination processes.

    Understanding the concept of the parts first, will make it easier
to understand the defined functionality of the parts. But first note
the following steps of a typical creation process/cycle, from
imagination to achieving the objective:

      Step   1) Imagination/conception of general picture or goal.

      Step   2) Breakdown into individual parts.

      Step   3) Fill in the details of parts, keeping the complete
                goal in mind and going to step 2 if needed.

      Step   4) Integrate parts to create the whole of Step 1.

      In addition to the basic four above:

      Step   5) Cleanup of work environment.

      Step   6) Integration into intended environment and use.

    We have already done step 1. The following is a loop of steps 2
and 3. We won't start at the beginning, how I determined what the
parts are, to save me some writting. But keep in mind, although the
parts are few it is the configuration ability that allows for virtual
interaction "connection".

The command parts are:

(AI) Alternating-Interface
  |  (PK) Place-Keeper                                     |
  |                                                        |
  |           (OI) Output-to-Input (or Obtain-Input)       |
  |                                                        |
  |                        (IP) InPut-set                  |
  |                                                        |
  |                        (OP) OutPut-set                 |
  |                                                        |
  |           (SF) Sequence-Files  (or Script-File)        |
  |                                                        |
  |                (IQ) Index-Queue                        |
  |                                                        |
  |                (ID) IDentity                           |
  |                                                        |
  |                        (KE) KEy  (or Knowledge Entry)  |

         AI - start/stop VICs and VIC to VIC control

         PK - track and alter VIC system sequence positions

         OI - get input into variable

         IP - where to get "OI" input and what to get

         OP - where to send "SF" output and what to send

         SF - edit script-file lines and/or process, and output

         IQ - select arguement word definition(s) and output

         ID - select arguement identification definition(s) and output

         KE - constrain access and use of definitions

(AI) Alternating-Interface - The concept of "AI" is to start-up a
        Virtual Interaction Core (VIC) with options of setting the
        starting contents of the core parts and to also shut a VIC
        down. AI is also used to allow one VIC to control/communicate
        with another VIC. A name can be given to a VIC to allow
        several VICs to communicate with each other by name but there
        is also a number automaticly assigned to each VIC, at startup,
        and can be used instead of a name. Or both name and number can
        be used together to distinguish between VICs using the same

(PK) Place-Keeper - The concept of the Place-Keeper is to keep track
        of the contents or positions of the core parts including
        itself. It does this through a "PK-file". PK can also directly
        alter the contents of the PK-file and change to another
        PK-file. Generally, the active PK-file is located in RAM (for
        speed). PK has alot of power over the commands below.

(OI) Output-to-Input - The concept of Output-to-Input is, for there to
        be input, there must be output from something to grab as input.
        Output-to-Input is a reminder of "Connection".
  (OI) Obtain-Input (same "OI") - Concept of Obtain-Input is to grab
        input and place it as the contents of a variable. A very
        common function but also contained is the data *CLASS* tag of
        the value as *DEFINED* by IP. Also if the amount of input is
        larger than a given amount, a file is created and the contents
        of the variable is the filename. Like PK there is an "OI-file".
        The file contains the list of variables, data *CLASS* tags and
        the values. PK cannot alter the contents of the OI-file, only
        OI can. But PK can change the OI-file used by OI. Generally,
        the active OI-file is located in RAM. OI can by-pass the IP

(IP) InPut-set - The concept of the InPut-set is to select the input
        device or program-port for OI to use and optionally *DEFINE*
        the input data *CLASS* tag. This is similar to input
        redirection control but with the ability to insert a
        processing step between the incomming input and destination
        variable. A process that can also generate a data *CLASS*
        tag. This input setting is contained in the PK-file and
        can only be altered by PK, but it can be bypassed by OI.
        Defaults to standard Keyboard as input device.

*DEFINE* - This can be considered to be a pre/post-processor, if used,
         such as a filter, data type identification, or just a user
         created *CLASS* tag.

(OP) OutPut-set - The concept of the OutPut-set is to select the
        output device or program-port for SF to use and optionally
        *DEFINE* the output data *CLASS* tag. This is similar to
        output redirection control but with the ability to insert a
        processing step between SF and the output device or
        program-port. This output setting is contained in the PK-file
        and can only be altered by PK, but it can be by-passed by SF.
        Defaults to calling device or program-port for output to, but
        can be set for standard out.

(SF) Sequence-Files - The concept of Sequence-Files is to access and
        control the typical "grab the next line of the active
        script-file", process it for VIC variables and commands, then
        pass it on to the device or program-port as set by OP when
        there is something to pass on (not completely consumed by
        SF.) Contained in the PK-file is the current stack of SF
        script-file name(s) with current line number(s) of execution
        of the script-file(s). Through PK this stack of SF-file
        name(s) and the line number(s) can be altered to change the
        up and comming sequence.

        SF is the user interface for the VIC. It can be iconified,
        sized just for SF, or full debug/watch of various elements but
        mostly watch, step, and edit of the current files used.

        SF has options to step through the processing of script-file
        lines and to limit processing. The ability to allow the user
        to directly alter the line being processed and at the
        different steps in the processing of the line. The user can
        insert lines to be processed before and/or after the current
        line and use SF in interactive mode (no SF-file being
        processed). The option to send the line(s) to a file (tee)
        with or (redirection) without sending it to the OP defined
        device or program-port. All this can be done through PK
        setting the SF-LPC (Line Processing Control) flags.

        There is a keyboard key combination (Ctrl-P) to toggle step
        and auto processing. It is also possible for a script-line
        to select the processing mode, through a PK command call.

        To properly understand the limitation of SF and PK abilities
        to alter the sequence, understand that SF only processes the
        current line for VIC variable and commands, optionally with
        user interaction, before passing it on to the device or
        program-port defined by OP. PK, in altering the SF stack only
        alters the comming sequence of files and/or their next line
        number(s) that SF processes.

        SF is where the imagination process is set in motion. Also
        where knowledge paths are mapped (tee/redirect output, with
        comments, to file).

        The SF-script file can be a pipe or port type of temporary
        file. As is generated by IQ, ID, or external program (such as
        another VIC or user interface). As well the tee/redirected to
        file output can also be such a pipe or port type of temporary
        file, or even a null device so that SF has no output.

(IQ) Index-Queue - The concept of Index-Queue is that of search and
        output. This command has similarities to other search type
        programs (Csh search, grep, etc..), having flags and pattern
        matching wildcards. Also similiar to the Csh "man" command in
        that it can output several consecutive lines from one match.
        But there are some important overall differences. It has
        sub-search abilities of two flavors. One of sub-file, and one
        of sub-definition. KE plays a part in the sub-search choices
        or direction. There is a temporary internal list of files with
        "path, name, date, and time" kept to assist in preventing
        searching through what has already been searched.

        To understand the search and sub-searches consider the IQ
        argument as a word-key to match with a word-keyhole in an
        IQ-file. The IQ-file may also contain file-keyholes and
        definition-keyholes. Again this will clear in understanding

      * The objective of the three different keyholes is to allow
        infinite search depth and constraint versatility. Minimum use
        is always best (keep it simple) but use is not limited.

        The successfull search possibilities are:
     A) File-keyhole match. (continue search in an additional file)

        A file-keyhole is found in the current IQ-file and a matching
        file-key is available, so the file is made the current IQ-file
        and the search continues in this current IQ-file.

     B) Word-key match. (output definition)

        The word-key finds a match within the current IQ-file.
        There are no file-keyholes or definition-keyholes, so the
        definition is output.

     C) Word-key + definition-keyhole match. (output definition)

        The word-key finds a match within the current IQ-file.
        There is a definition-keyhole and an available matching
        definition-key. The definition does not contain a file-keyhole,
        so the definition is output.

     D) Word-key + file-keyhole match.
        (continue search in an additional file)

        The word-key finds a match within the current IQ-file.
        There are no definition-keyholes but there is a file-keyhole
        and a matching file-key is available, so the file is made the
        current IQ-file and the search continues in the current.

     E) Word-key + definition-keyhole + file-keyhole match.
        (continue search in an additional file)

        The word-key finds a match within the current IQ-file.
        There is a definition-keyhole and an available matching
        definition-key. The definition contains a file-keyhole and a
        matching file-key is available, so the file is made the
        current IQ-file and the search continues in the current.

         Once a file has been searched then the search picks up
         where it left off on the previous file.

     F) If no match was found it is possible to have a "match any
        word" definition at the end of the first file and optionally
        based on a variable *CLASS* tag. This way a default can

        As you can see, a file-keyhole can be in the place of the
        word-keyhole and definition-keyhole (both non-keyed and keyed).
        But the word-keyhole and definition-keyhole have only one

        There are a few (default) rules on keyhole placement in an

    a)  All keyholes must be on a line by themselves with the two
        following exceptions:

     1) The file-keyhole is followed by the filename which is separated
        by a semi-colon. The semi-colon is preceeded and followed by
        at least one space.

     2) Keyholes are preceeded by one or two consective colons
        starting in the first column followed by at least one space.

    b)  The word-keyhole line starts with a single colon.

    c)  The definition-keyhole line starts with two colons.

    d)  The definition lines have no preceeding colons.

    e)  Comment lines start with three colons.

     3) *CLASS* tags (optional). For the file-keyhole the *CLASS* tag
        follows the filename with a "semi-colon preceeded and followed
        by at least one space." For word and definition keyholes the
        *CLASS* tag follows the keyhole with two consecutive
        semi-colons that are preceeded and followed by at least one

         ***** These rules can be altered by the KEy flags. ******

         Unless flagged (IQ flag) to go to a file first, output is
         to SF, a line at a time and "IQ@LINECOUNT" is added to the SF
         filename stack.

         Only one IQ/ID command per AI can be running at a time.
         But if SF finds an IQ/ID recursive call it gets PK to make
         a copy of the PK file (including the internal list of files
         searched - appended to the PK file) and proceeds with the
         recursion. Making the original the previous PK file. Upon
         completion returns to the previous PK file and picks up
         where it left off. NOTE - This action is an assumption the
         VIC makes when the IQ/ID definition writer (a user) fails
         to plan otherwise or intends to use the assumption.
                  Any call of IQ or ID from within an IQ or ID
         definition is an obvious recursion. Because IQ and ID are
         so similar in search and definition processing, and there
         are other ways for the definition writer to deal with and
         control this type of recursion, IQ and ID are considered
         the same command in regards to IQ/ID type recursion. The
         VIC assumption lets processing move forward and can be
         used creatively.

         When the internal list of files searched is temporarly
         appended to the PK file, it is read back to internal and
         removed from the PK file when the file again becomes

         With the option to send output to a file first, if no
         filename is given a temporary file (IQ##AI##.tmp) is used.
         It is up to the user or SF script to do something with it.
         This file(s) will exist until the next "zero level" IQ
         search from the given AI, so user/SF might want to rename
         it upon IQ completition.

         The output file is commented so the user can see exactly
         where the information came from and how IQ got to it.
         Comments come from copying the IQ filename line in the
         PK file as well as from the matching keyholes in the IQ
         file. Comments are not passed by SF (even if SF is
         disabled) so SF can be used as a comment filter if needed,
         but comments are passed by the SF tee to file flag.

(ID) IDentify - The concept of IDentify is similar to "IQ" but
         instead of looking for a word-pattern match it looks for
         the relationship(s) of its arguement to the VIC first.
         Then uses the relationship-word-pattern in the definition
         search (as is done in IQ). This command can be considered
         similiar to the Class/Actions of Csh but does not work on
         just files. It is also possible to cause ID to compare
         its arguement to non-VIC elements, such as external shell
         variables, system information, etc. This is done in the
         ID file (as named and changeable in the PK file).
         Because it is impossible to know or build in all possible
         relationships checking, the ID file can contain the
         program name and any arguements it needs to do such
         non-VIC comparison. This means ID can do more than a
         relationship comparison (through other programs) related
         search. This is also where the VIC variable tag-words can
         be of use.
                  Other than the above, ID performs the same
         processing sequence that IQ does. Of course, files and
         other IQ references (made in the above description of
         IQ) are ID, not IQ. And the format of comparison program
         names, program arguements, and the relationship-word-
         pattern, to use if successful, follows the following format.

         Column one contains a single colon, space, relationship-
         word-pattern followed by a space, single colon, space,
         command and arguements to use for the relationship test.
         The IQ and ID command (after determining relationship(s))
         ignore lines starting with a single colon.

(KE) KEy - The concept of KEy is best described as using keys to
         open doors to knowledge and parts usage. It allows "IQ/ID"
         knowledge constraints to be applied and has the trade off
         of search time. More constrained, faster search. Keys can
         be created, changed and removed from the current KE file
         through "KE". The current KE file can be created, changed
         or removed through "PK". Keys can have teeth and a master
         key can exist in the PK file.

         Keyholes and Keys - pattern matching

         KE flags are to allow changing the rules on keyhole usage
         within the IQ/ID files. This will allow different formated
         knowledge to be used. Also for constraining IQ/ID search
         to a standard grep type search. This needs to be worked out.

         File keyholes - When a file keyhole is encountered the
         following sequence happens:

         1) A matching file-key is looked for in the current KE
            file. If not found, skips file. If found goes to #2.

         2) The file-key teeth and master-key teeth are comparied
            with the file, that keyhole points to, keychain (a
            commented header that contains a list of all non-word
            key-teeth in the file, including the blank-key for
            definitions without a definition-key). If there is not
            a fit, skips the file. If there is a fit goes to #3.

         3) The internal IQ/ID "searched file list" is searched for
            a matching "path:filename:date/time" of the file to
            open. If not found, add the file to the top of the
            IQ/ID stack and internal list, and continues the search
            in this file. If found then goes to #4.

         4) PKs IQ/ID line/stack is searched for the filename and if
            found, moves it to the top of the stack and continues
            the search in this file on the line where it left off.
            If not found, skips the file because it has already
            been searched.

FILE FORMATS  - the use of colons  and semi-colons is intential and is
    the default but these seperators can be redefined. The intention is
    to allow file exchange between different commands.

    It should be understood that files may have protection bits set for
    read, write, delete. This way it is possible to have a library of
    different files. Of course, such files can not always be used by
    the VIC, but an unprotected copy can.

 "PK" files

AI : AI-number : AI-name

PK : PK-filename : previous/alt. PK-filename

OI : OI-filename : last/alt. OI-filename

IP : device ; DEFINE ; Beginning,End-Of-Input-Char(s) : "last/alt. set"

OP : device ; DEFINE ; Beginning,End-Of-Output-Char(s) : "last/alt. set"

SF : SF-LPC flags ; last/alt. set : SF-filename@line# ;.>running stack>

IQ : IQ flags ; last/alt. set : IQ-filename@line# ;.... >running stack>

ID : ID flags ; last/alt. set : ID-filename@line# ;.... >running stack>

KE : KE flags ; Master-teeth ; KE-filename : "last/alt. set"


All but SF have or can have a default setting/filename that is to be
used in the event one is not given or removed. IQ and ID, after a search
does not remove the first filename but removes the line number. Default
filenames and settings are built in where needed, so that on startup
(without arguements) the VIC can function. Understand that the current
PK-filename will always match the file it is.

 "OI" files
variable-pattern ; class-x tag ; value
variable-pattern ;; value

"IP and OP" are just lines in the PK file and are defined above.

"SF" files - The sequence files can be any script type files. Generally
             these files contain commands for the VIC but may contain
             lines for other programs. What is not completely process
             by the VIC is passed on to the output as determined by "OP"
             (which can be a shell the VIC is incorporated in.)

             If incorporated into a shell, it is possible to tell SF not
             to process a VIC command (say you want to use Csh "foreach"
             to call a VIC command, you'd need a way to escape or pass
             the VIC command pass SF.

"IQ" files
::: comments and headers


: word-keyhole
                 class-x looks to see if var class is related to class-n
:; class-x (or *CLASS* which looks to see if the class exist in KE file)

: filename-keyhole ; class-x ; filename

: filename-keyhole ;; filename

:; class-x ; filename

:;    - looks at class in var then if not exist in KE-file

        if var has no key but KE-file has ";;" then

:;; filename



:: definition-keyhole

::; class-x

:: filename-keyhole ; class-x ; filename

:: filename-keyhole ;; filename

::; class-x ; filename


::;; filename

 "ID" files

;;   -builtins


command ;; word-key to use

command ; class-x to use ; word-key to use

command ; class-x to use


On key-holes:

 The word-keyhole is pattern-matched with the IQ word arguement or
     variable value.

 The file-keyhole is pattern-matched with keys in the KE-file.

 The definition-keyhole is pattern-matched with keys in the KE-file.

 The class-x pattern is checked to see if it is either a
     parent/ansestor, child, or self ; with the class-x tag given
     in the OI-file, looking at the KE-file for the relationships.

 The *CLASS* keyhole checks to see if the variable class-x exist
     anywhere in the KE-file.

 "KE" files

file-key ;; key-tooth , key-tooth , ...




definition-key ;;


class ;; child-class , child-class , ...

class ; parent-class ; child-class , child-class , ...

class ; parent-class



                      Level 2  Development,
        cycles and lubricants. The Alternating Interface.

         Developing cycles and lubricants requires understanding
how the VIC commands/programs can be used.

Programming basics teaches the following primary and secondary

The Three Primary Programming Concepts -

               process, decision, and input/output

The Three Secondary Programming Concepts - these are made up from
         combining the primary in different configuration.

               sequence, selection, and iteration

These concepts relate to the general picture of the VIC,

         OI through IP for input.  SF through OP for output.

         PK for iteration

         SF for processing and sequence.

         IQ, ID, and KE for decision and selection.

but on closer inspection it's hard to say any one part plays
only one role. It depends on how one makes use of the VIC and
remember VIC means "Virtual Interaction Core".

So lets look at some of the main roles the parts can play:

AI - Start and stop AI/VICs. And allow VICs to communicate with
         others through files and AI. Timing between VICs by
         using AI to control the settings and positions of VICs.
         A hint of parrallel or networked processsing?

PK - Jump from one VIC sequence to another (PK file) within a
         single VIC. Because only one sequence can be active per
         VIC, this can act like function calls and can pass
         information between the inactive sequences through
         files. It is also possible for a VIC to pick up an
         inactive sequence started by another VIC. PK can also
         cause iteration in both SF processing and IQ/ID.

OI - Besides getting input from the user it is also useful for
         getting input from other sources, including other VICs.
         Remember "OutPut-to-InPut". Output generated from a VIC
         can be input to the same VIC or another. And because
         input is to a variable file, the file can be use by more
         than one VIC at the same time (or near enough the same
         time). Also, by swapping OI files and/or using the
         data-tag of a variable, it is possible to setup global
         and local style variables as well as external application
         specific variables. Parsing is possible by using the IP
         and OP setting of beginning and end of input/output

IP - Besides determining where OI gets input from, IP can call
         a filter, data identification program, timestamp, etc.
         Tagging the input can be from a program or user determined.
         The tag can be useful in determining, or reminding the user,
         what the input is to be used for. Also through IP the
         Begining or End-Of-Input character(s) can optionally be
         set, allowing for limited input based on char(s). And
         in using this together with the OP B/E-of-output both
         beginning and end of input can be determined.

OP - Besides redirecting output, OP can call a filter

SF - SF can be used for edit, mapping, and debugging. But being the
         VIC user interface, it can be used to do alot of things
         in the way of creating or developing imagination processes.

IQ - With the IQ files and Keys one can set up a variety of
         selection methods. Keeping in mind the ability of a match
         to be able to alter Keys, the IQ stack, and even the word
         being searched while continuing a search, it is possible to
         setup complex selection methods. Also possible is to have
         IQ files which are standard but other IQ files that are
         user created for the purpose of allowing different paths
         to the standard IQ files. Consider automated programming,
         it is possible to have a standard IQ file with code chunks
         but definition keyholes for different languages. By using
         the proper (user created) key one can select the proper
         code chunk. This can happen in a recursive manner, making
         it possible to get more specific code while prompting the
         user for any needed information.

ID -

KE -


     Communication, language translation, data conversion. Consider
     human verbal communication and the numerious languages used,
     the technical structure of languages and slang use. Add to this
     variations of use as well as accent used, creativity in poetry,
     music, jazz using words. From here consider programming
     languages, formats, etc.. With all this in mind recognize there
     is no one or few sets or rules, algorithims, or "constraints"
     that can handle all possibilities although all this falls under
     the heading of language. The reason is simple. Human Imagination
     is in use. Both in the use and time line of language development.

     However, through the use of cycles and lubricants it is possible
     to develop the individual rules, algorithims, "Constraints" to
     apply and use without all possibilities accounted for. The
     ability to allow the evolution towards all possibilities while
     making use of what currently exist. And to explore, using
     available cycles and lubricants, possibilities not yet

     Physics and chemistry are more clearly defined and as such the
     development of cycles and lubricants is, for the most part, just
     a matter of definition (rules, algorithims, "constraint")
     creation. From here exploration via imagination.

                     Level 3 The Knowledge Calculator

          Until more is developed on level two the section can only
    express general concepts.

**** the following will probably be deleted, but serve as concept

          While most users of computers today see what computers ARE
 doing for them, they fail to see what computers CAN do for them.
 They fail to understand there are possible bigger pictures and
 completely out of sight is the possible big picture.
          Few users realize computers have the "ability" to do
 whatever they are told to do (with bits), if told how. The problem
 is, nobody has told a computer how to calculate knowledge. At least
 not so users at all levels can participate. Man knows how to
 calculate knowledge, otherwise we would not be where we are today
 with knowledge and technology. But manpower has been limited more
 than it needs to be, given the technology we have today.

          When man decides to do something the first thing to do is
 draw out the general or big picture. Then man breaks the picture
 down into smaller pictures that may be broken down into even smaller
 pictures, and so on... Until all the picture peices are simple
 enough to easily produce. In producing the peices, work on some may
 begin before others are broken all the way down and some may be
 waiting for others to be complete before work can be done on them.
 Eventually all the peices are produced into the big picture. But in
 this process it becomes important to keep track of what is done,
 what is being worked on and what is waiting for others to be
 completed so they may be worked on.

          Since the building blocks we use within a computer are all
 made of the same material (bits), we know it is how well we use or
 control the bits that determines what we can build or do with them.
 And we have built up a storehouse of tools, standards, and programs
 to use and control bits. And all this has helped man to advance his
 knowledge and technology. But with all of the advancements man has
 made, he is now beginning to lose sight of what all can be done
 with computers. Not in knowing computers can do alot of things, but
 in what computers can do to integrate alot of things into a bigger
 picture and even into the big picture. And it is here where the
 knowledge calculator comes in.
          User often know what they would like to do with a computer
 but don't know how or even if it is possible. Through the use of
 the knowledge calculator, and proper knowledge bases, the knowledge
 calculator can answer them.
          On a bigger scale the knowledge calculator can apply the
 imagination process to explore possible solutions for problems.
 Having a computer doing this means mental man power will not be
 the limitation it was.


      The movie industry makes use of established knowledge,
 standards, and technology to combine reality with imagination.
 Consider how the VIC and Alternating Inferface may be applied to
 reach an objective given by the end user.

      "produce a movie script, for T.V., of an action sci-fi space

      Of course this would not be enough information but the system
 would ask for more details. The end user need not know about the
 standards of script format or other established standards. This is
 already established through the available definitions of the IQ/ID
 files. But consider all that would need to be done by the system to
 first interpret the objective to outputting the objective. Yes, this
 is a great deal of data/information/knowledge to process. But as
 more is defined and made available through the VIC/AI this becomes
 very possible.


These "quick notes" were not intended to be correct but intended to act
as a reminder to myself of my line of thinking. These notes were made
several years ago when I knew I was not going to be able to focus on the
VIC, my focus was directed to income producing work.

AI        Sets up the PK file and makes available the internal commands.

   May be used with any of the following options

     AI                           or         -n name

     AI -pk filename              or

     AI -oi filename              or         filename.oi

     AI -ip (set options)         or         -i (set options)

     AI -op (set options)         or         -o (set options)

     AI -sf filename@line#        or         filename.sf@line#

     AI -iq filename              or

     AI -id filename              or

     AI -ke filename              or

     AI -?          AI help

     AI -d / -w     debug/watch toggle

     AI exit        exit AI configuration


     AI -pkDF1:Testfile script.sf -keHolder


     PK                          returns PK pk line

     PK -?                       help on PK


     PK pk                       toggle positions 1 & 2

     PK pk(filename)             make pk file current

     PK -c pk                    cancel current pk file

     PK -c pk(filename)          replace current with


     PK oi                       toggle positions 1 & 2

     PK oi(filename)             make oi file current

     PK -c oi                    cancel current io file

     PK -c oi(filename)          replace current with


     PK ip                       toggle positions 1 & 2

     PK ip(set-options)          make ip set current

     PK -c ip                    cancel current ip set

     PK -c ip(set-options)       replace current with


     PK op                       toggle position 1 & 2

     PK op(set-options)          make op set current

     PK -c op                    cancel current op set

     PK -c op(set-options)       replace current with


     PK sf                       swaps current sf filename@line# with
                                 previous sf filename@line#

     PK sf filename@line#...     add filename@line# to top of stack

     PK -c sf                    cancels PK SF line

     PK -c sf filename@line#...  changes PK SF line to
                                 *note this can be rather destructive
                                 to script execution and OI var lists


     PK iq                       swaps current iq filename@line# with
                                 previous iq filename@line#

     PK iq filename@line#...     make IQ file current or put on top
                                 of stack

     PK -c iq                    cancels PK IQ line

     PK -c iq filename@line#...  changes PK IQ line to


     PK id                       swaps current id filename@line# with
                                 previous id filename@line#

     PK id filename@line#...     make ID file current or put on top
                                 of stack

     PK -c id                    cancels PK ID line

     PK -c id filename@line#...  changes PK ID line to


     PK ke                       toggles positions 1 & 2

     PK ke filename              make ke file current keychain

     PK -c ke                    cancel current keychain file

     PK -c ke filename           replace current keychain file with


     OI                          returns PK OI line

     OI -?                       help on OI

     OI -oi                      returns current list of vars & values

     OI variable                 gets input from user into variable
                                 value using IP set. if input is
                                 greater than 255 a file is created
                                 and input is to file and value is
                                 set to filename O#I.var where # is
                                 unique (perhaps filedate/time/AI#)

     OI -c var                   cancels variable

     OI -c var value             creates/changes var value

IP            only affects OI

     IP                          returns PK IP line

     IP -?                       help on IP

OP            only affects ID, IQ

     OP                          returns PK OP line

     OP -?                       help on OP


     SF                          returns PK SF line

     SF -?                       help on SF

     SF -sf                      returns SF line contents

     SF filename@line#...        returns given filename@line# contents

          Test word for being a var, var-contents, alias, alias
          contents, IQ word, directory, file. If file will try to
          determine type of file. executes commands based upon
          findings (wordf).
          Tests what the word is in relationship to the related AI

     ID                          returns PK ID line.

     ID -?                       help on ID

     ID -id                      returns ID search path based on

     ID -id word                 returns ID search path based on
                                 KEychain and wordf

     ID word                     Searches for wordf using KEychain
                                 access and executes line_contents
                                 commands based on KEychain teeth
                                 and OP set.

     ID -c wordf                 Cancels word/line_contents from
                                 file(s) using KEychain access.

     ID -c wordf line_contents   Creates or Changes word/line_contents
                                 using KE keychain access for search.
                                 If Creating it will add to the end of
                                 path - end of path is end if first


     IQ                          returns PK IQ line.

     IQ -?                       help on IQ

     IQ -iq                      returns IQ search path based on

     IQ -iq word                 returns IQ search path based on
                                 KEychain and word

     IQ word                     Searches for word using KEychain
                                 access and executes line_contents
                                 commands based on KEychain teeth
                                 and OP set.

     IQ -c word                  Cancels word/line_contents from
                                 file(s) using KEychain access.

     IQ -c word line_contents    Creates or Changes word/line_contents
                                 using KE keychain access for search.
                                 If Creating it will add to the end of
                                 path - end of path is end if first

               To be used by IQ and ID mainly.

     KE                          returns PK KE line.

     KE -?                       help on KE.

     KE -ke                      returns current keychain list w/values.

     KE keyname                  returns value of keyname if exist.

     KE -c keyname               cancels keyname.

     KE -c keyname key-teeth     creates or changes keyname.


File/Line Formats

OI - "variable : value : opt comment"

IP - "input type/format : input device : end of input char"

OP - "output type/format : output device : selection flags"

    selection flags:

                   -f = First match
                   -a = All matches
                   -b = Best match
                   -e = Exact match(s)
                   -l = Last match

                   -w = wait until search is complete before applying
                        found. A temp file is used to hold findings.
    IQ only?       -d = dual/two way pattern matching
    IQ only?       -s = soundex (a future application maybe)

                   -p@name = position name of match(s) contents to use.
                            These variables are related to key-teeth.
                            (may specify more than one)
                   *note: standards on -p@name use should be developed.

ID - "wordf to test : command-line to do testing : command/contents
                                                   -p@name posititions"

     If file - lines beginning with FILE>var will be tested:

     "FILE>type : command-line to do testing : command/contents
                                               -p@name positions"

     "keychain-pattern : keyname : file to check"

IQ - "word-pattern : opt command-line if match : command/contents
                                                 -p@name posititions"

     "keychain-pattern : keyname : file to check"

KE - "keyname:key-teeth/-p@name (to compare w/file-comment):level-check"

     user definable but defaults/examples are:

                            -t = text
                            -e = executable calls
                            -s = shell script code
                            -ed = education
                            -ref = referance
                            -appl = application

When the keychain is called:
                          :: key-name is looked for in current KE file
                            and if found... does level-check...
***file-comment/OP-p@name 1: key-teeth/-p@name are compared with file
                            comment and if there is a fit...
***ID/IQ LISTS            2: ID/IQ list is searched for a
                            path:filename(date) match and if not found
                            then adds filename to top of stack and list.
                            If found then...
                          3: PK's ID/IQ line is searched for filename
                            and if found moves it to top of stack and
                            picks up at line#. If not found then skips
                            filename (it's already been looked at)...


                    ----- END OF DOCUMENT -----


Names have been removed in the following message. It is posted here
because my response contains useful information.

From: TIM RUE                   Conference: 240 , I-Programming
  To: -----------               Message: 62  Reply To: 0
Subj: V.I.C. -- 1 of 10         Date: 02-08-95  Time: 22:48
> * In a message on 02/05/95, -------- -------  said to TIM RUE:
> RW> TR>     PLEASE NOTE!!!
> RW> Tim,
> RW>      A couple of suggestions.
> Also, shouldn't there be a rule somewhere about being meaningful?
> This paper of his made no sense to me whatsoever.  I can build the
> world's best artificial intelligence engine, too, but it's just in
> my imagination that it actually works.  :)
> -----,

--, focus on what you do understand. Being that this conference
is "Programming", I believe you would understand the description
of the parts and how they relate to what does exist. The V.I.C.
can be built, I'd have already done this but my programming skill
and knowledge vs: available time, simply hasn't allowed me to do
so. And although I mentioned A.I., I would not say the VIC is an
A.I. engine, though it can be used as a building block for such.
It can also be used as a building block dealing with robotic
movement or a building block for automated programming, etc... Or
any combination of building blocks, integration of robotics, A.I.
and automated programming for example.

But from a programming conference perspective, the VIC can be
built. It's the first step. If there is something not clear to
you about the defined functionallity, ask.

AWK originally was not intended to be used to the extent it now
is. That is, full length (1000's of lines of script/code for a
single AWK program). And in consideration of what has come about
with AWK, the VIC is designed/defined to allow virtual
configurability. How it may be used is up to users, but unlike
AWK the constraints are left up to the user to define. The VIC
configuration objective is to not have any inherent constraints
which would constrain usability.

I have no doubt I could show you examples of use, knowing others
will come up with uses I haven't imagined. But again the problem
is in seeing it work and this cannot be done without creating the
VIC. And the VIC can be built and as defined!

Within the world of programming where one can see in only one
direction, even though through experience with different
languages ones sight can become wider, one still has limited
sight. But from the outside looking in one can see the whole,
and with effort one can better determine the primary constants.
Fortran is a good language for number crunching but the ICON
programming language is better for non-numeric programming. The
difference is in the built in or inherent constraints of each
langauge. Each having it's up-side and it's down-side. Although
it's possible to combine compiled code from different languages
into one program, there are still constraints which require the
programmer to fully understand the languages being used. But to
have the ability to define constraints sets and change between
sets in the sequencing of a process one is given the ability to
control the constraints rather than the constraints controlling
programming. The VIC allows for one to create and change the

It is not outside the VIC ability for constraints to be defined
that allow it to compile C code or any other code. But its ability
goes beyond programming and into application. The three levels of
development, the VIC, the Alternating interface (internal as in
VIC use as well as external or user interface), and the Knowledge
Calculator that allows the user to work on a higher level with
greater ease - built upon the AI (or defined constraint sets)
which in turn is built upon (processed by) the VIC.

Lew, when I began learning about programming I found examples
that seemed to be pointless, made no sense, but as I learned more
and looking back I understood. For any experienced programmer I'm
sure the creation of the VIC would be fairly easy. For myself,
I know I could create it, perhaps I will, but I've got to find
the time to learn and do it in the multi-tasking environment of
the Amiga (because it's the system I have and I want to take
advantage of multi-tasking). I learned C on/in the environment of
single tasking MSDOS. Big difference in environment.

The C programming Language has "no functions". It is a definition
of a langauge of which C compiler makers adhear to. There is a
library of functions which have become standard and may be built-
in to the compiler. But the function are not the "C programming
language." Functions are built upon the C language definition.

The C programming language is a set of constraints. A set that is
likley never fully/completely used in any one program. A program
contains, and makes use of, a subset of the full set.

The VIC allows one to define the language(s) or constraint sets and
to change between constraint sets. And sense the user/programmer
is allowed to define the constraints and change them during
processing, the user/programmer is not constrained by unchangeable
constraints.  And it is this that may be difficult for you and
others to understand. I'm not setting any rules or constraints, I
only identify and define the mechanics that will allow you to define
the rules or constraint set(s). And I'm doing it on a command line
level, as a primary interface level, so to not only allow versatility
but anyone to make use of it (from kids to professional programmers
and researchers of non-traditional-programming fields.)

"it's just in my imagination that it actually works. :)" Your mind/
brain is a physical device that processes abstract thoughts/
imagination. A computer is a physical device that processes abstract
concepts created by mans thoughts/imagination. The difference is clear.
Both originate from man and deal with man created constraints. A
computer is detached from man and the VIC has the inherent constraints
of hardware but need not be constrained more than this. What good is
your imagination to the rest of us, if you do not communicate what your
imagination creates. To communicate successfully requires structure and
definition(s). Structure and definition(s) can be (and are) represented
with the basic computer elements, the bits. Movement/flow and change
are also relative to communication.

I hope I've shed some light here for you Lew. The bottom line remains
(at this time) to be creating the VIC. And it is defined and buildable.
  RNET 2.006: ILink: Faster-Than-Light  Atlanta GA USA  404-292-8761


Although this work is copyrighted, the intent of the copyright is to
support the concept of giving credit where credit is due and to prevent
the wrongful constraint and/or abuse/exploitation and/or distortion/
manipulation of it's content. This work may be transfer and used
following these conditions:

1) This work may be transferred only in whole and so long as NO
   consideration is received in return.

2) That proper credit is given to the Author(s) responsible for the
   creation of the work.

3) That there is no intentional distortion or manipulation of the work
   that in any way damages or harms the work or authors(s) responsible
   for the creation of the work. And that in finding any unintentional
   distortions or manipulations, correction(s) will be made A.S.A.P. and
   with reasonable effort to communicate the correction(s) to all.

4) This work shall not be included in any for-profit product and/or
   service without the written approval of the authors(s) responsible
   for it's creation. The exception to this is, of course relates to the
   world wide web, in that the work may be made available on and through
   the W.W.W. so long as the other conditions are adhered to.