[ale] Object Model on Linux

[charlie]

On Thu, 26 Dec 1996, Brad Dixon wrote:

> You've got the right idea, but I am much less interested in creating a
> scripting tool then creating an object system, and a free one at that.
> Yes, I think that CUA scripting like in the demo is cool, but I was much
> more impressed with the rest of the demo: nestable folders, objects that
> had intelligent uses (not just an icon with a popup menu!), multiple views
> of the same folder (list, icon, details).

> You should also think about extensablity. I'm not sure how they do it, but
> IBM's WPS has some interesting features. All of the object classes are
> contained in DLLS (I would rather see our object system use an object
> database for that). Say you have a basic folder object. It can display the

The DLLS are just 'ILU' equivalent wrappers of executables.  The database
you refer to I understand as being equivalent to the Smalltalk system.
It keeps track of the class structure and the instances.  At runtime
all of this information is avaible to the program.  Java allows for
this too.  If you thought of your apps as Classes then the system would
know what its 'Meta-Class' is and all of its children.  Like in the
example below.  (Sorry for the programming language analogies, but they really 
parrellel a TON of the ideas).
Also with this system you could take snap shots of the current systems
state by using this system.  That could be placed into the objects.
Much like in the demo where the sales rep put the negoiations on hold
did some stuff, and came back to exactly how it was.  A snapshot of the
current state of the system is just a type of object.

> Maybe a picture would help:
> 
> Root Object-------\
> 		  |
> 	/FOLDER META-CLASS
> 	|	normal-folder
> 	|	      |
> 	|	sorting folder
> 	|	/	|	\
> 	\ftp-folder  zip-folder  tar-folder
> 
> All folders have the same meta-class, and therefore the same external
> interface. If you just want a normal-folder, the object system would give

> Now, any idea how they do this? I've been reading a little about CORBA and
> ilu, and it seems in the ballpark.

ILU is definetly one way to go.  However, here is an alternative that
might sound tempting.  Ready: JAVA!  Yep.  Using Java's RMI (remote method
innovaction (?) ) with the new JDK 1.1 you could ditribute your objects
like in ILU.  And have the registry information as in above.  I know it
has some problems that might really impede on using it.  However, it
does provide a lot of extensibility your speaking of.  Also Java's
ideas of executing a class and not a function as in C++ is very
essential to the idea of these systems.  One BIG problem is the
unfortunate thing of a single language.  ILU you could write any
language that has a ILU language spec on it.  

Also Java provides mechanisms for the complier to check and make all objects 
inherriting from a parent implenment certain attributes.  I see this as key 
to developing a way to have a protocol between objects for sharing data.  So 
when using various objects, those objects know what to do when another object
hands them data.
So when Object A is dragged and dropped then there is a certain behavior that 
follows that is different from Object B.  And it probably will depend on what 
is dragged onto, and allow the user to extend this.  So dragging Object A onto
Object B does one thing that is different from dragging Object A onto Object C.
And if there is an Object D then the user can define what Object A will do
when dragged onto Object D.  ( That's really general, but maybe some insight
into the inerface )

pie charts and the little extert was almost a direct copy of the OPENDOC
stuff.  The ability to take the chart and mesh it with an Word processor
file is the basic concepts of OPENDOC.  However, OPENDOC only really works as
an open container for information.
But a lot of the demo centered around those ideas.  Taking the video clip from 
the folder and attaching that to the sales report -- OPENDOC.  The folders
are like super OPENDOC's that contain objects.  It doesn't matter was type
of objects are there.  Much like OPENDOC.

I'm trying to divide out general classifacations of objects.  Like
we see folders, devices, and documents/apps.  Documents act very closely
to apps in the view of the system.  Documents have attributes as well as
methods.  Devices are things that do things:  Printers, modems, etc.
I don't think devices would have to be closely tied to the real world or
actual components of the machine.  Folders hold objects and provide 
functionality to work with objects.  (Searching, sorting, etc)
Maybe someone could extend/refine these idea.

I guess my messages were way to general.  I should've backed them up with
a demo :)
							        Charles Hubbard
	   		 	          Internet: charlie at felix.cc.gatech.edu
 ". . .the pope talks a lot about sex, of which he knows nothing. . ."  
	- Robert Anton Wilson