CSC/ECE 517 Fall 2010/ch2 2c ck

Prototype Based Inheritance

Introduction

Dictionary Definition: An original, full-scale, and usually working model of a new product or new version of an existing product.^[1]
"... the prototype approach in some ways corresponds more closely to the way people seem to acquire knowledge from concrete situations"^[2]
Since the early period of implementation of Object Oriented Design (OOD), there have been two schools of thought concerning the best method of implementing OOD. The class approach, which is the static method of implementation. And the Prototype approach, which is the dynamic method of implementation.

The class based implementation of OOD is very rigid and favors a design first approach. The prototype based implementation of OOD favors a design as we go or iterative approach.
Even though the prototype implementation of OOD has been around for a long time, it is just now starting to show interest in the development community. One of the first languages to support prototyping is called Self. Self has been around since the 1986 and is still in active development. Its current version is 4.4.

Delegation

The mechanism for implementation of prototyping is called Delegation.^[2]
Delegation is a process whereby an existing object dynamically searches for properties and methods first within itself, then if an match is not found, it delegates that search to its parent object. The parent then repeats the exact same delegation process until a match is found. Once a match is found the result is returned to the requester.

Simple Example
This example demonstrates two objects that I always want aligned on the same y axis, however I want them to be independent on the x axis.

Box remains as is but Point is changed

NOTE: In the above example Box.GetPoint() would also return [10,10]. When GetPoint() searches for X it starts at the original requestors level and uses delegation just like the method search for Box.GetPoint().

While delegation is simple in its design, we will see that it is also elegant. In that it opens the door for several different techniques which allow software developers to morph an existing object, into a much larger and more robust object. While still retaining the original objects simplicity.

Competing Approaches

Class Approach

New objects are made from predefined classes. A class definition must exist to create an instance of a class. When a class is changed, existing objects must be reconstructed and we also need to ensure that nothing else in the application requires the prior classes constructed behavior.

Prototype Approach

New objects are constructed by copying an existing object. After copying we are safe to change the class behavior knowing that we are independent of all other objects. Prototyping is dynamic allowing us to create a real world object as a single instance and then refactor it at run time.

• We can add to it.
  
• We can remove parts from it.
  
• We can break parts out and move to a different location in the same delegation tree. Thereby extending the original behavior to more objects in the same object hierarchy.
  

Contrasting Development Styles

Class Development Style	Prototype Development Style
Must think about objects abstractly and develop a model to simulate behavior	Most people can think clearly about objects that already exist
Many people lack the ability to perform well when working with abstract thoughts	Most people have the ability to perform well when working with real world objects
Good communication is limited to those that can think abstractly	Good communication is open to normal methods of everyday interaction
Real world examples need to be broken down to a model and then reconstructed before they can be worked with	Real world examples can be worked with in real time, there is no need to model behavior

Analysis

Advantages of Prototype

• Reduces development time.
  
• Reduces development costs.
  
• Developers receive quick results and can move on to the next task.
  

Disadvantages of Prototype

• Can lead to insufficient analysis.
  
• The performance may be degraded by prototype overhead.
  
• Can cause systems to be left unfinished and/or implemented before they are ready.
  
• Sometimes leads to incomplete documentation.
  

Prototype Inheritance

As we will see, some dynamic languages use prototyping to support dynamic inheritance and multi-inheritance.
All object inheritance is initially copied from an existing object, then when additional functionality is desired, inheritance may be added at runtime via delegation.
The biggest design benefit of prototype inheritance is that inheritance functionality may be added anywhere within the existing objects class tree. It may be added to (or removed from) the end, the beginning, or anywhere in the middle. It is very flexible and powerful.

Real World Example

A bank account

Class Approach

Focus of thought is constantly changing:

1. Start with use cases
   
2. Create a class diagram
   
3. Write Code
   
4. Experiment
   
5. Modify class diagram
   
6. Refactor
   
7. Write Code
   
8. Rewrite code that depended on the functionality removed from prior class diagram.
9. Goto step 4
   

Prototype Approach

Lets just build a bank account object and code it right now.

Now I can show it to other people and get their inputs.

I show my account to Mary and she interacts with it.
Mary says that she has several accounts and often transfers money between them.

I add the following to my account object.
  TransferFrom(account, value)
  TransferTo(account, value)

I show the new account object to Bill who is a teller.
Bill replies that he needs to see all of the customers transactions
because sometimes he is asked a question about a particular transaction.
Bill adds that if management approves the dispute, he needs to be able to modify a prior transaction.

I add the following to my account object:
  TransactionHistory [[date location amount],[date location amount],[date location amount]]     
  DisplayTransactionHistory()
  AddTransaction(DateTime, Location, Amount)
  AdjustTransaction(DateTime, Location, NewAmount)

Now that I am tracking transactions, I want deposits, withdrawals and transfers to create transactions.
Therefore, I also add the following: 
  Deposit(value) 
  Withdrawal(value)  
  TransferFrom(account, value)
  TransferTo(account, value)

Now I have an awesome account object, but I only have one.
<pre>
I need a way to copy this object so that I can give accounts to all of my friends.
I then add the following
  Clone()
However, I want Clone() to be available to all existing objects.
Instead of delegating from Clone to TransactionAccount,
I am going to delegate from BankAccount to Clone.

I would also like a ToString() for all objects.
But, I do not need a Clone.ToString().
I am going to delegate from BankAccount to ToString.

Clone and Change Technique

Now that I have a clone() method, I can clone an existing object then morph it into a different object.
Given the above example. If I want to create an ATM account.

  ATMAccount = TransferableAccount.Clone()
  def ATMAccount.Pin end
  def ATMAccount.DailyLimit end
  def ATMAccount.LastTransaction end
  def ATMAccount.DailyTotal end

Clone Types

When copying a prototype object, there are different types of copying the existing object.
When using a prototype language, this is usually not a choice, it is implemented by the language.

Deep Copy

A deep copy, duplicates both the copied object and all objects that are delegated to.
In the above example a deep copy of TransferableAccount would make copies of TransferableAccount, BankAccount, Clone, ToString.
The benefit is that all parts may be modified without effecting the original object. The downside is that it consumes more resources.

Shallow Copy

A shallow copy, duplicates only the copied object and delegates to the same objects as the original.
The benefit is that it consumes less resources. The downside is that modification of a delegated object also effects the original object.

Shallow Copy with Intelligence

A hybrid of a deep and shallow copy that gives the benefits of both. As in a shallow copy, clone() duplicates only the copied object and delegates to the same objects as the original.
However when a delegated object is modified, a copy of the object to be modified is performed before the modification, and the delegate is adjusted to point to the copy. Then the copy is modified.

References

[1] Yahoo Online Dictionary - Prototype
[2] Using Prototypical Objects to Implement Shared Behavior in Object Oriented Systems By: Henry Lieberman
Classifying Prototype-Based Programming Languages
Self - The power of Simplicity By: David Ungar and Randall B - 1986
Prototype and Scriptaculous in Action By: Dave Crane; Bear Bibeault; Tom Locke; Thomas Fuchs ISBN-10: 1-933988-03-7