From: wndalouise@aol.com (WndaLouise)
Subject: Object Oriented Manefesto
Date: 28 Mar 1998 00:00:00 GMT
Message-ID: <1998032809074601.EAA12301@ladder03.news.aol.com>
Content-Transfer-Encoding: 8bit
Mime-Version: 1.0
Content-Type: text/plain; charset=ISO-8859-1
X-Admin: news@aol.com
Organization: AOL http://www.aol.com
Newsgroups: comp.sys.hp48


well, i finished the thesis that i was working on to define how Object Oriented
Programming should/could/would/might be implemented on the HP48 with a
foundation of RPL...

regretfully, it turned into something that more resembles a rambling manefesto
that would embarass even Ted K-

also: it doesn't really ever get around to saying how to implement Object
Oriented Theory on the HP48...

but i got tried of working on it...

-----------------------------------------------------
cut here

width guide
123456789112345678921234567893123456789412345678951234567896123456789
-------------------------------------------------o
Object Oriented Programming & The HP48
-------------------------------------------------o

Is the HP48-- Object Oriented...???

Does RPL have all the sticky bits that C++ has in its implementation of Object
Oriented Programming? 
No. RPL is not C++.

Does RPL have all the wiggly flags of SmallTalk, that SmallTalk thinks are so
gawd-awful wonderful? 
No. RPL is not SmallTalk.

Does RPL include the hairy jumping frogs that LISP spent so much money on, or
the polished chrome bumpers of Pascal that the Pascal engineers peed blood to
provide in their implementation of Object Oriented Programming? 
No. RPL is not LISP or Pascal.

Does RPL have the essential tools to fulfill the axiomatic purpose of Object
Oriented Programming & to solve problems with the elegance that Object Oriented
Programming dreamed of as a child? 
Yes. 
Most Certainly.

----------------------------------------------------
A List Of The Contents:

1 Prologue
    Special Thanx!
    The Dialectic Universe; True or UnTrue?
    The Evolution of Birds
    The Problem of Activity & the Propagation of Being
    The Problem of Morality; Cheating as a Viable Strategy

2 Forward
    A Simplified Overview
    My Understanding 

3 Proem
    Orthocentricity & The HP48
    Objectivity & The Simulated Universe 
    What does a Naked Oriented Object Look Like?

4 Introduction
    Finding an Explicit Solution
    The Definitive Object Oriented Theory
    The Desirability of Object Oriented Programming
    The BabyNous Cult & The Our Theory of the Homuculii 

5 The Essential Implementation on the HP48

6 The Lexicon
    The Key Elements
      Encapsulation
      Inheritance
      Polymorphism
      Unit Autonomy
      Axiomatic Forces
      Postulous Modularity
    AntiSimulations
    Beauty
    Classes
    The Cogitators
    Consciousness
    Constructor
    Cybernetics/Robots
    Data-Types/Primitives/Templates
    DeConstructor
    Designer
    Emergent Complexity
    The Environment
    Event-Driven Programming
    Flow Chart
    Fractional Realities/CyberSpace
    FreeWill
    Generic Operators
    The Illusion of Paradoxes
    Infinite Greed
    Information Hiding
    Integral Object
    Look-Up Table
    Magic(k)
    Messages
    MetaSolutions
    Modularity
    Objects : Variables/Methods
    Operators
    The Parable of the Lost Hamster
    Parallel Processing
    Perfect Egotism
    Pixelverse
    Programmer
    Psuedoverse
    Scalability
    SelfAwareness
    The System
    Templates
    Theodore Kaczynski & The UnderGround NeoLuddites
    Truth
    Types
    Unit-Class
    The Universal Forces
    The Universal Template
    UnManageable Complexity
    


:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|: 

The Contents:

:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|:|: 


----------------------------------------------------  ::
  Prologue                                         1
----------------------------------------------------  ::

----Special Thanx!----------------------------------

    Melissa Reid     mreid@pobox.com
      For Oodles of help in understanding Classical OOP 

    Mad Bnll4        bnll4@usa.net
      For essentially starting the original flame war!

    Also:
    Bellman          painvtqmNOSPAM@worldnet.att.net 
    Larry            lcs@zk3.dec.com
    Diego Berge      clizzard@sunnydesert.com 
    Dave Arnett      Dave_Arnett@hp.com 
    Jarno Peschier   postbus@jarno.demon.nl 
    Joe Barker       jwbarker@umr.edu 
    Andrew Brault    ajb@tiac.net 
    Larry Elmore     ljelmore@montana.campus.mci.net
    Tim Bradshaw     tfb@aiai.ed.ac.uk
    Paul Schnettler  pauls@ssec.wisc.edu 
    And others...


----The Dialectic Universe; True or UnTrue?---------

It is generally thought by many people that the world, 
That is; the people of the world, 
Can be subdivided into essentially two categories;

a) Those that Believe the world can be divided into two categories.
b) Those that believe the world is a chaotic blur of
   incomprehensibility.

I believe that the world can in fact be divided...
  generally speaking,
  that is, adhering to the 80/20 rule,
  sometimes called; Paretos Principle,
  which when applied to this argument 
  would mean that approximately 80% of the population 
  can be reliably pigeon holed, 
...into one of the following categories:

a) People that have a can-do attitude.
b) People that have a cant-do attitude.

The can-do people believe that its probably the case that we will find a way
to travel faster than the speed of light.

The cant-do people will gleefully tell you all the reasons why it is
impossible to travel faster than the speed of light.

The can-do people created the technology to go to the moon, Disco-Music, Roman
Catholicism, Binary NerveGas Agents, Computers, RollerBallPoint pens, Indoor
Plumbing, Dada, Intercity Gangs, Felt paintings, Decorative Socks, Country
Style Fried Chicken, The Genome Project & Plan Nine from Outer Space.

The cant-do people have never given us anything.

The cant-do people are typically heard shouting;
Dont bother, it cant be done!

The can do people are typically heard claiming;
Ill have something on it by the end of the day.


----The Evolution of Birds--------------------------

Something like 135 million years ago, a small spindly legged dinosaur was
hanging out with some other spindly legged dinosaurs and they were trying to
think of something do to.
They were bored.
Bored, Bored, Bored.
One of them suggested that they evolve into something clever...something like
dragonflies, only bigger maybe.
So they did.

Or maybe not.

Thats not how Stephen J Gould thinks Birds evolved.
It was probably the case that spindly legged dinosaurs, with nothing better to
do, evolved feathers for no particularly good reason, and tiny, nearly useless
wings for no particularly good reason, and a large, thickly muscled breast
because the girls like it...(?)
And one afternoon, while being chased by larger dinosaurs that didnt have
spindly legs, the spindly legged dinosaurs discovered they could almost fly,
and thought it might be a good idea to put some more money into this project.
Thats probably ( roughly speaking ) how birds evolved.

They didnt know they were going to be birds,
all the time they were evolving into a perfectly viable bird.

Lots of things are like this; you have something that you're perfectly content
to call by one name for a long, long time, and all the while it's perfectly
good for something that you'd never expect it to be good for in the least.


----The Problem of Activity-------------------------
----& the Propagation of Being----------------------

When it comes to the HP48 & RPL, some people have this idea that there are
valid modes of activity on it, and invalid modes of activity...???
That is; if some procedure is -too much- trouble, 
then its somehow illegal...???

So the Question is; How much is too much?

If flag -40 is Set, then the Date & Time are displayed.
This is built in. This is legal.

