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
and
The Knowledge Calculator
Copyright 1994 By: Timothy V. Rue
timrue@mindspring.com
(see copyright notice at end of document)
---------------------------------------------------------------------
INTRODUCTION:
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:
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
Relationships
---------------------------------------------------------------
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
thought).
** Power is obtained through structure control of the primary **
** elements and their changing relationship to one another. **
---------------------------------------------------------------------
OVERVIEW:
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
level.
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.
---------------------------------------------------------------------
A NOTE ABOUT THE SYSTEM I HAD IN MIND DURING REASEARCH.
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.
---------------------------------------------------------------------
A NOTE ABOUT THE POWER OF THE ALTERNATING INTERFACE
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
name.
(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
setting.
(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
KE.
* 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
exist.
-----------------------------------------------------------------
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
position.
There are a few (default) rules on keyhole placement in an
IQ-file.
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
space.
***** 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
current.
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
variable-pattern
-----------------------------------------------------------
"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
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-keys
file-key ;; key-tooth , key-tooth , ...
file-key
definition-keys
definition-key
definition-key ;;
class
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
concepts:
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
characters.
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
considered.
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
reminders.
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
adventure."
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.
**********************************************************************
THE FOLLOWING IS FROM EARILER "QUICK NOTES" THAT WERE MADE.
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.
COMMAND OPTIONS
=======================================================================
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 filename.pk
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 filename.iq
AI -id filename or filename.id
AI -ke filename or filename.ke
AI -? AI help
AI -d / -w debug/watch toggle
AI exit exit AI configuration
Example:
AI -pkDF1:Testfile script.sf -keHolder
====================================================================
PK
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
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
SF returns PK SF line
SF -? help on SF
SF -sf returns SF line contents
SF filename@line#... returns given filename@line# contents
====================================================================
ID
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
system.
ID returns PK ID line.
ID -? help on ID
ID -id returns ID search path based on
KEychain.
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
file.
====================================================================
IQ
IQ returns PK IQ line.
IQ -? help on IQ
IQ -iq returns IQ search path based on
KEychain.
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
file.
=======================================================================
KE
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"
key-teeth/-p@name:
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)...
NEED TO PUT MORE THOUGHT INTO THIS!!!
***********************************************************************
----- 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
rules.
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
------------------------------------------------------------------------
COPYRIGHT INFORMATION:
------------------------------------------------------------------------
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.
****
Email: timrue@mindspring.com