🚀 go-pugleaf

Stahl Michael wrote:

> What is object orientaiton? 

A very hard question to answer, because you will probably get as many
definitions as people you ask (if not more!)

Generally. Object Orientation is a way of writing software that tries
to work in a way similar to how the human mind thinks.  Rather than
dealing with Data and Code, we deal with 'Objects'.  An object combines
both the data and the code that deal with the same concept, and
different objects work together to make your software.

Each object should be a simple idea, so you can describe it in terms of
it attributes (data, eg. colour) and its behaviour (code, eg Draw() )

That is pretty much the common base of all Object Oriented systems, but
there are a few extra features most people expect.

First, objects only communicate by sending messages to each other,
there is no direct access to the internal data of an object.  This
principle is called often 'encapsulation' and is a huge help in
designing large, complex systems that are stable against continually
evolving code.
"sending messages" often reduces to calling object methods these days,
or member functions in C++.

Another common feature is inheritance.  I can derive a more specialised
version of an object by basing it on an existing object, and
refining/adding the special behaviour unique to the new one.  Often,
this is implemented in terms of classes, which describe the object to
the compiler, rather than directly on 'live' objects at runtime.
However some modern languages, such as Python, allow exactly this sort
of runtime specialization as well.

The third common feature is generally called 'polymophism' and is
commonly implemented as a 'virtual function'.  This confusing name
basically means that when you create a more specialised object (or
class) you can change how a method works, 'overide' it.  Then code
written to deal with the base object type, when handed your more
specialized object, will magically call the correct overiden version of
your function.

System lacking virtual functions (and sometimes inheritance) are often
called 'object based' rather than object oriented.  However, there is
no hard and fast definition for either of these terms.

And just to thoroughly confuse matters <g>  although polymorphism is
usually thought of as a runtime feature - your correct function is
magically called at runtime, C++ also features compile time
polymorphism through its template syntax.

> Would it make sense to attempt to create a completely new ide
> application for it?

It made so much sense it has been done many times <g>  The Smalltalk
environment invented many of these ideas over 20 years ago, and the
Delphi/C++Builder IDE is an excellent demonstration of these ideas
today.

> This would have to load and edit objects (dlls) dynamically at 
> runtime, jumping into it and even recurse freely in between then.
> Am i getting feverish ?  --

Possibly <g>  I would take a look at some Microsoft technologies here,
specifically ActiveX/COM, or the new(ish) .NET platform.

I would also try a little research on some of these ideas with Google.
There are a number of good sites out there that explain these ideas far
better than I ever will, especialliy in the small space of a newsgroup
posting <g>
Good luck!

AlisdairM(TeamB)