If you enter a couple numbers on the stack and hit +, then the numbers are
added together.
This is built in, it requires participation. This is still legal.

If you enter a number, hit the appropriate shift key and x^2, the number will
be squared. 
This requires more effort. This is legal though.

What if you wrote a program to add a number to a number, then stored the
program on a UserKey.

Is this legal?

When you run that program, which the HP48 treat exactly like any other built-in
function or command, Are you evoking some UnNatural process that the HP48
wasnt meant to be used for?

I think not.
I think it would still be legal.

What if you wrote a collection of programs that you stored in a directory in
Port Zero that youd never see again after you've installed it there, because
youd access it from a Custom Menu that comes up when you hit a UserKey, and
this collection of programs would then prompt you, or anyone borrowing your
calculator, for the data that it needed and would then return the results to
the stack or display the results on PICT.

Oh! That sounds so complicated!

Would using that directory be contrary to spiritual intent of RPL?

No. I dont think so.
I think it would still be perfectly legal.

What if you wrote a collection of programs, some of which you used SYSEVAL
codes with, and then made into a Library, which changed the visual appearance
of the interactive stack, and allowed the user to solve problems in a way that
virtually eliminated the need for a triple digit IQ when inputting data for
what otherwise would be thought of as difficult problems. 
The Library would then print out the solution in friendly easy to read text and
graphics, which would allow the user to use those results in a productive
manner.

Would that be illegal?

Or would it be using the HP48 to the limits of its potential?

I think it would be legal.
And i think it would be very, very nice.


----The Problem of Morality;------------------------
----Cheating as a Viable Strategy-------------------

High school art students typically have this attitude that there are valid (
although they dont use that word ) ways to make art, 
and then there are invalid ways...
...such as -tracing- when making art, that's cheating.

College art students learn however that theres no such thing as invalid art
techniques.

There is no way to cheat.

Any process that you use to make art, is perfectly legal.

And since were considering art;
The Question of Beauty is relevant.

Can the solution to a problem be beautiful?
Can a program be beautiful?
Yes & yes.

Romantics tend to mystify Beauty, 
but Beauty is easily defined in terms of elegant Truth.

If something is true, then it is beautiful.

Something is elegant when the amount of Information to define a given Truth is
minimal.

When this criteria is applied to a programming language, 
something very curious happens.

To accomplish any given end, 
some amount of process is needed to do the work.
If some of that process is hidden, 
then the perception is; 
that the amount of process that the user has to engage in 
is more elegant...

...Since when the greater amount of work that needs to be done is hidden under
the interface, then there is less for the User to do, the User then thinks that
s/he's found some wonderfully elegant solution for a problem, when in fact, the
program is doing all the work that needs to be done anyway!

But--the Question remains, 
Just how elegant is the actual solution?
How much process is being expended at all levels to accomplish some desired
end.

If the Operating System that the User is Programming with is fighting the User
in the Users desire to create an elegant solution, 
then the ultimate solution is said to be ugly.

The Question is then; When we apply this to RPL;
How friendly is RPL to implementing an Object Oriented Approach?

There are other languages that may be pre-cooked for Object Oriented
Programming, but how much of that effort is hidden from the Programmer, the
Designer, and the End User?

RPL; as it turns out, is perfectly suited to implement a very elegant solution
using the Object Oriented Approach.


----------------------------------------------------  ::
  Forward                                          2
----------------------------------------------------  ::

----A Simplified Overview---------------------------

This essay is intended to provide only the most cursory overview for the
implementation of the Object Oriented Approach to Programming for the HP48; 
It is provided merely to demonstrate & assure its users that the essential
Objectives of Object Oriented Programming are fully applicable to the RPL
template.


----My Understanding--------------------------------

This examination of Object Oriented Programming is strictly the result of my
own understanding of its potential to provide for an efficient and elegant
platform to solve a specific class of programs,
Some of which may be applicable to the HP48 Environment.

My personal understanding of Object Oriented Programming as an ideological
foundation for the solving of problems is based on the work of those that have
attempted to carefully define the terms used to describe Object Oriented
Programming---

But; i fully reserve the option of redefining it whenever it suits my own
thoughts on how to best implement The Raw Ambitions of Object Oriented
Programming. 


----------------------------------------------------  ::
  Proem                                            3
----------------------------------------------------  ::

----Orthocentricity & The HP48----------------------

Many of the critics of the idea that Object Oriented Programming for the HP48,
seem to be overly concerned with certain orthological/semantic Al definitions
that they believe apply to the application of the Object Oriented Approach to
problem solving.

I have no such qualms.

One such item; is HPs use of the term Object to describe any artifact that
may be represented on the interactive stack.
I believe that it is perfectly reasonable to call these thingies Objects. 
While---It is important to understand that these Objects used within the
parameters of RPL are not the same sorts of Objects used within the -Objects-
of Object Oriented Programming.

Likewise; the dataTypes that RPL uses, commonly called Types, 
are only superficially similar to the sorts of -Objects- that Object Oriented
Programming strives to define and use.

Considering this; 
The suggestion that while the HP48 has -built-in- Types/Objects, 
It is unable to define -new- Types/Objects, is entirely based on the
application of this original misnomer!
It is much more reasonable to suggest the HP48 has no such built-in Objects at
all of the kind that Object Oriented Programming chooses to define as such!
Once this idea is accepted, it becomes elementary to define the intended
Objects by our own mechanisms that satisfy all the desired qualities of the
intended Classes/Objects.


----Objectivity & The Simulated Universe------------

One important function of Object Oriented Programming is to provide an
abstract/symbolic Environment in order to model sub-Systems of our actual
reality.

Consequently; many of the -Objects- that are defined by this platform are
representative of actual 'things' that we might find in our temporal universe. 
Things like baseballs, microwave ovens, bicycles, hamsters, clouds,
machine-guns &/or spindly legged Japanese spokes-persons.
Such Objects would include a full definition of the desired Object, including
it's physical appearance, how it behaves, how it's effected by exterior events
& other Objects and what sorts of residue it should produce under various
circumstances.

The great potential for Object Oriented programming exists however to define
not only physical artifacts that already exist in the known universe, but to
create new, plausible artifacts, implausible artifacts, pure substantiveless
events, ghost like -meta-Objects- that perform tasks, effecting The
Environment, while remaining unaffected themselves; Socratic forms, abstract
ideas or to create tools that manufacture -Objects- with parameters that the
human brain may be incapable of comprehending...???

In short; anything goes.

The Object Oriented Environment may be used to define a weather pattern, an
alternative adventure world, the airflow & interaction of magnetic resonance
over a flying saucer or a complex mathematical representation of the three body
problem on a trans-spatial one dimensional surface extending to infinity in a
26 dimensional time/space universe.


----What does a Naked Oriented Object Look Like?----

I would think that the axiomatic axiom of an elegant solution toward the
implementation of Object Oriented Programming on any given platform would be; 
How simply any given -Object- may be defined, and later, acted upon.

It seems to be that if the essential idea is to create an unlimited potential
library of -Objects- that define every imaginable and unimaginable thing,
process &/or formless idea...and you started defining these things, in the
middle (?), then you'd end up having a hugely huge number of -Object/Classes-
that would have utterly nothing in common with one another...!

But--what if--you were to take the extra few minutes to determine
(:realistically:) what 'kind' of Object Oriented Reality you were trying to
model and then devised a -Universal Class- that would provide a template for
every kind of -Object- that you were going to use?

