Object Oriented and Object Based Programming are still fluid.

  Some useful, yet not standardized, definitions:

  Object            - A software packet containing a collection of
                      related data (in the form of variables) and
                      methods (procedures) for operating on the
                      data. An object is a specific instance of a
                      class and includes all characteristics of the
                      class.

  Class             - A template for defining methods and variables for 
                      a particular type of object. All objects of a given
                      class are identical in form and behavior but
                      contain different data in their variables.

  Method            - A procedure contained within an object that is
                      made available to other objects for the purpose
                      of requesting services of that object. Most,
                      if not all, communication between objects takes
                      place through methods.

  Message           - A signal from one object to another that requests
                      the receiving object to carry out one of its
                      methods. A message consists of three parts: The
                      name of the receiver object, the method to carry
                      out and any actual parameter values the method
                      may require to fulfill its charge.

  Abstract Class    - A class with no instances that is created only
                      for the purpose of organizing a class hierarchy
                      or defining methods and variables that will apply
                      to all lower level classes.( Also a virtual class.)

  Class Hierarchy   - Starting with a base class that does not depend
                      (inherit) from any other class, subclasses of
                      the base class are in the hierarchy of the base
                      class. This continues ad nausea as sub-subclasses
                      inherit from their parent class. The terms parent,
                      child and sibling have the obvious relationships
                      of classes within a class hierarchy. A parent
                      could also be called a super class and a child
                      could be called a subclass. Classes with an
                      " is a " relationship make sense as a subclass.

  Object Hierarchy  - Assembling a complex object, like a car,
                      has an object hierarchy of a frame, four wheels
                      and so forth. Objects with a " belongs to "
                      relationship signify composition and are part
                      of an objects hierarchy.

  Abstract Data Type- A data type defined by a programmer that is not
                      built into the programming language. Abstract
                      data types are typically used to create high-
                      level structures that correspond to real world
                      objects represented in a program.

  Member Function   - A specific method in a specific class. The function
                      (method) is a member of (defined inside) a class.


  Instance Variable - Normal variable that stores a unique value for
                      each instance of a class ( for each object ).
                      This is only used when necessary to distinguish
                      the less common class variable, common to all
                      objects of that class.

  Instance          - A term used to refer to an object that belongs to 
                      a particular class. Maryland is an instance of
                      the class state.

  Encapsulation     - Allowing only the required information to be
                      exposed outside of a class ( or object). This
                      implies protection such that variables in the
                      class always contain valid data.

  Information Hiding- Encapsulation.

  Template Function - Provides a prescription for automatic generation
                      of an infinite set of function instances, varying
                      by type, but whose implementation remains invariant.
                      Pro: It is quick and easy. Con: No type checking.

  Overloading       - Multiple function instances that provide, usually,
                      common operation, but require differing
                      implementations, to share a common name.
                      Pro: Automatic type selection and checking.
                      Con: Difficult to find in C++ unless good conventions.
                      Technically: Polymorphic over limited types.

  Polymorphism      - The ability to hide different implementations behind
                      a common interface. For example a 'print' method
                      would do what is necessary to print any object
                      where printing made sense. i.e. Overloading over all
                      possible types.

  Virtual Functions - The function to execute is chosen at run time. This
                      is very akin to shared generics in Ada.

  Object Oriented   - Purist think Smalltalk

  Object Based      - Purist think C++ and Ada

  Reuse             - Including previously produced designs, code, tests
                      and documentation in a different application.