[MUD-Dev] Re: DevMUD: Inheritable modules

[Bruce]

On Wednesday, October 28, 1998, The Arrow wrote:
>There have been a lot of talk about modules, how to implement them, and how
>to send messages between them.  But so far I haven't seen anything about
>inheritable modules.  I know it wouldn't be trivial to make a good
>implementation, but once done they might make DevMUD even more OO and
>extensible.  What do you think about it?


Have you looked at TOM (http://gerbil.org/tom/) ?

To quote from that page:

               TOM is an object oriented programming language. It may look
like Objective-C at a first
               glance, but that resemblence is only syntactic. TOM is about
as much like Objective-C as
               Objective-C is like Smalltalk. Why another OO programming
language? Because TOM
               promotes usability of objects, not just reusability.
Reusability is a prerequisite of an OO
               language, but subclassing a given class to make it suit your
needs does not always work,
               for instance when you have no control over all locations
where objects are instantiated. In
               such cases, a modified class is what you need: without the
possibility to modify classes,
               you're stuck programming with something between objects and
abstract data types.

               TOM provides the following features in support of usable
objects:

                    * classes are extensible entities: a class is defined by
its main definition and its
                       extensions,
                    * an extension can add and replace methods. In support
of complex added
                    * behaviour, an extension can add instance variables. To
promote object reuse, an
                    * extension can introduce additional superclasses,
                    * extensions can be added to a program at compile, link,
or run time.

               To highlight some more features: TOM is dynamic; it provides
very simple (as in `elegant')
               multiple inheritance; methods are overloaded on both argument
and return types;
               instances as well as classes are true objects; they can be
extended and modified at run
               time and at compile time; objects are managed by a tracing
incremental garbage collector;
               returns are multi-valued; methods have preconditions and
postconditions (in pursuit of
               supporting Design By Contract); and the condition mechanism
(`exceptions'), like every
               part of the language, is an attempt at the right balance
between arcane, baroque, simple,
               elegant and, foremost, usable.

               The TOM compiler and tools are licensed under the GNU General
Public License
               (GPL); the libraries under the GNU Library General Public
License (LGPL). This means
               that (1) you can apply TOM for commercial applications---no
strings attached---and (2)
               if you fix a bug in the TOM tools or libraries the rest of
the world should share in that
               achievement.

Good day,

 - Bruce