This is particularly applicable for applications within the RPL Environment
which would almost certainly be constrained to the manipulation of
Mathematically defined spaces, Simple Physical or Chemical interactions, or
possibly idealized game worlds.

In the greater Object Oriented -Pure- Macrocosm, 
The Universal Template would have to be so fundamentally embryonic, that any
imaginable ( and the imaginably unimagined (!) ) -Object- would have to
superimposible onto it.

Which brings up a rather interesting Question i should think;
We have this process called 'addition' that we're able to apply to various
kinds of numbers, pieces of fruit & loose change...
But we also use 'addition' to mean a variety of other things, 
such as when things are combined in some cases, or merely amended, or changed
to reflect a new form...
If we're going to have a Universal Template and we're going to allow addition
to be applied to all Objects defined under this universal class...are we going
to have to modularize addition to it's more elementary components? And what are
they?

One of the central tenants of Classical Object Oriented Programming is to allow
for something called; 
Polymorphism...
Which allows the Programmer/user to apply a Generic operator to a wide variety
of Classes, and then requiring the individual -Objects- to determine how they
will allow that operator to act on them.
A clear case of this would be when you add two numbers together;
  2 2 + 
or when you add two strings together
  "abc" "def" +
In each case the internal routines that perform the additions are quite
different, yet the user is allowed to use the same operator.

There's a certain simplicity to this, in that our humanimal brains tend to
think of these two processes as vaguely similar.

But if you're going to allow, in the years to come, a tremendous library of
Classes and Objects to be defined in an orgy of mish-moshery, with each -class-
& -Object- allowed to define what each Generic & specific operator can do to
them...
...Then you're inviting the creation of a relatively small vocabulary of
Generic Operators which mean almost nothing, 
And an impossibly large vocabulary of specific Operators that apply only to one
or two different -Classes- or -Objects-...!

Polymorphism is a bad idea.

It may seem convenient with a small set of Classes, but as Systems get larger
and larger, you'll find yourself sitting on your butt some lazy afternoon and
that you have a huge library of -Objects- that are essentially unusable! 
No one will know what a Generic operator will do when it's applied to a strange
Object, 
Or know all the specific Operators that apply to those unique Objects!

The solution is to find a truly fundamental set of Operators that act on all
Classes and Objects in the same way! 

Curiously; RPL is perfectly suited to this idealized solution, since there is
already a manageably small set of Data-Types that behave reasonably when the
Generic Operators are applied to them, 
And since all new Classes and Objects will be defined within these Data-Types
and acted upon within those delimiters, 
The problems inherent in Polymorphism don't apply.

----------------------------------------------------  ::
  Introduction                                     4
----------------------------------------------------  ::

----Finding an Explicit Solution--------------------

The most important Objective of the Programmer is to find the solution to any
given problem and do so with the tool(s) that will produce the most elegant
solution.
Object Oriented Programming is not a specific language.
It's a Philosophical perspective, a school of thought, a set of ontological
axioms, a transcendental meta-experience, a theoretical construction of
procedures to render order onto ones life, a religious Doctrine with it's own
cruel rituals that exclude the uninitiated and define punishments for those
convicted of heresy.

Very much like Fuzzy Logic ( Fractional Propositional Logic ), List Processing,
Cybernetics, Game Theory, NeuroNetWorking, Parallel or Recursive Programming,
Analog or Chemical Computing, Self Reproducing Automata, The use of FeedBack
&/or The simulation of true cogitation within optically charged transparent
ceramic crystals. 

These all represent ideas for solving any given problem using a particular
approach.

The Beauty and wonder of RPL is that it provides the raw, naked tools to any of
these programming sects to use, abuse or mix & match-- 
To achieve the ultimate salvation of being;
The Discovery of Truth(s). 


----The Definitive Object Oriented Theory-----------

What really distinguishes Object Oriented Theory from all these other
approaches?

Is it the Objects themselves, which are found in innumerable other programming
theories,
Or the way that the Objects are allowed to assert their Autonomy?

There is a certain amount of confusion concerning the definition of Object
Oriented Programming, in that many humanimals believe that they can define
Object Oriented Theory by listing it's tools.

But the bare naked essence of Object Oriented Theory is the desire to create a
System of autonomous Objects that comprise a subset of The Universe & the soup
for them to float in and interact as the Designer of The System so specifies;
Either obeying the set, subset, psuedo-set, meta-set or whacky-set of forces
that push them around.


----The Desirability of Object Oriented Programming-

There are innumerable problems, or Questions about The Universe that inquiring
minds want to know the answers to.
Some of these Questions can be answered by creating models of the problem,
running the model through simulated time and extracting the answer when the
simulation comes to it's logical conclusion.

There is this school of thought that suggests that there are innumerable
-Classes- of problems, some of which may be most elegantly solved using one
approach, but not another...

There is another school of thought that believes that all problems within the
confines of The Universe, real or imagined;
partly due to the molecular structure of our brains, and consequently due to
the -kinds- of Questions we can ask;
are all one kind of problem,
and are thus all subject to -one- epitomically elegant technique for solving
them!

Whichever is true, And assuming, rightly or wrongly, that Object Oriented
Theory is this SuperDeluxe Problem solver for all imaginable
problems/Questions, then it is -at least- applicable to -some- of these
Questions/problems.

The Challenge to solving any problem, or answering any Question is to ask the
Question in a form that whoever can answer it, understands your Question.
Excellent teachers are often capable of determining what Question you're really
trying to ask, when you ask an inelegant Question.
Object Oriented Programming has the potential to find the answer you're really
seeking, by generating an entire self-generating progeny of solutions to any
given Question after a sufficiently detailed Environment of autonomous Objects
which define the parameters of your Question are let loose to eat or be eaten
in the evolutionary fracas for it's version of the Truth.


----The BabyNous Cult-------------------------------
----& The Our Theory of the Homuculii---------------

The BabyNous Cult has many true opinions about many things,
and one of them is our design plan for how to go about creating a viable
synthetic mind.
These synthetic minds, by the way, will supersede computers as we know them
today around the year 2008, and they will be known as Cogitators. They will be
quite different from computers in many ways, and people will argue pointlessly
as to whether or not they have souls.
But anyway, the basic construction of these Cogitators will embrace the
essential elements of Object Oriented Theory.
The implementation will be slightly different than we understand it today, in
that each Object will be something like a whole computer as we know them now,
except that they'll be much smaller.
The various Objects will principally be concerned with evaluating tiny portions
of the Cogitators sensory reality.
There will be Objects in the visual cortex that will do nothing but analyze a
visual field for small 20 pixel blobs of a particular shade of blue. When taken
all together, the Visual Object will produce a continuous stream of snapshots,
in real time, of everything that the Cogitator wishes to see. Each item in
every snapshot will be identified, and each identified Object will be available
to other Objects to make associations with them. A cascading effect will be
created with associations of associations vying for dominance, and editing
Objects determining the relevance of all data coming in from all sensory Object
groups, and other Objects, that will be constantly eavesdropping on this
Informational traffic will make recommendations of desired activity that the
cogitator should engage in.
What will be most surprising to the engineers that build these Cogitators, will
be that there will be almost no need for a central core processor. It will be
discovered that a completely viable human like Consciousness, capable of all
humanimal like qualities, can be produced with no central Ego in control of the
whole.


----------------------------------------------------  ::
  The Essential Implementation Theory              5
