Code Space Generation, Protection, and Communication

[Gary D. Duzan]

   How about a brief look at the basics? Here are some basic things
we will need:

1) A code space. Private code and code included from elsewhere. This
implies a binding mechanism (dynamic or static) and a method of
locating the external code. (Constant data can be considered part of
the code, for all practical purposes.)

2) An execution space. A code space, a data space, and execution state.
For multitasking (or whatever your favorite term happens to be) more
than one of these is required. So we need a way to create and control
the execution space.

3) Communication. A standard way for execution spaces to pass data
between them. To communicate, execution spaces require some sort of
naming mechanism to direct the data to be communicated.

4) Protection. Keep execution spaces from disturbing other execution
spaces or the hardware. So we have to define which execution spaces
can perform particular sets of operations on particular code spaces,
data spaces, execution states, and hardware.

   Now, if we plan to globally implement object inheritance via code
inclusion, protection becomes a serious issue. For example, one idea
proposed was to inheirit a keyboard object to handle the object's
keyboard input. However, if the keyboard code needs access to the
keyboard, there needs to be some way to keep the upper-level code
from disturbing the keyboard hardware. In other words, the system
needs to enforce the object interface.
   Now, the 386 can probably handle this pretty well by using the
protection attributes of 386 segments. However, other architectures
may require a separate execution space to properly enforce this
protection. This implies that the inheritance in this case must
be translated into communication. Therefore, we should define a
standard communication method for invocing "base class methods"
on other objects.
   Anyone see any major logic flaws here?

                                        Gary Duzan
                                        Time  Lord
                                    Third Regeneration
                         Humble Practitioner of the Computer Arts