CSC/ECE 517 Summer 2008/wiki1 8 dm

In Lecture 7, we consider prototype-based programming in Ruby. The example that is given is some what artificial. Can you identify real tasks that are easier with prototype-based programming than with class-based programming? Give the code, at least in outline.

Prototype-based Programming

Introduction

As object oriented design becomes more important when designing code, how the objects are designed is becoming a subject increasing scrutiny. There are two major approaches that are commonly implemented. The first is the traditional approach of object-oriented design. Using a starting class that serves as a basis for progressively more complex classes down the line. It could be termed the "Russian Doll" approach. The second approach is prototype-based programming. A prototype class is created with the desired functionality and then simple replicated and extended as needed. It could be termed the "Versioning" approach.

Advantages of Prototype-based Programming vs. Traditional Object-Oriented Programming

Both of these approaches have advantages that play into the nature of design. Traditional programming is a very structured approach which can provide a large scale design with an organized approach. It creates classes that can be reused and it would be structured and extended. If these upper classes need to remain static, this approach will function needed. Any change made to a higher level class will propagate through all class that extend it.

Prototype-based Example

|class LinkNode
| attr_reader :name, :next, :value
|
| def initialize(name, next,value)
|   @name, @next, @value = name, next, value
| end
| by
| def getNext
|   next
| end
|end
|
|node1 = LinkNode.new('Dave',nul,nul)
|node2 = LinkNode.new('John,nul,nul)
|
|module StringNode
|  def isEmptyString?
|    if value == nul
|     true
|    else
|      false 
|    end
|end
|
|node1.extend(StringNode)

As an example this is relatively primitive but it illustrates the basic concept. A linked list has to act as a container for any number of different manners of objects and these will require nodes customized to those objects. You may not be able to account for those objects in your initial design, so being able to add code afterward without compromising the design. As the example shows, you can simply add a customized module to support any needed functionality.

References

1. Taw's Blog
2. Softpanorama
3. Wikipedia Prototype Programming