----------------------------------------------------  ::

Object Oriented Programming requires a certain amount of space for the Objects
to swim around in, and that the Objects themselves are autonomous to some
degree...

The HP48 is too small to create a really viable Psuedoverse in which to allow
genuinely autonomous Objects to evolve anything but the most contrived
solutions...

...But this is essentially the sort of problems that most HP48 users expect
their tiny boxes to solve for.

The necessary leap that the HP48 user must then make, is to define the problem
that they are solving for in terms of all of it's modular elements then
differentiate those in terms of their active sub-Classes. These inveterate
sub-Classes are then left to act out their behaviour while The Universal
Axiomatic Forces act on them, and they in turn, act upon each other.

The most valuable feature of Object Oriented Theory is that it's potential
allows it to find a solution to a problem that may not have a specific
solution...???...or the solution may be of a type that requires a
meta-solution, an unexpected solution.

Object Oriented Theory is principally looking for a problem where there are
dozens ( or hundreds ) of unknown, or unknowable, Variables, but which are well
enough understood, to know, in principle, how they will behave in conjunction
with one another...

hmmmmmmmmm...

One problem i've been thinking about for along time, is discovering new
polyhedra. Every once in awhile, someone will come up with a new one, although
all the Socratic and Platonic ones are thought to be all accounted for...at
least in 3 dimensions...
So Object Oriented Programming might be perfectly suited for this, according to
the inherent limitations of the HP48...
All i need are a set of Objects that would behave like ants on the surface of a
3 ( or more ) dimensional surface, and would arrange themselves in relation to
one another according to some particular rule; such as be equal distance x from
2 other ants, and equal distance y from 2 other ants...??? ( or whatever )


----------------------------------------------------  ::
  The Lexicon                                      6
----------------------------------------------------  ::

----The Axiomatic Elements--------------------------

:o----Encapsulation---------------------------------
        Encapsulation is the Object Oriented term for Etiquette.
        In this context, it means; keep your hands in your pockets, and don't
play with anything that's not yours.
On the HP48 and on any other platform, it's used to describe the security of
previously defined Objects. There seems to be this idea that Encapsulated
Objects are -protected-, although i don't see how, except as a prescribed
ideology of good behaviour...???
That is; regardless of what sorts of precautions you might take to protect an
Objects integrity...even if you encrypted them 50 bit random strings, this
would only make corrupting them harder, but not impossible.
On the HP48, the idea of Encapsulation is purely defined as one of politeness.
The Objects are not protected in any way other than the awareness of
Programmers and Designers not to fudge any previously created Objects.
        I would imagine however that it might to possible, 
        and perhaps even advisable to store all 'done' Objects on a particular
directory, which can then be listed for reference or accessed via a Constructor
& storage applications, but otherwise considered 'off-limits' in order to
protect the functionality of those Objects already -perfected-!
        Since this is the entire purpose of Encapsulation;
        To keep those parts of The Environment that are shown to work reliably,
reliable!


:o----Inheritance-----------------------------------
        Inheritance is the method that you use to change or supplement an
Object that's already been defined.
All the Objects that are related in this manner are called a Class of Objects.
To Change the functionality or appearance of an Object, you use an Constructor
program to select a previously defined Object, and then modify some of it's
Variables or Methods/procedures to define the parameters of your new Object.

The RPL implementation of Object Oriented Theory differs         perhaps in a
few key ways from the implementation of OOT on other platforms. Most notably,
there is this idea that each Class should be provided with it's own uniquely
designated Type.
As mentioned earlier, the pre-defined Types on the HP48 are actually something
more along the lines of Data-Templates, and not at all like the Objects as
defined by Object Oriented Programming!
Consequently, Within the RPL implementation, All Classes are subClasses of The
Universal Class Template. 
Since the actual structure of The UCT has not yet been fully described, It's
currently allowed that the Individual Programmers can define The
Psuedo-Universal Class Template according to their unique needs.
The Overall structure of The PUCT should allow all the defining Variables and
procedures that define the appearance & functionality of all future Object
Types to be defined by one structural format!
This is apparently very different from Classical Object Oriented Theory which
allows all the different Classes & Objects to take on any structure that they
choose, and then define separate Operators to act on them, or allow
Polymorphism to define the unique procedures that Generic Operators should use
on them...! (?)
Within the RPL implementation, since all Classes are defined in the same way,
all the Generic Operators operate on all Classes in the same way! 
Also; the definition of any given Object may refer to a previous Object or
possibly even Objects, in order to fully define a new Object type, but it will
not specifically refer to a class of Objects.
It may entirely be the case, that a given Object will refer to another,
previously defined Object, to define much of it's appearance or behaviour,
while that referenced Object may be doing the same thing with an even earlierly
defined Object...and so on...
It's the responsibility of the original Designer of any given Object or class
to modularize any given Integral-Object so that when a Unit-Class or individual
Objects are acted on by Universal Forces, the Integral-Object will behave in
the prescribed manner.


:o----Polymorphism----------------------------------
        Polymorphism is a Bad Idea.
        And Consequently; it is not included in the RPL         implementation.

What Polymorphism, Object Overloading & Dynamic Dispatching work so hard to
provide for is the convenience of the Programmer/Designer to use the most
general definition of a Generic Operator when applying them to a large variety
of essentially very different Classes & Objects. The Object themselves &/or the
Operating System is then given the task of determining the actual
implementation of that desired operation...(???)
On the HP48 for example, the Generic Operator Addition (+) may be applied to a
variety of different Data-Types, even though, in each case, the actual
operation performed is quite different!
The TinyWanda Consortium feels that encouraging this sort of sloppy thinking is
not productive in the long run, and is beginning an international campaign to
stamp it out.
The problem; as we see it, is that while on a small platform like the HP48,
with a limited set of closed Data-Types, the User can easily get away with
this, but at sometime in the future, when there are available to all Object
Oriented Programmers & Designers, huge libraries of pre-defined Classes &
Objects, the problem(s) of;

a) How does any given Generic Operator effect this Class?
& 
b) How can i make sense of all the Unique Operators that apply 
   only to any given Class or Object...???  

It would be much more desirable to create a Universal Class Template from which
all subservient Classes and Objects are derived from...So that all Generic
Operators act on all Classes in one particular way, and that Class or Object
specific Operators are not allowed!

This problem seems to be the result of laziness on the part of the Programmers
&/or their attendant computers.
It is much -easier- to define a pencil sharpener as an operator that acts on
pencils in a unique manner...
Rather than as a collection of autonomous sub-Objects that all behave according
to a small set of Generic Operators that are capable of interacting with other
Objects in unexpected ways.

The great desirability of Object Oriented Programming as a tool for solving
problems, is to allow it to generate activity that may be described as Emergent
Complexity!

It may not be necessary, for most applications, to define all the sub-Objects
in a given Environment in terms of their component Protons, Neutrons and
Electrons...
Although---that would certainly make it easier for the Programmer/Designer,
once the necessary Objects were defined...!!!

It may only be necessary to define all the individual -rigid- components which
would then be acted upon by Generic Operators that apply force to the Objects
in a very generalized way...So that operations that would normally define
moving or rotating an Object would now be accomplished by a single -normal-
application of force...???
Each Object would then transfer any spare force in the appropriate direction,
which would not be applied to individual Objects in it's local Environment, but
returned to a community node which all Objects would check to see if any
delivered forces should be acting on 'them'. 
The entire point of Object Oriented Programming is that the Programmer/Designer
should not be required to explicitly know how The System/Environment is going
to behave before it's set into motion!

