home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / OOF20.ZIP / OOF.DOC < prev    next >
Encoding:
Text File  |  1987-09-19  |  8.5 KB  |  216 lines
  1.  
  2. {                          Version 2.00                        87/09/19
  3.  
  4.                      OOF! (Object Oriented Fudge)
  5.  
  6.        Utilities for Object Oriented Programming in TURBO Pascal.
  7.  
  8.  
  9. COPYRIGHT NOTICE:
  10.  
  11.   These utilities are COPYRIGHT (c) 1987 by Mike Babulic. They may be used
  12.   as if they were in the public domain so long as the following conditions are
  13.   met:
  14.          1) This notice of copyright must be included in full unless the
  15.             copyright owner's permission is obtained.
  16.  
  17.          2) Commercial publishers must obtain the copyright owner's permission
  18.             before physically publishing this work. Anyone may publish this
  19.             work in a non-physical form.
  20.                 - some examples of non-physical publication (allowed):
  21.                     - Electronic Bulletin Boards, Compuserve
  22.                 - some examples of physical publication (prohibited):
  23.                     - Books, Magazines, Floppy Disks
  24.                 - Computer clubs are NOT considered to be commercial publishers
  25.  
  26. AUTHOR:     Mike Babulic
  27.             3827 Charleswood Drive N.W.
  28.             Calgary, Alberta
  29.             CANADA
  30.             T2L 2C7
  31.  
  32.             Compuserve Id.:  72307,314
  33.  
  34.  
  35. A SMALL TALK (pun intended):
  36.  
  37.    These utilities "Fudge things", extending TURBO Pascal to allow an
  38.    object-oriented approach to programming.
  39.  
  40.    Object-oriented programming is neet stuff! Each OBJECT is a member of a
  41.    CLASS. A class is simaler to a TYPE in ordinary Pascal but it is also
  42.    more! A class is a type and all the operations that can be performed on
  43.    that type. These operations are called a class's METHODS.
  44.  
  45.    A CLASS consists of both a datastructure and the methods (procedures and
  46.    functions) which operate on that datastructure.
  47.  
  48.    To perform an operation, you send a MESSAGE containing ARGUMENTS to the
  49.    object that you wish to use. In the case of these utilities a message is a
  50.    procedure call whose last argument is the object.
  51.  
  52.    So far this is quite unexciting. It appears to be a complicated way of
  53.    talking about things that could be explained more simply. All this jargon
  54.    has a purpose however, it allows us to discuss the concept that makes the
  55.    object-oriented approach so powerful. That concept is INHERITANCE.
  56.  
  57.    When a class of objects is being defined, it can INHERIT the properties of
  58.    a PARENT class. Exceptions and additions can then be described. In other
  59.    words you can say things like "This class is just like the previous one
  60.    except that it should also have a new data field and the procedure to
  61.    write it on the screen should be changed". That has the potential of saving
  62.    a LOT of coding!
  63.  
  64.    Here is another advantage: suppose you have a program that manipulates
  65.    various shapes. A piece of code to draw these shapes on the screen might
  66.    look something like this:
  67.  
  68.           CASE thing.kind of
  69.             point:    drawPoint(thing);
  70.             circle:   drawCircle(thing);
  71.             triangle: drawTriang(thing);
  72.          and so on ...
  73.  
  74.    A chunk of object oriented fudge might look like this:
  75.  
  76.          DrawShape(thing);
  77.  
  78.    If you add other shapes (squares, pentagons, etc.) you will have to change
  79.    CASE statements throughout your program to account for them. Nothing needs
  80.    changing in the object-oriented program!
  81.  
  82.  
  83. WHAT'S THE DIFFERENCE BETWEEN Object AND Instance?
  84.  
  85.    The same as the difference between TYPE and VARIABLE.
  86.  
  87.       - An OBJECT is a DEFINITION (datastructure, messages and methods).
  88.  
  89.       - An INSTANCE is a THING WHO'S DEFINITION IS AN OBJECT.
  90.  
  91.    In other words: Objects are like expanded type declarations.
  92.                    Object Variables are "instances" of objects.
  93.  
  94.  
  95. IMPLEMENTATION DECISIONS
  96.  
  97.    - The MESSAGE RECEIVER (object or class) is a VAR parameter and
  98.        the LAST PARAMETER of a message procedure.
  99.  
  100.            1) VAR PARAMETER - an object's data may be changed by a method.
  101.  
  102.            2) LAST PARAMETER - the object is easy to find on the stack.
  103.                      It is always second from the top under the return address
  104.                      so the dispatcher doesn't need to know how many
  105.                      parameters a method has.
  106.  
  107.  
  108.    - A CLASS is represented as the address (ie. offset from CSeg) of the
  109.        dispatcher procedure of that class. (reasons: simplicity & speed)
  110.  
  111.    - METHODS are "FORWARD" procedures.
  112.  
  113.        One of the quirks of Turbo Pascal is that a forward procedure
  114.        declaration is complied as a JMP to the second declaration, which
  115.        follows later in the code segment.
  116.  
  117.        Declaring the methods of an object type as "forward" and putting all
  118.        these declarations together in one place means that we create an
  119.        ARRAY OF PROCEDURES. This makes it easy for the dispatcher procedure
  120.        to select the correct method when passed a message.
  121.  
  122.        Each JMP is 3 bytes long. That is why messages are numbered 0,3,9...
  123.        instead of 1,2,3...
  124.  
  125.    - OOF uses the STACK and NOT THE HEAP to store instances of objects.
  126.  
  127.        This is unlike most object oriented programming systems. They
  128.        are almost always heap based.
  129.  
  130.        Why is OOF stack based? Well, I'm not just being ornery ...
  131.  
  132.           1) Garbage collection - this is trivial (and extremely fast)
  133.                   with stack-based objects.
  134.  
  135.           2) Safety - a programmer using Object Pascal must dispose of
  136.                   (and C++ programmers must free) instances of objects when
  137.                   they are finished with them. This means there is a danger of
  138.                   DANGLING POINTERS.
  139.  
  140.           3) Appropriate Model - the vast majority of object instances are
  141.                   created by the method that uses them. Why complicate things
  142.                   with both an object handle in the stack AND an instance in
  143.                   the heap?
  144.  
  145.  
  146. NOTATIONAL CONVENTIONS  (adapted from Object Pascal)
  147.  
  148.    The TYPE of object is called "T<name>".
  149.            - example: TWindow
  150.  
  151.    The METHODS of an object all have names beginning with the name of the
  152.         TYPE, followed by an underscore.
  153.            -example: TWindow_WTitle
  154.  
  155.    The DISPATCHER procedure of an object is called "C<name>" because
  156.         it's address (offset) defines the class.
  157.            - example: PROCEDURE CWindow(message,number:Integer);
  158.  
  159.    The LAST PARAMETER of a MESSAGE is a typeless VAR parameter which
  160.         represents the object or class the message is to be passed to.
  161.         It should be called "SELF" unless the message is a class message;
  162.         then it should be called "aClass".
  163.  
  164.    The LAST PARAMETER of a METHOD is a VAR parameter of method's TYPE.
  165.         It should be called "SELF" unless the message is a class message;
  166.         then it should be called "aClass".
  167.  
  168.  
  169. HOW TO USE OOF / DEMO PROGRAM
  170.  
  171.    OOF.INC is an $Include file that implements the object programming
  172.            extensions to Turbo Pascal
  173.  
  174.    DEMO.PAS shows you how to organize your program to do object oriented
  175.            programming.
  176.  
  177.    *** IMPORTANT ***
  178.  
  179.            MESSAGES are numbered  0,3,6,9 ... etc. NOT 1,2,3
  180.  
  181.            METHODS  must be declared as a LIST OF FORWARD PROCEDURES.
  182.                     There must be nothing but comments between methods
  183.                     in the list (no constants, no variables, no other
  184.                     procedures or functions ... none! nothing! nada!)
  185.  
  186.  
  187. PAST & FUTURE:
  188.  
  189.    I got the idea for this stuff from Object Pascal, which I first encountered
  190.    on Apple's Macintosh computer. A look through "SMALLTALK-80, The Language
  191.    and Its Implementation" by Goldberg & Robson (Addison-Wesley) also helped
  192.    me to understand object-oriented programming.
  193.  
  194.    I hope to use this Object Oriented Fudge to create a window manager for
  195.    turbo programmers. It should be just the sort of project to build a
  196.    "wish list" for version 3 and also to shake out any problems there might be
  197.    in version 2.
  198.  
  199.    If you have any suggestions or comments, please write or send me Compuserve
  200.    EMAIL. I also log on to a friend's BBS quite often & can usually be reached
  201.    there (Calgary FIDO: (403) 282-1703,  net/node = 134/1).
  202.  
  203.  
  204. BIBLEOGRAPHY:
  205.  
  206.    1) "SMALLTALK-80, The Language and Its Implementation"
  207.             Goldberg & Robson (Addison-Wesley)
  208.  
  209.    2) "Object-Oriented Programming for the Macintosh"
  210.             Kurt J. Schmucker (Hayden, 1986)
  211.  
  212.    3) "TML Pascal User's Guide and Reference Manual"
  213.             (TML Systems, 1986)
  214.  
  215.    4) "Object Oriented Programming, An Evolutionary Approach"
  216.            Brad J. Cox (Addison-Wesley, 1986)