object interface standards
Joseph Strout
commonly used classes (strings, containers, interface widgets).
An "object interface standard" would define a minimum interface (i.e.,
public methods and member variables) which must be supported by any given
type of class. Any class which adhered to the standard could be
substituted in a project for any other (provided the platform
requirements are met). Different implementations of a standard class
might vary in platform, memory vs. speed, optimization, etc., but this
would be hidden from the user.
As an example, the OIS might define three levels of String. A level 1
String supports conversion to/from a character array, the assignment
operator, and comparison operators. A level 2 String meets the Level 1
interface criteria, but adds certain substring operators. A level 3
String meets the Level 2 OIS, but adds regular expression matching.
(This is meant just an example; the details would have to be worked out
by mutual agreement.) If I need a level 2 String on my Mac, I may choose
one which is implemented as a Pascal string so that I can pass it to the
toolbox routines easily. If you need the same thing under Unix, you may
choose a different implementation. No matter; our code is the same.
A more useful example would be interface widgets. If we can define, say,
a "Window" class (or set of classes) with a specific interface, then we
can proceed to write implementations appropriate to each platform. I'll
call Window toolbox routines; you may just draw boxes or whatever. But
the interface is standard, so to port to another platform, you just drop
in the appropriate Window classes in place.
What I'm getting at is not a class library, but rather a loose collection
of class interfaces, to which anyone could contribute an implementation.
Is there such a thing? If not, why not?
,------------------------------------------------------------------.
| Joseph J. Strout Department of Neuroscience, UCSD |
| jst...@ucsd.edu http://sdcc3.ucsd.edu/~jstrout/ |
`------------------------------------------------------------------'
Enno Sandner
counterpart of the OMG-Object-Services. Also, I think the hard part
will be to fix the semantics of the offered services in an usefull
way.
regards
Enno
Joseph Strout <jst...@ucsd.edu> writes:
>In short: I'm asking about/proposing a set of standards for defining
>commonly used classes (strings, containers, interface widgets).
>
>An "object interface standard" would define a minimum interface (i.e.,
>public methods and member variables) which must be supported by any given
>type of class. Any class which adhered to the standard could be
>substituted in a project for any other (provided the platform
>requirements are met). Different implementations of a standard class
>might vary in platform, memory vs. speed, optimization, etc., but this
>would be hidden from the user.
>
> [ ... ]
Brett Walker
though not as formally or completely as a real standard.
We develop a cross-platform product that runs on Mac, Windows, OS/2, Netware,
and almost every flavor of unix. One of our biggest problems is writing
a GUI interface that is highly portable. We've looked at the various
cross-platform development tools, and found them lacking in terms of
support, performance, and extensibility.
Instead, we're attempting to use platform specific GUI libaries (such as
MFC for Windows and PowerPlant for Mac) and provide our own common
set of classes and interfaces on top of it. We're not planning on
subclassing every object in a GUI library, but we will have our own
Window and Dialog objects, specialized listbox objects, etc. Any objects
that we would normally need to write will be given a standard interface
that must be adhered to, no matter what the underlying GUI library is.
If a better GUI library comes out for a platform, we should be able to
simply rewrite the interface objects - all remaining code should work
(we hope). We're still in the design stage, but we think its going to
work.
In any case, like you're idea...
Brett Walker
IBM
walk...@vnet.ibm.com
In article <Pine.SGI.3.91.950829122906.1329B-100000@golgi>, Joseph Strout
<jst...@ucsd.edu> wrote:
> In short: I'm asking about/proposing a set of standards for defining
> commonly used classes (strings, containers, interface widgets).
>
> An "object interface standard" would define a minimum interface (i.e.,
> public methods and member variables) which must be supported by any given
> type of class. Any class which adhered to the standard could be
> substituted in a project for any other (provided the platform
> requirements are met). Different implementations of a standard class
> might vary in platform, memory vs. speed, optimization, etc., but this
> would be hidden from the user.
>
> As an example, the OIS might define three levels of String. A level 1
> String supports conversion to/from a character array, the assignment
> operator, and comparison operators. A level 2 String meets the Level 1
> interface criteria, but adds certain substring operators. A level 3
> String meets the Level 2 OIS, but adds regular expression matching.
> (This is meant just an example; the details would have to be worked out
> by mutual agreement.) If I need a level 2 String on my Mac, I may choose
> one which is implemented as a Pascal string so that I can pass it to the
> toolbox routines easily. If you need the same thing under Unix, you may
> choose a different implementation. No matter; our code is the same.
>
> A more useful example would be interface widgets. If we can define, say,
> a "Window" class (or set of classes) with a specific interface, then we
> can proceed to write implementations appropriate to each platform. I'll
> call Window toolbox routines; you may just draw boxes or whatever. But
> the interface is standard, so to port to another platform, you just drop
> in the appropriate Window classes in place.
>
> What I'm getting at is not a class library, but rather a loose collection
> of class interfaces, to which anyone could contribute an implementation.
> Is there such a thing? If not, why not?
>
MediaServe
That's IMHO a good idea. It would be sth. like a language specific
counterpart of the OMG-Object-Services. Also, I think the hard part
will be to fix the semantics of the offered services in an usefull
way.
regards
Enno
Joseph Strout <jst...@ucsd.edu> writes:
>In short: I'm asking about/proposing a set of standards for defining
>commonly used classes (strings, containers, interface widgets).
>
>An "object interface standard" would define a minimum interface (i.e.,
>public methods and member variables) which must be supported by any given
>type of class. Any class which adhered to the standard could be
>substituted in a project for any other (provided the platform
>requirements are met). Different implementations of a standard class
>might vary in platform, memory vs. speed, optimization, etc., but this
>would be hidden from the user.
>
> [ ... ]