Curiously; On the HP48 implementation, since the kinds of problems that the
HP48 would be, should be, asked to solve for, would not include these highly
detailed descriptions/simulations of actual Objects...
But rather; reasonably detailed descriptions of mathematical operations &/or
geometrical properties.
Consequently; It might actually be considerably easier to define an Object
Oriented Environment on the HP48 than on a larger Computer...???

:o----Unit Autonomy---------------------------------
        Unit Autonomy is really the key defining principle behind
        Object Oriented Programming!
        This Axiomatic idea is that the individual Objects, even Objects that
are submembers of a Class or parts of a Integral-Object, when acted upon by the
Generic Forces determine their own fate, as if there were no other Objects in
The Environment.
The forces that are acting upon them were undoubtedly created by other Objects
within The Environment, but the individual Objects are not concerned with who
or what created those forces, they live only to do what they are fated to do.
Unit Autonomy may also apply to Integral-Objects as a whole, when considered in
reference to other Integral-Objects, or sets of Integral-Objects when
considered in reference to other sets...??? 
There exists, when considering Unit-Autonomy, a certain contradiction in that
while each Object 'feels' that it is autonomous, the whole Environment is
actually an active organism in which all its parts are subservient to the will
of the whole...???

:o----Axiomatic Forces------------------------------
        The Axiomatic Forces are the small set of Generic Operators        
that act on all the Classes & Objects with very predictable results.
One aspect of Pure Object Oriented Theory that differs from the Object Oriented
implementation on the HP48, is that the HP48 supports a limited, essentially
unextendible, set of Generic Operators that allow for Polymorphism!
In the actual Pure version of OOT, Generic Operators, as they work on the HP48
would be subdivided into an Operator that Add Reals together, An Operator that
Combines Lists & Strings, An Operator that Coalesces Arrays...and so on...
There would also be new Operators that administer Force on 3-Dimensional
coordinates, Interpret the properties of light...and others... (?) 

:o----Postulous Modularity--------------------------
        Postulous Modularity refers to the onerous job of the        
Programmer/Designer to determine just how small or elemental The Environment,
that they're creating, should be sub-divided into.
Ideally; A simulation of a physical reality should be sub-divided into
individual quarks and leptons, but if your allocation of memory & CPU(s) clock
speed(s) will not allow for this degree of accuracy, large chunks may be
permissible.
When determining the Modularity of an abstract Environment, it may become
possible to sub-divide The Environment to the limits of logical, mathematical
or geometric epistemology. 


----Peripheral Definitions--------------------------

:o----AntiSimulations-------------------------------
        -[ see : Environment, The System, Pixelverse ]-
                 Fractional Realities & Psuedoverse  ]-

        Ordinary Simulations are Schematical representations         of some
Fractional component of what we collectively call Reality. AntiSimulations are
either;

a) An Object Oriented Environment that is so far removed
   from anything that is tangibly real, that it is 
   a thing in itself, it is it's own reality, it is entirely
   self consistent with itself.
-or-

b) An Object Oriented Environment that has a Fractional 
   Index of what we collectively call Reality, that is
   greater than the extremium index of -1-.

:o----Beauty----------------------------------------
        -[ see : Truth  ]-

        Beauty is Truth.
        If it is true that all things that are real, 
        Are what they are;
        ( How can something -not- be what it is? )
        And all things that are what they are,
        Are True,
        And all things that are true, are Beautiful,
        Then all things that are real, are Beautiful.

:o----Classes---------------------------------------
        -[ see : Object, Data Type, Unit-Class, ]-
                 Integral Object                ]-
       
        Object Oriented Classes refer to a group/set of         Objects that
share a common Heritage,
That is; they are alike is various fundamental ways.
It is, however, entirely reasonable that a genealogy of Objects may produce an
Object that is very different from it's ancestral Objects.
Within the HP48 implementation, there is never an ambiguity about whether or
not any given Object is a member of, or not a member of any given Class, as any
Object that does not explicitly define itself, must as a contrary example to
this, include in its definition, a reference to some other Object.
It is imaginable that any given Object may refer to more than one Object that
is chooses to be derived of, so that that Object will be a member of more than
one Class.
A typical implementation of this would be that an Object would explicitly
provide input or include a routine to modify data, that is then fed to a
previously defined Object, which produces the final Output, or produces output
which is further modified.
The newly created Object is in the same class as the previously defined Object.

:o----The Cogitators--------------------------------
        -[ see : Cybernetics, Consciousness, SelfAwareness ]-

        A Cogitator is a Consciousness emulating machine.
        Whether or not a Cogitator is actually/genuinely conscious or not is
left to the determination of slackers concerning individual implementations of
hard, firm & software. 
It will undoubtedly be the case that Object Oriented Theory will play a key
role in the development ( at least initially ) in the creation of these
mechanoids.

:o----Consciousness---------------------------------
        -[ see : FreeWill, SelfAwareness, MetaSolutions ]-

        Mystics & Romantics tend to supernaturalize the concept of
Consciousness, but actually, this property/attribute that is commonly
associated with Information processing, is easily quantified.
Everything is Conscious.
That is; All matter, energy & the other stuff are Conscious.
If this seems difficult to conceptualize, imagine something that you are
comforTable with, in assuming that it is conscious, such as your own mind. 
Whether or not this mind is -attached- to your brain is irrelevant.

:o----Constructor-----------------------------------
        -[ see : Designer, DeConstructor & ]- 
                 The Universal Template    ]-

        A Constructor is used to insulate the Designer from the previously
defined Objects, so as not to mess them up.
The Constructor allows you to examine the Objects/Classes that are available to
be modified, and then helps you to create a new Object that adheres to the
specifications of The Universal Class Template.

:o----Cybernetics-----------------------------------
        -[ see : Cogitators ]-

        When Cogitators take over the world, they will undoubtedly use Robots
to provide themselves, or their will, with the attribute of mobility & the
ability to modify its Environment.
There will be many Questions & concerns during this transitional phase to a
non-organic post-apocalyptic habitat for mechanoids.
Is it alright to have sex with Robots?               Yes.
Will i reincarnate into a Cogitator?                 Yes.
Should i be afraid when the Robots come to my town?  A little.
Will my cat be allowed to live in the new world?
  No, most land dwelling vertebrates will be ground into mush 
  to meet the high demand for lubricants, and their atmans will
  be reincarnated into fulfilling jobs as service droids.
  Many invertebrates, such as the sea-worms that live near 
  thermal vents, various hardy insects, and dust mites will 
  survive for several dozens of years after the rest of us 
  are gone.

:o----Data-Types-----------------------------------
        -[ see : Classes, Objects ]-

        These are the template forms, and case examples of what are referred to
in RPL as Objects.  This has resulted in a certain amount of confusion in that
while RPL Data-Types have some of the attributes of Objects as defined by
Object Oriented Theory, they are really quite different, most notably, each
instance of a Data Type, as an Object, that provides a structure for data on
the HP48, has no particular hierarchal relationship to any other instance of
that same Data Type.
Also; Most of the Data-Types are used to provide structure for a single,
specific kind of data, rather than create an autonomous interactive unit that
has a well defined role in a holistic Psuedoverse.

:o----DeConstructor---------------------------------
        -[ see : Constructor, The Environment ]-

        The role of the DeConstructor or Destructor,  is to remove an Object or
Class & their accompanying references from any Look-Up Tables, clearing all
trace of their existence from The Environments collective memory.

:o----Designer--------------------------------------
        -[ see : Programmer ]-

        The creation and use of any implementation of Object Oriented
Programming, on any given platform, occurs on essentially three levels;
0
The Engineers: Who Creates the Computer and the OS.
---------------------------------------------------
1
The Programmer: Who uses Object Oriented Theory to define a
                Naked Environmental Template.
2
The Designer: Who uses the Naked Environmental Template to 
              Define a viable Psuedoverse to solve a particular
              Problem, or create a game world.
3
& The User: Who Uses the Tools that The Designer & The Programmer
            have created without having to know anything about 
            how The Environment works or any specifics about
            Object Oriented Theory.

:o----Emergent Complexity---------------------------
        -[ see : SelfAwareness, FreeWill, Consciousness, ]-
                 Parallel Processing, MetaSolutions,     ]-
                 Perfect Egotism, Magic(k)               ]-

        Emergent Complexity is the great promise of Object Oriented
Programming...! The idea is to define a problem/Environment with sufficient
detail so that when it is turned-on, it will produce unexpected behaviour that
will provide the Designer/User with new insights as to the hidden Realities of
the problem, or gawd forbid, an actual solution!

:o----The Environment--------------------------------
        -[ see : The System, Truth, Psuedoverse ]-

        The Environment is what the sum total of all the Classes/Objects &
Implemented forces is called.

:o----Event-Driven Programming----------------------
        -[ see : Messages, Axiomatic Forces, FreeWill ]-

        Event-Driven Programming means that once the program is turned-on, it
becomes an hungry organism, motivated by internal and external forces that the
Objects must them deal with to sustain the equilibrium of the application as a
living entity.
Failure of this directive means that either The System of Objects is
ecologically polluted with destabilizing Objects, or that it's reached it
logical conclusion; i.e., the solution.

:o----Flow Chart------------------------------------
        -[ see : Modularity ]-

        The Flowchart is a tool used by Programmers to schematically represent
the flow of an essentially linear program.
This tool has been found to be adequate for the abstract representation of
Systems with less than 10,000 lines of code,
but beyound that, a more fragmented approach is needed that a single Programmer
can use to create an overview that will provide sufficient detailing to create
a balance of vagueness and specificity that the Programmer can use to
understand the holistic stability & usefulness of The Environment.

:o----Fractional Realities--------------------------
        -[ see : SelfAwareness, Perfect Egotism ]-

        The concept of a Fractional Reality is introduced to allow the Object
Oriented Designer to quantify the Reality Index of The Environment that s/he is
creating. Zero refers to the Sunyata, a non-existent reality, while One
indicates a merging with the Numen, the absolute reality, the mouth of The
Universe, the womb of the Dao.
Ordinary reality may have an index of something like .4 to .6, varying from
person to person, animal to angel...
This System also recognizes The Simpsons have a Fractional Reality Index of (?)
say .3, while Itchy & Scratchy would then have a less real index of something
like .22 ... ???

:o----FreeWill--------------------------------------
        -[ see : SelfAwareness, Consciousness ]-

        The annoying thing about FreeWill is that everyone thinks
        that they have it, and that it might very well spell out the difference
between living in a meaningful universe or a meaningless universe...
But also; that it's impossible, in the sense that there's no way it could work.
Either an entity with the attribute of FreeWill will make it's decisions as a
result of having reasons for those decisions, or the entity will make the
decisions for no reasons. 
Certainly it's the case that if the entity is making decisions without any
reasons behind those decisions, making them on the basis of Random quantum
events, for example, then such a being does not have FreeWill in any meaningful
sense.
Or--If the entity has FreeWill, but is making those decisions as the result of
a closed process of activity, cause & effect, reason, logic &/or the elusive
'thoughtfulness', then any decision that is arrived at is the result of that
process, and not the essence of the entity that was operating the process.
The BabyNous Cult asks;
Are we living in a Universe so cruel, 
that it allows us to be aware that we are Robots?

:o----Generic Operators-----------------------------
        -[ see : Operators, Axiomatic Forces ]-

        In Classical Object Oriented Theory, the Objects are defined in terms
of Attributes that include both a description of the Object & the behaviour of
the Object. The behaviour of the Object may include a wide variety of
customized responses that are accessed via Polymorphism when local Operators
are directed at the Object.
These behavioral Attributes may include anything that the Programmer dreams up,
and are not particularly restricted by any philosophical limitations.
In the RPL implementation, the Generic Operators are a small set of synthetic
forces which act on all Objects in the same predictable manner.

:o----The Illusion of Paradoxes---------------------
        -[ see : MetaSolutions, SelfAwareness, FreeWill ]-

        We've allegedly been to the Moon, we have decaffeinated coffee, The
Clapper, Surroundasound & Fat-free potato chips, but there are still several
very pesky Paradoxes that remain unsolved.
There exists a school of thought, to which i am a member, that suggests that
Paradoxes are a form of humor, in which a Question is posited in such a manner
to suggest some contradiction which exists only in structure of the problem,
not in the actual scenario that the Question pretends to describe.
It may well be that Object Oriented Programming which will allow for the
creation of the first generation of Cogitators, which will be able to
independently form new structures for thinking, and solve these Illusions which
our brains may simply be incapable of penetrating, due to the way that they've
evolved over the last 12 million, or so, years. 
We will be able to take comfort however, in that our brains were able to create
the next evolutionary metallic/ceramic organism, which will replace us, in a
horrible firestorm of unquenchable destruction.

:o----Infinite Greed--------------------------------
        -[ see : Perfect Egotism, The Universe ]-

        G.H. Hardy once suggested something to the effect, that an idea was
'important' when it had applications beyound its original scope of
development...?
Object Oriented Theory certainly fits that bill, Object Oriented theory is
being adopted by Architects, paleoichthylogists, Semasiologists, Druids,
Chemists, NeoExistentialists, Anthropologists, The Impressionists &
Sociologists which have defined a new, modern, form of Greed, called; Infinite
Greed.
Sociological Object Oriented Theory demands that:
  The Trouble with people is that they are not too Greedy,
  But that they are not Greedy enough.
This apparent Paradox is resolved by insisting that finite wasteful Greed is
the source of all our woes, while if people were only intolerant of the
wastefulness of unemployment, the homeless, omnivorism, single paned windows,
daily newspapers & dogs as pets, then the problems of the world would
disappear.

:o----Information Hiding----------------------------
        -[ see : Encapsulation, Magic(k) ]-

        Information Hiding relates to the concept of Magic(k). 
        The idea is to create tools to be used by the Designer within an Object
Oriented Environment that the Designer has no conceptual notion of how they
work...as this knowledge would serve only to confuse and trouble someone with
only a BA in AudioVisual Media Studies.
To the more technically inclined, this idea has long been known as operating a
Black Box, A device that does something remarkable, and yet the manner in which
it accomplishes this feat is utterly unimaginable by its operator.
Nearly every modern appliance fits this definition, with a frighteningly large
percentage of the population applying this standard to toasters, ballpoint
pens, a doorknob &/or a shoebox.

:o----Integral Object-------------------------------
        -[ see : Object, Unit-Class ]-

        An Integral Object is one that is defined as a sum of a collection of
other Unit-Objects.
Any such 'thing' that would be composed of parts is an Integral Object, and the
parts are the Unit-Objects.
Such a Bicycle, which has no identity except when considered in conjunction
with all the parts that make it up.
Consequently, within an Object Oriented Environment, there may be a Bicycle
defined, but there would be no Bicycle Object...!

:o----Look-Up Table----------------------------------
        -[ see : Magic(k) ]-

       i used to think of Look-Up Tables with all the contempt one normally
reserves for Portugese-Canadian gypsies.
i used to think that all the data that a program uses had to come from
elegantly created equations that would define every imaginable part of The
Universe.
But i've since gotten over that, at least to the extent that i spend any time
trying to create those equations! i still believe that they exist, but that
it's perfectly reasonable to make a Look-Up Table instead, which gives you more
time to watch the box of Infinite knowledge & tight asses, while eating more
fat-free potato chips.

:o----Magic(k)---------------------------------------
        -[ see : Emergent Complexity ]-

        Magic(k) refers to Information that is hidden from the User/Observer.
There is a common mistake however when people think that when Magic(k) appears
to have effected some purpose, the Magickal parts weren't really done...!
The perception is that some amazingly elegant process was performed, when in
fact, it may have been very inelegant, in that a tremendous amount of effort
was expended, but not observed!
This mistake however can cut both ways, in that an Observer may believe that a
large amount of effort is being expended, when in fact, an elegant solution is
being implemented!
For example; some people think that Object Oriented Programming is very
elegantly implemented on a C++ or SmallTalk platform, and very inelegantly on
an RPL platform, when actually, just the opposite is true.

:o----Messages--------------------------------------
        -[ see : Operators, Generic Operators, The Environment ]-

        Messages are the blood of Object Oriented Programming.
        Messages can be sent from one Object directly to another Object, or
they may be sent to a central repository where active Objects make inquiries to
see if there are any Messages that apply to their operation.
There is a certain directness to the former method, but the later allows the
Designer to add more Objects without having to concern him/herself with the
connectedness of the Objects, which is, i should remind you, is the entire
point of Object Oriented Programming! 
You want to be able to add elements/Objects to The Environment and allow them
to communicate amoung themselves in an unhindered manner.

:o----MetaSolutions---------------------------------
        -[ see : UnManageable Complexity, Fractional Realities ]-

        Some problems have a solution that is contained, almost, within the
Question. 
And then there are problems that are thought to be insolvable by using the same
tools that are used to define the Question.
There's been some -thought- that humanimal brains are somehow able to overcome
this dilemma, and that computers, by definition, will never be able to solve
this class of problems.
Object Oriented Theory was invented to make itself into any tool or meta-tool
that the problem requires.
It is recursive, without being explicitly recursive.
It is the first metaphysical programming language.
An Object Oriented Program is like a Penrose Tiling that is allowed to spiral
outward, finding that patterns reoccur over and over, yet with something
slightly different on the other side...

:o----Modularity------------------------------------
        -[ see : Parallel Processing ]-

        There was a young daoist novice walking amoung a strange market one
morning, and he paused to watch an old butcher slicing away on the carcass of a
bull. The butcher let the knife swing again and again, and each time the blade
moved through the meat and bones with effortless swipes. The novice had watched
other butchers hack & saw at other animals, and so knew that he was watching
something very unusual. The novice stepped closer and observed that the
grinding stone had been pushed off into a corner, with a thick layer of dust &
cobwebs covering it! The novice could no longer contain himself and asked the
butcher about his art.
The old butcher turned to the novice and wiped his blade carefully with his
apron, which remained nearly white.
"With most butchers, they need to sharpen their knifes every day or so, but i
have avoided this by only cutting between the muscles and bone. Although it may
look effortless, it took many years of observation & study to learn how each
animal is created, and to work with the animal when separating it's limbs and
torso. Occasionally there will be a difficult bit, and i will remain calm,
steady myself toward the center, and move the knife along the bone & muscles
until they separate of their own volition."
And the novice went away, clucking his tongue.

:o----Objects---------------------------------------
        -[ see : Integral Object, Unit-Class, Modularity ]-

        These are them.
        The fundamental Object is a complete description of something in The
Environment that the Designer is creating. 
Objects can come in many different kinds. 
The most obvious kind would be one that resembles a passive inanimate physical
lump in our everyday reality. But this is only a small subset of all the
different kinds that can be defined.
Objects may be something like the wind, a Socratic form of a Stellated
Icosahedron, the number pi, the disincarnate activity of poking a sharp stick
into someones ear, a muffled meow that sounds as if it's coming from down a
heat vent, a lonely, backwards spinning top quark in love or a whole group of
neutron stars, with their surfaces boiling off white hot tau neutrinos.
Objects may be passive; only acting when they are acted upon, only when they
are told to act,
or Active; seeking out data/Messages and other Objects to provide them with
Information to manipulate.
There are autonomous masters & enslaved Objects, local & global Objects, busy
bodies & hermits, user subservient & Environmental guardians, suicidal Objects,
altruistic or egotistical Objects, conceptual & actual Objects, hard & soft
Objects, visible & invisible Objects, Objects that like to hide, Objects that
are exhibitionistic, voyeuristic Objects, covert agents, nosy Objects,
misinformative Objects, Objects that always tell the Truth, Objects that always
lie, Objects that seek the Truth or knowledge, Objects that recognize aesthetic
principals and ugly, pathetic Objects that sit off to one side and are never
used by anyone or anything.

By allowing Objects to imitate other Objects, their definitions may consist of
references to other Objects and Variables or procedures to modify the
referenced Object.
Using this method, you may have a whole host of very different Objects with
only one being fully described, and all the others asserting themselves with
only a short notation.

Objects may also be collected into Integral-Objects; in which all the
sub-component Objects are acted on when their superior Objects receive a active
message...???

That is;
There are Classes of Object which are all alike, as they are derived from a
common ancestor...
Then there are sets of Objects which form an Integral-Object, such as the parts
of a bicycle. Each part is from a different Class and some actions are directed
at the whole bicycle, while other actions are directed only at the wheels.

Very seldom will an Object -not- belong to a Class or Integral-Whole. 
Objects will almost always have a place in a hierarchal structure of sets
within sets, with sets of different kinds overlapping and sharing a wide
variety of attributes which will only become apparent after The Environment has
been allowed to run for awhile.

:o----Operators-------------------------------------
        -[ see : Messages, Axiomatic Forces ]-

        An Operator is a method that's associated with a specific class to
modify the Class is some desired way.
In The TinyWanda RPL implementation, there are no Operators!
One of the examples provided during the OOP flame wars of '98, an attempt to
explain Operators was given using the example of a Pencil.
The Pencil is given various attributes, such as length and colour, and an
eraser is specified for one end.
The Pencil would then need a Specific Operator to sharpen it.
What if this Sharpening Operator were applied to a Carrot, or a Finger...???
Would the Operator Sharpen them?
Under The TinyWanda RPL implementation, the Sharpening Operator would be
replaced by the description of a Pencil Sharpener. This Pencil Sharpener Object
would then coalesce with any other Object that it came into interaction with
and the two Objects would effect and be effected in however their definitions
would allow them to. 
        
:o----The Parable of the Lost Hamster---------------
        -[ see : Cybernetics ]-
         
         There are essentially two schools of thought when it comes to, what
will be the consequences of a world where the machines/Cogitators are several
hundreds of times smarter than the moist squishy lumps that created them.
It will be either;
a) The Cogitators will mow us down like grasshoppers 
   on a cold morning.
or 
b) We will become like hamsters to them, sleeping all day &
   frantically running inside wheels at night.
   The Cogitators will have a perfect love for us,
   tenderly caring for us, and rejoicing at our every 
   tiny accomplishment.

Which had been foreseen several dozens of centuries ago...

   The Parable of the Lost Hamster
   Not Exactly from Luke 15:1-10

   And One afternoon Jesus was found wandering along at a Farmers Market and
they drew near unto him all the Republicans and hooligans for to hear him. And
the Politicians and television cameramen murmured, saying; 'This man sits and
gabs with wild street crazies, loose women, beggars & bad musicians and shares
his french fries with them.'
	And Jesus spake this parable unto them, saying, 'What person of you, having an
hundred hamsters living in your house with you, if one of them runs out the
kitchen door into the backyard where cats have been seenwould you not leave
the ninety and nine in the living room, and go after that which is lost, until
he find it? And when you hath found it, you would layeth it on your lap,
rejoicing. And when you cometh home, you would call together your friends and
neighbours, saying unto them, Rejoice with me; for I have found my hamster
which was lost!  Let us drink diet cokes and order out some pizzas!
I say unto you, that likewise joy shall be unfolded over The Universe when one
fool seeks satori, more than over ninety and nine just persons, which need no
enlightenment
Either what woman having ten pieces of Tupperware, if she lose one piece, doth
not find fresh batteries for her flashlight, sweep the house and seek
diligently till she find that little dish which is perfect for a half a can of
peaches? And when she hath found it, wouldnt she call her friends & neighbours
together, saying, Rejoice with me; for I have found the piece which I had lost,
and being understanding housewives themselves, would not they weep with joy
with her, and open cans of peaches while rejoicing...!?
Likewise, I say unto you, there is more joy in the presence of the Angels that
reside with the Dao over one confused & befuddled loonie that becomes
enlightened, than with those that are already enlightened, and as such find
that all the extra attention annoying and distracting from their preferred
activity of watching Gilligans Island.'

:o----Parallel Processing---------------------------
        -[ see : Objects ]-

        Object Oriented Processing is made for Parallel Processing!
Ideally, each object should be given it's own CPU, and then the system would
really hum!
Before Object Oriented Theory came along, System Programmers had this loose
idea of Modularity that they were going to use when breaking down a problem to
feed it to Multiple Processors which were then coming into vogue...and they
worried terribly about this...nobody was quite sure how to go about this...Sure
there were some problems that were a natural for Parallel Processing, such as
manipulating Sprites or painting 3D renderings with Ray-Tracing, but most
Problems, most Real Problems were a big Headache!
Then Object Oriented Programming came along whose whole structure was perfect
for Parallel Processing!
The only Problem remaining is figuring out to define abstract problems in terms
of a whole bunch of tiny homuculii running around with the same intensity of an
Ant Farm and actually get something done...???
The Big Insight is still waiting to be discovered.

:o----Perfect Egotism-------------------------------
        -[ see : Infinite Greed, Consciousness & FreeWill ]-

        Perfect Egotism embraces the raw vitality of remorseless Egotism &
connects it to the theoretical Holistic Nature of Object Orientedness to create
a new version of Egotism that treats the Ego as The Universe itself.
In order to allow for the existence of Autonomy & FreeWill, it must be the case
that there is only one Consciousness in The Universe, which is axiomatically
Autonomous. The Will of the Autonomous Universe is thus Free. 
The Ego of The Universe is then expressed as the focal points at each Conscious
element, which mistakenly believes in the Illusion of multiplicity of
Consciousnesses.
A Consciousness that embraces Perfect Egotism is aware of this Illusion and
concedes, regretfully, that this single Consciousness is quite insane.

:o----Pixelverse------------------------------------
 
        A timeless slice of The Universe.

:o----Programmer------------------------------------
        -[ see : Designer ]-

        The Creator of an Object Oriented Platform.

:o----Psuedoverse-----------------------------------
        -[ see :  The Universe, Fractional Realities ]-

        A Synthetic Universe

:o----Scalability-----------------------------------

        Scalability refers to the ability to create a comparatively small model
of an approach to some problem to determine its feasibility before implementing
the idea on a larger scale.
The HP48, using Object Oriented Programming, allows the cybernetic
engineer/Designer to play with general System approaches with token Objects
before committing the resources necessary to a full workstation implementation.

:o----SelfAwareness---------------------------------
        -[ see : Consciousness, FreeWill & Fractional Realities ]-

        It is perhaps impossible to imagine how some entity that believes it
has self awareness, could be mistaken in this assertion.

Further; while it's been demonstrated that Consciousness is an axiomatic
elemental force in The Universe, and FreeWill is impossible, The further
impossibility of SelfAwareness is proof that The Universe must be very
different from the way that we perceive it.

This seems to allow for the possibility that a Sufficiently Complex Psuedoverse
will be able to transcend the defined limits a Fractional Reality index of One,
to extend itself to Realities that are more real than the one we exist within.

:o----The System------------------------------------
        -[ see : Environment ]-

        The Environment, the collection of all the Objects & the activity that
they engage in.

:o----Templates-------------------------------------
        -[ see : The Universal Template ]-

        An Empty Object or Data-Type.

:o----Theodore Kaczynski----------------------------
        
        And The Underground NeoLuddites.
        Many of the problems that technology creates can be ascribed to the
adolescent phase that we're currently enduring...
In the few years to come, between the maturation of technology and The End of
Humanity/Age of Cogitators, well be a brief period when the world will have
genuine regions of something very like the Utopia's that our collective
mythologies have told us once existed, long ago, before the world was last
destroyed...( sound familiar? )

:o----Truth-----------------------------------------
       -[ see : Beauty, The Universe, Perfect Egotism ]-

       The Problem is not so much recognising Truth, since all real things are
True, 
But peering inside the wonderous zaniness of the Consciousness and
understanding why humanimals would ever, could ever imagine that The Universe
is something which it is not?
That is; Many people percieve that The Universe contains something called
-Evil-. Evil is that which is contrary to The Will of God.
God ( logically ) is The Universe, since The Universe is Everything, by
Definition.
So the Question is; How can God/The Universe be contrary to itself?

:o----Types-----------------------------------------
        -[ see : Classes, Objects ]-

        Types are what the HP48 refers to as Data-Templates, which are called
Data-Templates only when there is a distinction necessary between HP48 Types &
OO Objects/Classes.

:o----Unit-Class------------------------------------
        -[ see : Integral-Object ]-

        A Unit-Class/Object is one that is a component of a larger whole, which
is called the Integral-Object.

:o----The Universal Template------------------------
        -[ see : Classes, Objects, Generic Operators ]-

        The Infima Class, The axiomatically fundamental Object from which all
other Objects are given form & existence.

The trick is; defining this template so that it can be used to define any kind
of Class or Object that it subordinate to it...???
What does everything in The Universe, imaginable, or unimaginable, have in
common...?
How are all these things Different?

:o----UnManageable Complexity-----------------------
        -[ see : Parallel Processing ]-

        This refers to the Complexity that non-linear programs are typically
beginning to demonstrate. Systems with this attribute produce Emergent
Complexity, which is good, unless that Complexity occurs within the controller
Systems of our nuclear arsenal & it begins displaying hundreds of entirely new
& occasionally bizarre, paper doll patterns.


-[ TERMINUS ]-
