CSC/ECE 517 Fall 2011/ch1 1g vn: Difference between revisions

From Expertiza_Wiki
Jump to navigation Jump to search
 
(192 intermediate revisions by 2 users not shown)
Line 1: Line 1:
<big>'''Object-Oriented Languages and Scripting'''</big>
__TOC__
==Overview ==
==Overview ==


'''Object Oriented Programming''' is a programming paradigm that uses abstraction to create models based on the real world. It uses several techniques from previously established paradigms, including modularity, polymorphism, and encapsulation. Today, many popular programming languages (such as Java, JavaScript, C#, C++, Python, PHP, Ruby and Objective-C) support object-oriented programming (OOP).
In recent years, object-oriented programming has become especially popular in dynamic programming languages. Python, Ruby and Groovy are dynamic languages built on OOP principles, while Perl and PHP have been adding object-oriented features since Perl 5 and PHP 4, and ColdFusion since version 6. Over time, the scripting landscape has changed dramatically. Perl has added support for object orientation, Python has extended its object-oriented support, and more recently Ruby has made a name for itself as a full-fledged dynamic object-oriented scripting language with significant productivity benefits when compared to Java and C++. Groovy follows the lead of Ruby by offering these dynamic object orientation features. Not only does it enhance
Java by making it scriptable, but it also provides new OO features [http://en.wikipedia.org/wiki/Object-oriented_programming]
 
That scripting has developed in the shadow of object-oriented programming explains part of the problem. The two are not incompatible, but one philosophy has received the most attention. Scripting has been appearing language by language [http://ieeexplore.ieee.org/xpl/freeabs_all.jsp?arnumber=4563874]
 
===Object-Oriented Languages===


Object-oriented programming may be seen as the design of software using a collection of cooperating objects, as opposed to a traditional view in which a program may be seen as a collection of functions, or simply as a list of instructions to the computer. In OOP, each object is capable of receiving messages, processing data, and sending messages to other objects. Each object can be viewed as an independent little machine with a distinct role or responsibility.
Object-oriented programming (OOP) is a programming paradigm using "objects" – data structures consisting of data fields and methods together with their interactions – to design applications and computer programs. Programming techniques may include features such as data abstraction, encapsulation, messaging, modularity, polymorphism, and inheritance. Many modern programming languages now support OOP, at least as an option.


Object-oriented programming is intended to promote greater flexibility and maintainability in programming, and is widely popular in large-scale software engineering. By virtue of its strong emphasis on modularity, object oriented code is intended to be simpler to develop and easier to understand later on, lending itself to more direct analysis, coding, and understanding of complex situations and procedures than less modular programming methods.[https://developer.mozilla.org/En/Introduction_to_Object-Oriented_JavaScript]
[http://en.wikipedia.org/wiki/List_of_object-oriented_programming_languages List of object-oriented programming languages ]


A scripting language, script language or extension language is a programming language that allows control of one or more applications. "Scripts" are distinct from the core code of the application, as they are usually written in a different language and are often created or at least modified by the end-user. Scripts are often interpreted from source code or bytecode, whereas the application is typically first compiled to native machine code.Scripting languages uses a lot of the features of object oriented languages.[http://en.wikipedia.org/wiki/Scripting_language]
===Scripting Languages===


Scripting languages have their roots in the "Job Control" languages (e.g., IBM's OS JCL) that are used on "batch processing" computer systems. JCL commands tell the system to run specified programs, using particular I/O resources (e.g., files and tape drives). The "command languages" found on "time-sharing" systems (e.g., Unix and VMS) add interactive window-dressing, but perform precisely the same functions.
A scripting language, script language or extension language is a programming language that allows control of one or more applications. "Scripts" are distinct from the core code of the application, as they are usually written in a different language and are often created or at least modified by the end-user. Scripts are often interpreted from source code or bytecode, whereas the application is typically first compiled to native machine code. Early script languages were often called batch languages or job control languages. Such early scripting languages were created to shorten the traditional edit-compile-link-run process [http://en.wikipedia.org/wiki/Scripting_language]


In recent years, object-oriented programming has become especially popular in dynamic programming languages. Python, Ruby and Groovy are dynamic languages built on OOP principles, while Perl and PHP have been adding object oriented features since Perl 5 and PHP 4, and ColdFusion since version 6. Over time, the scripting landscape has changed dramatically. Perl has added support for object orientation, Python has extended its object-oriented support, and more recently Ruby has made a name for itself as a full-fledged dynamic object-oriented scripting language with significant productivity benefits when compared to Java and C++. Groovy follows the lead of Ruby by offering these dynamic object orientation features. Not only does it enhance
==Advantages that object-orientation bring to a scripting language==
Java by making it scriptable, but it also provides new OO features.
As object-oriented concepts continue to evolve software development, many of the software needs that are driving the object-oriented movement are the same for scripting languages. Therefore, many of the fundamental concepts of object-oriented languages are advantages for scripting languages. In some languages, object-oriented concepts are present even if one does not directly use them. For example, all variables created in Ruby or Python are references to an object, regardless of whether or not they are treated as one. [http://books.google.com/books/about/Scripting_with_objects.html?id=3lK3OAAACAAJ]


The Document Object Model of HTML, XHTML, and XML documents on the Internet have bindings to the popular JavaScript/ECMAScript language. JavaScript is perhaps the best known prototype-based programming language, which employs cloning from prototypes rather than inheriting from a class. Another scripting language that takes this approach is Lua. Earlier versions of ActionScript (a partial superset of the ECMA-262 R3, otherwise known as ECMAScript) also used a prototype-based object model. Later versions of ActionScript incorporate a combination of classification and prototype-based object models based largely on the currently incomplete ECMA-262 R4 specification, which has its roots in an early JavaScript 2 Proposal. Microsoft's JScript.NET also includes a mash-up of object models based on the same proposal, and is also a superset of the ECMA-262 R3 specification.
A few of the main concepts advantages to scripting are:


==History==
===Objects===
Early mainframe computers (in the 1950s) were non-interactive, instead using batch processing. IBM's Job Control Language (JCL) is the archetype of language used to control batch processing.


The first interactive shells were developed in the 1960s to enable remote operation of the first time-sharing systems, and these used shell scripts, which controlled running computer programs within a computer program, the shell.
[[File:Concepts-object.gif| right| A software object.]]


Languages such as Tcl and Lua were specifically designed as general purpose scripting languages that could be embedded in any application. Other languages such as Visual Basic for Applications (VBA) provided strong integration with the automation facilities of an underlying system. Embedding of such general purpose scripting languages instead of developing a new language for each application also had obvious benefits, relieving the application developer of the need to code a language translator from scratch and allowing the user to apply skills learned elsewhere.
Objects are one of the key concepts in object-oriented design. When trying to understand software objects it is important to realize that they are very similar to real-world objects such as cats, desks, and cars. Real-world objects can be broken down into two fundamental characteristics: state and behavior. For example, a car object has state (color, make, model, year) and behavior (accelerate, brake, change gear).  


Some software incorporates several different scripting languages. Modern web browsers typically provide a language for writing extensions to the browser itself, and several standard embedded languages for controlling the browser, including JavaScript (a dialect of ECMAScript) or XUL.[http://en.wikipedia.org/wiki/Scripting_language]
Software objects, which conceptually are similar to real-world objects, also consist of state and behavior. An objects stores its state in variables and expose its behavior through methods. When combined with scripting languages, they provide the distinct advantage of allowing a programmer to more effectively model real-world objects. [http://download.oracle.com/javase/tutorial/java/concepts/object.html]


Object Oriented features were embedded into scripting language starting with Perl 5.000 released on October 17, 1994. Perl was originally developed by Larry Wall in 1987 as a general-purpose Unix scripting language to make report processing easier. Since then, it has undergone many changes and revisions and become widely popular amongst programmers. Larry Wall continues to oversee development of the core language, and its upcoming version, Perl 6. Perl borrows features from other programming languages including C, shell scripting (sh), AWK, and sed. The language provides powerful text processing facilities without the arbitrary data length limits of many contemporary Unix tools, facilitating easy manipulation of text files. Perl gained widespread popularity in the late 1990s as a CGI scripting language, in part due to its parsing abilities.[http://en.wikipedia.org/wiki/Perl]
<br/><br/>
<b>Image on right is a visual representation of a software object.</b>
<br/><br/><br/><br/>


Another Scripting Language Ruby was conceived on February 24, 1993 by Yukihiro Matsumoto who wished to create a new language that balanced functional programming with imperative programming. Matsumoto has stated, "I wanted a scripting language that was more powerful than Perl, and more object-oriented than Python. That's why I decided to design my own language".
===Classes===


At a Google Tech Talk in 2008 Matsumoto further stated, "I hope to see Ruby help every programmer in the world to be productive, and to enjoy programming, and to be happy. That is the primary purpose of Ruby language."[http://en.wikipedia.org/wiki/Ruby_%28programming_language%29]
A class in object-oriented programming is a construct which is used as a blueprint to create instances of itself. The class objects are also called as instance objects or just objects. A class can have data members or functions which enable its objects to define functionality, behavior and maintain its state. It represents a noun, such as a person, place or (possibly quite abstract) thing, or something nominalized. For example, "Banana" is an instance of the class "Fruit" (a "Fruit" object). It is of the type "Fruit". Programming languages that include classes as a programming construct offer support for various class-related features [http://en.wikipedia.org/wiki/Class_%28computer_programming%29]


==Object Oriented Languages and Features==
===Inheritance===
Another important concept of object-oriented programming is inheritance. Inheritance allows a class to copy all the state and behavior of another class and then modify and extend these attributes to provide a more custom approach for the problem at hand. Any class that extends from another class is called a subclass. The class a subclass inherits from is called the superclass. The two major types of inheritance are single and multiple inheritance.


Benjamin C. Pierce and some other researchers view as futile any attempt to distill OOP to a minimal set of features. He nonetheless identifies fundamental features that support the OOP programming style in most object-oriented languages:
<b>Single Inheritance</b><br/>
Single inheritance is when a subclass only inherits from a single base class.


===Dynamic dispatch===
Example [http://www.inf.ufsc.br/poo/smalltalk/ibm/tutorial/oop.html]:
When a method is invoked on an object, the object itself determines what code gets executed by looking up the method at run time in a table associated with the object. This feature distinguishes an object from an abstract data type (or module), which has a fixed (static) implementation of the operations for all instances. It is a programming methodology that gives modular component development while at the same time being very efficient.
<pre>
class Student {
String name;
String address;
int age;
float gpa;
}


===Encapsulation===
class Undergraduate extends Student {
Data encapsulation, sometimes referred to as data hiding, is the mechanism whereby the implementation details of a class are kept hidden from the user. The user can only perform a restricted set of operations on the hidden members of the class by executing special functions commonly called methods. The actions performed by the methods are determined by the designer of the class, who must be careful not to make the methods either overly flexible or too restrictive. This idea of hiding the details away from the user and providing a restricted, clearly defined interface is the underlying theme behind the concept of an abstract data type.
String year; // Freshman, Sophomore, Junior, or Senior
}


The advantage of using data encapsulation comes when the implementation of the class changes but the interface remains the same. For example, to create a stack class which can contain integers, the designer may choose to implement it with an array, which is hidden from the user of the class. The designer then writes the push() and pop() methods which puts integers into the array and removes them from the array respectively. These methods are made accessible to the user. Should an attempt be made by the user to access the array directly, a compile time error will result. Now, should the designer decide to change the stack's implementation to a linked list, the array can simply be replaced with a linked list and the push() and pop() methods rewritten so that they manipulate the linked list instead of the array. The code which the user has written to manipulate the stack is still valid because it was not given direct access to the array to begin with.
class Graduate extends Student {
String program;  // Either graduate or PhD
}
</pre>


The concept of data encapsulation is supported in C++ through the use of the public, protected and private keywords which are placed in the declaration of the class. Anything in the class placed after the public keyword is accessible to all the users of the class; elements placed after the protected keyword are accessible only to the methods of the class or classes derived from that class; elements placed after the private keyword are accessible only to the methods of the class.
Both a Graduate class and Undergraduate class have similar behavior such as managing a name, an address, a major, and a GPA. Rather than put this behavior in both of these classes, the behavior is placed in a new class called Student. Both Graduate and Undergraduate become subclass of the Student class, and both inherit the Student behavior.
Both Graduate and Undergraduate classes can then add additional behavior that is unique to them. For example, Graduate can be either Master's program or PhD program. On the other hand, the  
Undergraduate class might want to keep track of either the student is Freshman, Sophomore, Junior or Senior.  


As a convention, calling a method of an object instantiated from a class is commonly referred to as sending a message to that object.
<b>Multiple Inheritance</b><br/>
Multiple inheritance is when a subclass inherits from multiple base classes.


An example of encapsulation in Ruby is as shown below.In this code, you cannot mess around with the state of its variable @value. The only way you can access it is through get & set method (get_value, set_value). This is the encapsulation
Example [http://www.java-samples.com/showtutorial.php?tutorialid=462]:
<pre>
<pre>
class Encapsulation
class Horse {
    def get_value
public:
        @value
Horse() { cout << "Horse constructor... "; }
    end
virtual ~Horse() { cout << "Horse destructor... "; }
virtual void Whinny() const { cout << "Whinny!... "; }
    def set_value value
private:
        @value = value
int itsAge;
        return nil
};
    end
 
end
class Bird {
public:
encapsulation = Encapsulation.new
Bird() { cout << "Bird constructor... "; }
encapsulation.set_value(15)
virtual ~Bird() { cout << "Bird destructor... "; }
puts encapsulation.get_value
virtual void Chirp() const { cout << "Chirp... ";  }
virtual void Fly() const {
cout << "I can fly! I can fly! I can fly! ";
}
private:
int itsWeight;
};
 
class Pegasus : public Horse, public Bird {
public:
void Chirp() const { Whinny(); }
Pegasus() { cout << "Pegasus constructor... "; }
~Pegasus() { cout << "Pegasus destructor...  "; }
};
</pre>
</pre>


===Object inheritance===
Pegasus, which is a horse that can fly, inherits from both the Horse and the Bird classes. However, since Pegasus cannot chirp, the inherited Chirp function from the Bird class is overwritten with the Whinny function.
In object-oriented programming (OOP), inheritance is a way to compartmentalize and reuse code by creating collections of attributes and behaviors called objects that can be based on previously created objects. In classical inheritance where objects are defined by classes, classes can inherit other classes. The new classes, known as subclasses (or derived classes), inherit attributes and behavior (i.e. previously coded algorithms) of the pre-existing classes, which are referred to as superclasses, ancestor classes or base classes. The inheritance relationships of classes gives rise to a hierarchy. In prototype-based programming, objects can be defined directly from other objects without the need to define any classes, in which case this feature is called differential inheritance.
 
===Polymorphism===
Polymorphism, from the perspective of object-oriented languages, is the ability for functions and objects to have many forms. It is a very powerful tool that allows programmers to separate the interface from the implementation.
 
Consider the following example [http://www3.ntu.edu.sg/home/ehchua/programming/java/J3b_OOPInheritancePolymorphism.html]:
 
[[File:OOP_PolymorphismShape.png| left| Polymorphism Example.]]
 
<br/><br/><br/><br/><br/><br/><br/><br/>
<br/><br/><br/><br/><br/><br/><br/><br/><br/>
 
Suppose that our application uses many types of shapes, such as rectangles, and triangles. We can create a base Shape class that defines the public interface for all of the different types of shapes. In this case, we want all shapes to have a getArea() method.
 
Here is one possible implementation of the Shape class:


An example of inheritance in Ruby.In Ruby, a class can only inherit from a single other class. Some other languages support multiple inheritance, a feature that allows classes to inherit features from multiple classes, but Ruby doesn't support this.
<pre>
<pre>
    class Mammal 
public class Shape {
      def breathe 
  private String color;
        puts "inhale and exhale" 
 
       end 
  public Shape (String color) {
    end 
       this.color = color;
     
  }
    class Cat < Mammal 
 
       def speak 
  // All shapes must has a method called getArea()
        puts "Meow"
  public double getArea() {
       end 
       System.err.println("Shape unknown! Cannot compute area!");
    end 
       return 0;  // Need a return to compile the program
        
  }
    rani = Cat.new 
 
    rani.breathe 
  public String toString() {
    rani.speak 
       return "Shape of color=\"" + color + "\"";
  }
}
</pre>
</pre>


===Open recursion===
Since the Shape class does not know what type of shape it is dealing with, it just prints out an error message when its getArea() method is called.
A special variable (syntactically it may be a keyword), usually called this or self, that allows a method body to invoke another method body of the same object. This variable is late-bound; it allows a method defined in one class to invoke another method that is defined later, in some subclass thereof.


===Classes of objects===
Now deriving the Rectangle and Triangle subclasses:
A class is a blueprint or prototype from which objects are created. This section defines a class that models the state and behavior of a real-world object. It intentionally focuses on the basics, showing how even a simple class can cleanly model state and behavior.
<pre>
 
public class Rectangle extends Shape {
===Instances of classes===
  private int length;
  private int width;
 
  public Rectangle(String color, int length, int width) {
      super(color);
      this.length = length;
      this.width = width;
  }
 
  @Override
  public String toString() {
      return "Rectangle of length=" + length + " and width=" + width + ", subclass of " + super.toString();
  }
 
  @Override
  public double getArea() {
      return length*width;
  }
}
</pre>
<pre>
<pre>
public class Bicycle{
public class Triangle extends Shape {
  private int base;
    private int cadence;
  private int height;
    private int gear;
 
    private int speed;
  public Triangle(String color, int base, int height) {
      super(color);
    // add an instance variable for the object ID
      this.base = base;
    private int id;
      this.height = height;
   
  }
    // add a class variable for the number of Bicycle objects instantiated
 
    private static int numberOfBicycles = 0;
  @Override
......
  public String toString() {
      return "Triangle of base=" + base + " and height=" + height + ", subclass of " + super.toString();
  }
 
  @Override
  public double getArea() {
      return 0.5*base*height;
  }
}
}
</pre>
</pre>
When a number of objects are created from the same class blueprint, they each have their own distinct copies of instance variables. In the case of the Bicycle class, the instance variables are cadence, gear, and speed. Each Bicycle object has its own values for these variables, stored in different memory locations.[http://download.oracle.com/javase/tutorial/java/javaOO/classvars.html]


===Methods===
Therefore, due to polymorphism, all the shape subclasses will compute their area based on their corresponding area formula. All Rectangle objects will compute their area as length * width, while all Triangle objects will use 0.5 * base * height.
In object-oriented programming, a method is a subroutine (or procedure or function) associated with a class. Methods define the behavior to be exhibited by instances of the associated class at program run time. Methods have the special property that at runtime, they have access to data stored in an instance of the class (or class instance or class object or object) they are associated with and are thereby able to control the state of the instance.[1] The association between class and method is called binding. A method associated with a class is said to be bound to the class. Methods can be bound to a class at compile time (static binding) or to an object at runtime (dynamic binding).[http://en.wikipedia.org/wiki/Method_%28computer_programming%29]
 
===Encapsulation===
Encapsulation, which is most often achieved through information hiding, allows a programmer to hide the implementation details of an object. Only state and behavior of an object that are designated as public can be viewed from outside its scope. This provides an important advantage to scripting languages by preventing objects from accidentally modifying attributes in another object that may be vital to the scripts functionality.


Examples of writing method in Ruby is as shown below.[http://rubylearning.com/satishtalim/writing_own_ruby_methods.html]
In most programming languages, the common levels of access to an object are:
*Public : All objects can access it.
*Protected : Access is limited to members of the same class or subclass.
*Private : Access is limited to members of the same class. [http://books.google.com/books/about/Object_oriented_analysis_and_design_with.html?id=3NQgAQAAIAAJ]
 
===Code Reuse===
Object-oriented design promotes code reuse by allowing programmers to take preexisting classes and integrating them into new scripts. This helps to improve readability of the code as well as promoting the "Don't Repeat Yourself" principle, which aims at reducing repetition of information. [http://www.artima.com/intv/dry.html]
 
==Advantages that scripting capability bring to an object-oriented language==
Scripting provides a few advantages to object-oriented languages:
 
===Interpreted Code===
One of the main differences between scripting languages and system programming languages is that the scripting languages are interpreted whereas system programming languages are mostly compiled. Being an interpreted language, scripting languages make applications flexible, provide rapid turnaround while in development, eliminates compile time errors, and  allows for code generation on the fly [http://www.tcl.tk/doc/scripting.html].
 
===Dynamic Typing===
Scripting languages were originally designed to serve as tools for automating repetitive tasks such as rotating a system log. In order to permit easy interfacing between components, a script language must be as typeless as possible. In strongly typed languages, extra code may be required in order to allow to components to communicate. This dynamic typing provides a distinct advantage that eventually made its way into popular programming languages such as Python and Ruby [http://books.google.com/books/about/Scripting_with_objects.html?id=3lK3OAAACAAJ].
 
===Glue Code===
While not contributing any additional functionality to a program, glue code allows a programmer to connect two different pieces of existing code that were not designed to work together.
[http://www.site.uottawa.ca:4321/oose/index.html#gluecode]
 
==Are there any advantages to a scripting language that is not object-oriented?==
 
The only advantage to a scripting language that is not object-oriented is that it makes it a little easier if the language used for a particular project doesn’t require much complexity and OOP features don’t really make a difference. There are many non-object-oriented scripting languages in use, or scripting languages that have "object extensions" that often go unused like Perl, PHP, and various UNIX shells.
 
All these languages enable one to write small programs very quickly and efficiently without any complexity of OOP features. Perl was not originally designed or implemented as an object-oriented language. Its version of object-orientation is simple and well integrated, but not fundamental to the language. In a larger system, an object-oriented implementation of a system in Perl will almost never be faster than the equivalent non-object-oriented implementation [http://www.manning.com/conway/excerpt_preface.html]
 
Tcl also did not originally support object-oriented (OO) syntax before 8.6, so OO functionality was provided by extension packages, such as [http://en.wikipedia.org/wiki/Incr_Tcl incr Tcl] and [http://en.wikipedia.org/wiki/XOTcl XOTcl]. Tcl is more suited at OO in the large than OO in the small. Fine-grained "an int is an object" OO would not fit well in Tcl. Everything is a string, after all [http://equi4.com/moam/strength.html]
 
[http://www.toves.org/books/php/ch03-first/index.html A non-object-oriented PHP program ]
<pre>
<pre>
def hello 
<html>
  'Hello' 
<head><title>Random</title></head>
end 
<body>
#use the method 
<p>I have randomly selected the number
puts hello 
<?php $choice=rand(1,100); echo $choice;?>.
 
Its square root is <?php echo sqrt($choice);?>.</p>
# Method with an argument - 1
</body>
def hello1(name)
</html>
  'Hello ' + name 
end 
puts(hello1('satish')
 
# Method with an argument - 2 
def hello2 name2 
  'Hello ' + name2 
end 
puts(hello2 'talim')
</pre>
</pre>


===Polymorphism===
==Is scripting essentially synonymous with dynamic typing?==


===Abstraction===
[[File:DegreeofTyping.jpg |right]]
The conjunction of complex inheritance, methods, properties of an Object must be able to simulate a reality model.
Scripting languages are dynamically typed, usually interpreted, and very high-level for e.g. Perl, Tcl, Python, Rexx, Visual Basic). Because of dynamic typing and interpretation they are very flexible and encourage experimentation [http://books.google.com/books/about/The_world_of_scripting_languages.html?id=ZpFQAAAAMAAJ]


==Object Oriented Scripting Languages==
The figure on the right shows a comparison of various programming languages based on their level (higher level language execute more machine instructions for each language statement) and their degree of typing. System programming languages like C tend to be strongly typed and medium level (5-10 instructions/statement). Scripting language like Tcl tend to be weakly typed and very high level (100-1000 instructions/statement) [http://www.tcl.tk/doc/scripting.html#921216]
Few of the Object Oriented Scripting languages:
Objects in scripting languages tend to be typeless. To enable easy interfacing between the components that are combined together in a script.  In a typeless environment, the output of one can be taken as a generic system of bytes and accepted by the receiving component just on that basis. Or, as is more commonly the case with scripting languages because string processing is main focus of such languages, the components can be assumed to produce characters at their outputs and to accept character streams at their inputs.
 
Perl is known as one of "the three Ps" (along with Python and PHP), the most popular dynamic languages for writing Web applications. Python is dynamically typed, so there is no need for variable declarations. This reduces the amount of code that students have to write and also eliminates common errors stemming from misunderstanding the subtle distinctions of declaration, definition and use
[http://www.jython.org/docs/tutorial/indexprogress.html] Ruby also features dynamic typing.
<br>
[http://www.dreamincode.net/forums/topic/179748-dynamic-typing/ The following program shows power and simplicity of dynamic typing in Ruby]
<pre>
class Class
    def attr_reader2(*vars)
        vars.each do |symbol|
            define_method(symbol) { instance_variable_get "@#{symbol}" }
        end
    end
    def attr_writer2(*vars)
        vars.each do |symbol|
            define_method("#{symbol}=") { |value| instance_variable_set("@#{symbol}", value) }
        end
    end
    def attr_accessor2(*vars)
        attr_reader2(*vars)
        attr_writer2(*vars)
    end
end
</pre>


==Object-Oriented Scripting Languages==
=== AppleScript===
=== AppleScript===
[http://developer.apple.com/library/mac/#documentation/AppleScript/Conceptual/AppleScriptX/Concepts/ScriptingOnOSX.html%23//apple_ref/doc/uid/20000032-BABEBGCF AppleScript] is a scripting language that provides direct control of scriptable applications and scriptable parts of the Mac OS. AppleScript scripting language uses an English-like terminology which may appear simple, it is a rich, object-oriented language, capable of performing complicated programming tasks. It has the concepts of classes and objects. It’s not as obvious that AppleScript also supports some fundamental OOPfeatures such as inheritance, instantiation, data encapsulation, and polymorphism.
[http://developer.apple.com/library/mac/#documentation/AppleScript/Conceptual/AppleScriptX/Concepts/ScriptingOnOSX.html%23//apple_ref/doc/uid/20000032-BABEBGCF AppleScript] is a scripting language created by Apple Inc., through which scriptable applications and parts of Mac OS can be controlled directly. AppleScript scripting language appears to be a simple language but it is a very rich, object-oriented language, capable of performing complex programming tasks. It has the concept of classes and objects. It is basically an inter-application processing system, intended to exchange data between different applications and control them to automate recurring tasks.
<br>
[http://developer.apple.com/library/mac/#documentation/AppleScript/Conceptual/AppleScriptLangGuide/conceptual/ASLR_fundamentals.html#//apple_ref/doc/uid/TP40000983-CH218-SW2 Example of a simple script with one property, one handler, one nested script object, and an implicit run handler with two statements]
<pre>
property defaultClientName : "Mary Smith"
on greetClient(nameOfClient)
    display dialog ("Hello " & nameOfClient & "!")
end greetClient
script testGreet
    greetClient(defaultClientName)
end script
run testGreet --result: "Hello Mary Smith!"
greetClient("Joe Jones") --result: "Hello Joe Jones!"
</pre>


===Curl===
===Curl===
[http://en.wikipedia.org/wiki/Curl_(programming_language) Curl] is a reflective object-oriented programming language for interactive web applications which goal is to provide a smoother transition between formatting and programming. It makes it possible to embed complex objects in simple documents without needing to switch between programming languages or development platforms. Curl is a markup language like HTML—that is, plain text is shown as text; at the same time, Curl includes an object-oriented programming language that supports multiple inheritance.
[http://en.wikipedia.org/wiki/Curl_(programming_language) Curl] is a reflective object-oriented programming language for interactive web applications whose goal is to provide a effortless transition between formatting and programming. Curl is a markup language like and also includes an object-oriented programming language that supports multiple inheritance.
 
A modern web document, which comprises of different building blocks mostly requires various kinds of methods of implementation: different languages, different tools, different frameworks and sometimes completely different teams. The biggest problem has been getting all of these blocks to communicate with each other in a consistent manner. Curl attempts to side step these problems by providing a consistent syntactic and semantic interface at all levels of web content creation: from simple HTML to complex object-oriented programming.
Curl combines text markup (as in HTML), scripting (as in JavaScript), and heavy-duty computing (as in Java, C#, or C++) within one common framework. It is used in a range of internal enterprise, B2B, and B2C applications.
<br>
[http://curl.com/products/prod/language/#op Java-Like Object Oriented Programming]
<pre>
{curl 6.0 applet}
{curl-file-attributes character-encoding = "shift-j is"}
{define-class public Foo
{method public {hello}:void
  {popup-message "Hello!"}
}
{define-class public Bar {inherits Foo}
  {method public {hello}:void
    {popup-message "Hello World!"}
}
{ do
  let foo:Foo = {Bar}
  {foo.hello}
}
</pre>


===Groovy===
===Groovy===
[http://en.wikipedia.org/wiki/Groovy_(programming_language) Groovy] is an object-oriented programming language for the Java platform. It is a dynamic language with features similar to those of Python, Ruby, Perl, and Smalltalk. It can be used as a scripting language for the Java Platform.
[http://en.wikipedia.org/wiki/Groovy_(programming_language) Groovy] is an object-oriented programming scripting  language for the Java platform. It is a dynamic language with features similar to those of Python, Ruby, Perl, and Smalltalk. It makes writing shell and build scripts easy with its powerful processing primitives, OO abilities and an Ant DSL. It makes testing simpler by supporting unit testing and mocking out-of-the-box. It seamlessly integrates with all existing Java classes and libraries.
Groovy uses a Java-like bracket syntax. It is dynamically compiled to Java Virtual Machine (JVM) bytecode and interoperates with other Java code and libraries.
<pre>
class Greet {
  def name
  Greet(who) { name = who[0].toUpperCase() +
                      who[1..-1] }
  def salute() { println "Hello $name!" }
}
 
g = new Greet('world')  // create object
g.salute()              // Output "Hello World!"
</pre>


===JavaScript===
===JavaScript===
[http://en.wikipedia.org/wiki/JavaScript JavaScript] is a prototype-based scripting language that is dynamic, weakly typed and has first-class functions. It is a multi-paradigm language, supporting object-oriented, imperative, and functional programming styles. It can support OOP because it supports inheritance through prototyping as well as properties and methods. Many developers cast off JS as a suitable OOP language because they are so used to the class style of C# and Java. Many people don't realize that JavaScript supports inheritance. When you write object-oriented code it instantly gives you power; you can write code that can be re-used and that is encapsulated.
[http://en.wikipedia.org/wiki/JavaScript JavaScript], also known as Mocha, LiveScript, JScript, and ECMAScript, is one of the world's most popular programming languages. It is a class-free, object-oriented language, and uses prototypal inheritance instead of classical inheritance.
 
It is a prototype-based scripting language, which is dynamic, weakly typed, and has first-class functions. It is a multi-paradigm language, which supports object-oriented, imperative, and functional programming styles. It supports OOP because it supports inheritance through prototyping as well as properties and methods. Many developers cast off JS as a suitable OOP language because they are so used to the class style of C# and Java. The primary use of JavaScript is to write functions that are embedded in or included from HTML pages and that interact with the Document Object Model (DOM) of the page.
===Lua===
JavaScript is an excellent language to write object oriented web applications. It can support OOP because it supports Encapsulation, Polymorphism and inheritance through prototyping as well as properties and methods [http://mckoss.com/jscript/object.htm]
[http://www.lua.org/ Lua] is a powerful, fast, lightweight, embeddable scripting language. Lua combines simple procedural syntax with powerful data description constructs based on associative arrays and extensible semantics. Lua is dynamically typed, runs by interpreting bytecode for a register-based virtual machine, and has automatic memory management with incremental garbage collection, making it ideal for configuration, scripting, and rapid prototyping.
<pre>
function A()
{
    var x = 7;
    this.GetX = function() { return x;}
    this.SetX = function(xT) { x = xT; }
}
obj = new A;
obj2 = new A;
document.write(obj.GetX() + ' ' + obj2.GetX());
obj.SetX(14);
document.write(' ' + obj.GetX() + ' ' + obj2.GetX());
</pre>


===Object Rexx===
===Object Rexx===
[http://en.wikipedia.org/wiki/Object_REXX Object REXX] programming language is an object-oriented scripting language initially produced by IBM for OS/2. It is a follow-on to and a significant extension of the "Classic Rexx" language originally created for the CMS component of VM/SP and later ported to MVS,[1] OS/2 and PC DOS. Open Object Rexx includes features typical of an object-oriented language, such as subclassing, polymorphism, and data encapsulation. It is an extension of the classic Rexx language, which has been expanded to include classes (a base set of classes is supplied), objects, and methods.
[http://en.wikipedia.org/wiki/Object_REXX Object REXX] programming language is an object-oriented scripting language initially produced by IBM for OS/2. As an object-oriented language, Rexx provides data encapsulation, polymorphism, an object class hierarchy, class-based inheritance of methods, and concurrency[http://www.oorexx.org/docs/rexxref/c188.htm] It includes a number of useful base classes and allows you create new object classes of your own.
<br>
[http://www.kilowattsoftware.com/tutorial/rexx/Structure.htm factorialProgram.rex] -- computes the factorial of a number
<pre>
  arg N .
  call factorial N
  say result
  exit 0 /* don't fall through to the PROCEDURE instruction */
  factorial : PROCEDURE
  n = arg( 1 )
  if n  = 1 then
    return 1
  return n * factorial( n - 1 )
</pre>


===Perl===
===Perl 5===
[http://www.perl.org/ Perl] is a high-level, general-purpose, interpreted, dynamic programming language. Perl was originally developed by Larry Wall in 1987 as a general-purpose Unix scripting language to make report processing easier. There are three main terms, explained from the point of view of how Perl handles objects. The terms are object, class, and method.
[http://www.perl.org/ Perl] is a high-level, general-purpose, interpreted, dynamic programming language. Perl was originally developed by Larry Wall in 1987 as a general-purpose Unix scripting language to make report processing easier. There are three main terms, explained from the point of view of how Perl handles objects. The terms are object, class, and method.
*Within Perl, an object is merely a reference to a data type that knows what class it belongs to. The object is stored as a reference in a scalar variable.  
*Within Perl, an object is merely a reference to a data type that knows what class it belongs to. The object is stored as a reference in a scalar variable.  
Line 167: Line 362:
*A method within Perl is a subroutine, defined with the package. The first argument to the method is an object reference or a package name, depending on whether the method affects the current object or the class.
*A method within Perl is a subroutine, defined with the package. The first argument to the method is an object reference or a package name, depending on whether the method affects the current object or the class.
Perl provides a bless() function which is used to return a reference and which becomes an object. Perl has a special variable, @ISA which governs (method) inheritance.
Perl provides a bless() function which is used to return a reference and which becomes an object. Perl has a special variable, @ISA which governs (method) inheritance.
<br>
[http://perldoc.perl.org/perlboot.html#Inheriting-the-constructor Inheritance in Perl 5]
<pre>
    { package Animal;
    sub speak {
      my $class = shift;
      print "a $class goes ", $class->sound, "!\n";
    }
    sub name {
      my $self = shift;
      $$self;
    }
    sub named {
      my $class = shift;
      my $name = shift;
      bless \$name, $class;
    }
  }
  { package Horse;
    @ISA = qw(Animal);
    sub sound { "neigh" }
  }
</pre>


===PHP===
===PHP===
[http://www.php.net/ PHP] is a widely-used general-purpose scripting language that is especially suited for Web development and can be embedded into HTML. Basic object-oriented programming functionality was added in PHP 3 and improved in PHP 4.[6] Object handling was completely rewritten for PHP 5, expanding the feature set and enhancing performance.[68] In previous versions of PHP, objects were handled like value types.[68] The drawback of this method was that the whole object was copied when a variable was assigned or passed as a parameter to a method. In the new approach, objects are referenced by handle, and not by value. PHP 5 introduced private and protected member variables and methods, along with abstract classes and final classes as well as abstract methods and final methods. It also introduced a standard way of declaring constructors and destructors, similar to that of other object-oriented languages such as C++, and a standard exception handling model. Furthermore, PHP 5 added interfaces and allowed for multiple interfaces to be implemented. There are special interfaces that allow objects to interact with the runtime system. Objects implementing ArrayAccess can be used with array syntax and objects implementing Iterator or IteratorAggregate can be used with the foreach language construct. There is no virtual table feature in the engine, so static variables are bound with a name instead of a reference at compile time.[69]
[http://www.php.net/ PHP] is a widely-used general-purpose scripting language that is especially suited for Web development and can be embedded into HTML. Basic object-oriented programming functionality was added in PHP 3 and improved in PHP 4. Object handling was completely rewritten for PHP 5, expanding the feature set and enhancing performance. PHP 5 introduced private and protected member variables and methods, along with abstract classes and final classes as well as abstract methods and final methods. It also introduced a standard way of declaring constructors and destructors, similar to that of other object-oriented languages such as C++, and a standard exception handling model. Furthermore, PHP 5 added interfaces and allowed for multiple interfaces to be implemented. There are special interfaces that allow objects to interact with the runtime system. Objects implementing ArrayAccess can be used with array syntax and objects implementing Iterator or IteratorAggregate can be used with the foreach language construct. There is no virtual table feature in the engine, so static variables are bound with a name instead of a reference at compile time.
 
<pre>  
<pre>  
class Person {
class Person {
Line 191: Line 408:


===Python===
===Python===
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a remarkably powerful dynamic programming language that is used in a wide variety of application domains. Python is often compared to Tcl, Perl, Ruby, Scheme or Java. Python is a general-purpose, high-level programming language[5] whose design philosophy emphasizes code readability.[6] The class statement, which executes a block of code and attaches its local namespace to a class, for use in object-oriented programming. Python allows programmers to define their own types using classes, which are most often used for object-oriented programming.
[http://en.wikipedia.org/wiki/Python_(programming_language) Python] is a remarkably powerful dynamic programming language that is used in a wide variety of application domains. Python is often compared to Tcl, Perl, Ruby, Scheme or Java. Python is a general-purpose, high-level programming language whose design philosophy emphasizes code readability. The class statement, which executes a block of code and attaches its local namespace to a class, for use in object-oriented programming. Python allows programmers to define their own types using classes, which are most often used for object-oriented programming.
<br>
[http://docs.python.org/tutorial/classes.html An object oriented program in Python]
<pre>
# Function defined outside the class
def f1(self, x, y):
    return min(x, x+y)
 
class C:
    f = f1
    def g(self):
        return 'hello world'
    h = g
</pre>


===Ruby===
===Ruby===
[http://www.ruby-lang.org/en/ Ruby] is a dynamic, reflective, general-purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features. Matsumoto has stated, "I wanted a scripting language that was more powerful than Perl, and more object-oriented than Python. That's why I decided to design my own language".[9] Ruby is object-oriented: every data type is an object, including classes and types that many other languages designate as primitives (such as integers, booleans, and "nil"). Variables always hold references to objects. Every function is a method and methods are always called on an object. Methods defined at the top level scope become members of the Object class. Since this class is an ancestor of every other class, such methods can be called on any object. They are also visible in all scopes, effectively serving as "global" procedures. Ruby supports inheritance with dynamic dispatch, mixins and singleton methods (belonging to, and defined for, a single instance rather than being defined on the class). Though Ruby does not support multiple inheritance, classes can import modules as mixins.
[http://www.ruby-lang.org/en/ Ruby] is a dynamic, reflective, general-purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features. Matsumoto has stated, "I wanted a scripting language that was more powerful than Perl, and more object-oriented than Python. That's why I decided to design my own language" Ruby is object-oriented: every data type is an object, including classes and types that many other languages designate as primitives (such as integers, booleans, and "nil"). Variables always hold references to objects. Every function is a method and methods are always called on an object. Methods defined at the top level scope become members of the Object class. Since this class is an ancestor of every other class, such methods can be called on any object. They are also visible in all scopes, effectively serving as "global" procedures. Ruby supports inheritance with dynamic dispatch, mixins and singleton methods (belonging to, and defined for, a single instance rather than being defined on the class). Though Ruby does not support multiple inheritance, classes can import modules as mixins.
<pre>
<pre>
class Person
class Person
Line 219: Line 449:


===Tcl-Tk===
===Tcl-Tk===
[http://en.wikipedia.org/wiki/Tcl Tcl] (originally from "Tool Command Language", but conventionally rendered as "Tcl" rather than "TCL"; pronounced as "tickle" or "tee-see-ell"[3]) is a scripting language created by John Ousterhout.[4]  It is commonly used for rapid prototyping, scripted applications, GUIs and testing. Tcl is used on embedded systems platforms, both in its full form and in several other small-footprinted versions.
[http://en.wikipedia.org/wiki/Tcl Tcl] originally from "Tool Command Language" is a scripting language created by John Ousterhout. It is commonly used for rapid prototyping, scripted applications, GUIs and testing. Tcl is used on embedded systems platforms, both in its full form and in several other small-footprinted versions. Tcl 8.6 provides an OO system in Tcl core [http://www.tcl.tk/man/tcl8.6/TclCmd/class.htm#M13]
The combination of Tcl and the Tk GUI toolkit is referred to as Tcl/Tk.
The combination of Tcl and the Tk GUI toolkit is referred to as Tcl/Tk.
<pre>
<pre>
Line 255: Line 485:
</pre>
</pre>


==Conclusion==
==References==


==References==
1. Object-oriented programming http://en.wikipedia.org/wiki/Object-oriented_programming
[1]https://developer.mozilla.org/En/Introduction_to_Object-Oriented_JavaScript
<br>
2. Loui, R. (2008). In Praise of Scripting: Real Programming Pragmatism , IEEE Computer, vol. 41, no. 7.
<br>
3. Scripting Language http://en.wikipedia.org/wiki/Scripting_language
<br>
4, 13. Kak, A. C. (2008). Scripting With Objects. Hoboken, NJ: John Wiley & Sons.
<br>
5. What is an Object? http://download.oracle.com/javase/tutorial/java/concepts/object.html
<br>
6. Classes http://en.wikipedia.org/wiki/Class_%28computer_programming%29
<br>
7. Single Inheritance http://www.inf.ufsc.br/poo/smalltalk/ibm/tutorial/oop.html
<br>
8. Multiple Inheritance http://www.java-samples.com/showtutorial.php?tutorialid=462
<br>
9. Polymorphism http://www3.ntu.edu.sg/home/ehchua/programming/java/J3b_OOPInheritancePolymorphism.html
<br>
10. Booch, G., Maksimchuk, R. A., Engle, M. W., Young, B. J., Conallen, J., & Houston, K. A. (2007). Object-Oriented Analysis and Design With Applications, Third Edition. Upper Saddle River, NJ: Addison-Wesley.
<br>
11. Don't Repeat Yourself http://www.artima.com/intv/dry.html
<br>
12, 18. Scripting http://www.tcl.tk/doc/scripting.html
<br>
14. Glue Code http://www.site.uottawa.ca:4321/oose/index.html#gluecode
<br>
15. What object-oriented Perl isn't http://www.manning.com/conway/excerpt_preface.html
<br>
16. The strength on Tcl http://equi4.com/moam/strength.html
<br>
17. Barron, D., & Barron, W. D. (2000). The world of scripting languages (August 2000 ed.). NY: John Wiley & Sons
<br>
19. The Jython Tutorial http://www.jython.org/docs/tutorial/indexprogress.html
<br>
20. Object Oriented Programming in JavaScript http://mckoss.com/jscript/object.htm
<br>
21. Open Object Rexx http://www.oorexx.org/docs/rexxref/c188.htm
<br>
22. Tcl Core http://www.tcl.tk/man/tcl8.6/TclCmd/class.htm#M13

Latest revision as of 03:15, 26 September 2011

Object-Oriented Languages and Scripting

Overview

In recent years, object-oriented programming has become especially popular in dynamic programming languages. Python, Ruby and Groovy are dynamic languages built on OOP principles, while Perl and PHP have been adding object-oriented features since Perl 5 and PHP 4, and ColdFusion since version 6. Over time, the scripting landscape has changed dramatically. Perl has added support for object orientation, Python has extended its object-oriented support, and more recently Ruby has made a name for itself as a full-fledged dynamic object-oriented scripting language with significant productivity benefits when compared to Java and C++. Groovy follows the lead of Ruby by offering these dynamic object orientation features. Not only does it enhance Java by making it scriptable, but it also provides new OO features [1]

That scripting has developed in the shadow of object-oriented programming explains part of the problem. The two are not incompatible, but one philosophy has received the most attention. Scripting has been appearing language by language [2]

Object-Oriented Languages

Object-oriented programming (OOP) is a programming paradigm using "objects" – data structures consisting of data fields and methods together with their interactions – to design applications and computer programs. Programming techniques may include features such as data abstraction, encapsulation, messaging, modularity, polymorphism, and inheritance. Many modern programming languages now support OOP, at least as an option.

List of object-oriented programming languages

Scripting Languages

A scripting language, script language or extension language is a programming language that allows control of one or more applications. "Scripts" are distinct from the core code of the application, as they are usually written in a different language and are often created or at least modified by the end-user. Scripts are often interpreted from source code or bytecode, whereas the application is typically first compiled to native machine code. Early script languages were often called batch languages or job control languages. Such early scripting languages were created to shorten the traditional edit-compile-link-run process [3]

Advantages that object-orientation bring to a scripting language

As object-oriented concepts continue to evolve software development, many of the software needs that are driving the object-oriented movement are the same for scripting languages. Therefore, many of the fundamental concepts of object-oriented languages are advantages for scripting languages. In some languages, object-oriented concepts are present even if one does not directly use them. For example, all variables created in Ruby or Python are references to an object, regardless of whether or not they are treated as one. [4]

A few of the main concepts advantages to scripting are:

Objects

A software object.
A software object.

Objects are one of the key concepts in object-oriented design. When trying to understand software objects it is important to realize that they are very similar to real-world objects such as cats, desks, and cars. Real-world objects can be broken down into two fundamental characteristics: state and behavior. For example, a car object has state (color, make, model, year) and behavior (accelerate, brake, change gear).

Software objects, which conceptually are similar to real-world objects, also consist of state and behavior. An objects stores its state in variables and expose its behavior through methods. When combined with scripting languages, they provide the distinct advantage of allowing a programmer to more effectively model real-world objects. [5]



Image on right is a visual representation of a software object.



Classes

A class in object-oriented programming is a construct which is used as a blueprint to create instances of itself. The class objects are also called as instance objects or just objects. A class can have data members or functions which enable its objects to define functionality, behavior and maintain its state. It represents a noun, such as a person, place or (possibly quite abstract) thing, or something nominalized. For example, "Banana" is an instance of the class "Fruit" (a "Fruit" object). It is of the type "Fruit". Programming languages that include classes as a programming construct offer support for various class-related features [6]

Inheritance

Another important concept of object-oriented programming is inheritance. Inheritance allows a class to copy all the state and behavior of another class and then modify and extend these attributes to provide a more custom approach for the problem at hand. Any class that extends from another class is called a subclass. The class a subclass inherits from is called the superclass. The two major types of inheritance are single and multiple inheritance.

Single Inheritance
Single inheritance is when a subclass only inherits from a single base class.

Example [7]:

class Student {
	String name; 
	String address;
	int age;
	float gpa;
}

class Undergraduate extends Student {
	String year; // Freshman, Sophomore, Junior, or Senior
}

class Graduate extends Student {
	String program;  // Either graduate or PhD
}

Both a Graduate class and Undergraduate class have similar behavior such as managing a name, an address, a major, and a GPA. Rather than put this behavior in both of these classes, the behavior is placed in a new class called Student. Both Graduate and Undergraduate become subclass of the Student class, and both inherit the Student behavior. Both Graduate and Undergraduate classes can then add additional behavior that is unique to them. For example, Graduate can be either Master's program or PhD program. On the other hand, the Undergraduate class might want to keep track of either the student is Freshman, Sophomore, Junior or Senior.

Multiple Inheritance
Multiple inheritance is when a subclass inherits from multiple base classes.

Example [8]:

class Horse {
	public:
		Horse() { cout << "Horse constructor... "; }
		virtual ~Horse() { cout << "Horse destructor... "; }
		virtual void Whinny() const { cout << "Whinny!... "; }
	private:
		int itsAge;
};

class Bird {
	public:
		Bird() { cout << "Bird constructor... "; }
		virtual ~Bird() { cout << "Bird destructor... "; }
		virtual void Chirp() const { cout << "Chirp... ";  }
		virtual void Fly() const { 
			cout << "I can fly! I can fly! I can fly! "; 
		}
		private:
		int itsWeight;
};

class Pegasus : public Horse, public Bird {
	public:
		void Chirp() const { Whinny(); }
		Pegasus() { cout << "Pegasus constructor... "; }
		~Pegasus() { cout << "Pegasus destructor...  "; }
};

Pegasus, which is a horse that can fly, inherits from both the Horse and the Bird classes. However, since Pegasus cannot chirp, the inherited Chirp function from the Bird class is overwritten with the Whinny function.

Polymorphism

Polymorphism, from the perspective of object-oriented languages, is the ability for functions and objects to have many forms. It is a very powerful tool that allows programmers to separate the interface from the implementation.

Consider the following example [9]:

Polymorphism Example.
Polymorphism Example.


















Suppose that our application uses many types of shapes, such as rectangles, and triangles. We can create a base Shape class that defines the public interface for all of the different types of shapes. In this case, we want all shapes to have a getArea() method.

Here is one possible implementation of the Shape class:

public class Shape {
   private String color;
   
   public Shape (String color) {
      this.color = color;
   }
   
   // All shapes must has a method called getArea()
   public double getArea() {
      System.err.println("Shape unknown! Cannot compute area!");
      return 0;   // Need a return to compile the program
   }
   
   public String toString() {
      return "Shape of color=\"" + color + "\"";
   }
}

Since the Shape class does not know what type of shape it is dealing with, it just prints out an error message when its getArea() method is called.

Now deriving the Rectangle and Triangle subclasses:

public class Rectangle extends Shape {
   private int length;
   private int width;
   
   public Rectangle(String color, int length, int width) {
      super(color);
      this.length = length;
      this.width = width;
   }
   
   @Override
   public String toString() {
      return "Rectangle of length=" + length + " and width=" + width + ", subclass of " + super.toString();
   }
   
   @Override
   public double getArea() {
      return length*width;
   }
}
public class Triangle extends Shape {
   private int base;
   private int height;
   
   public Triangle(String color, int base, int height) {
      super(color);
      this.base = base;
      this.height = height;
   }
   
   @Override
   public String toString() {
      return "Triangle of base=" + base + " and height=" + height + ", subclass of " + super.toString();
   }
   
   @Override
   public double getArea() {
      return 0.5*base*height;
   }
}

Therefore, due to polymorphism, all the shape subclasses will compute their area based on their corresponding area formula. All Rectangle objects will compute their area as length * width, while all Triangle objects will use 0.5 * base * height.

Encapsulation

Encapsulation, which is most often achieved through information hiding, allows a programmer to hide the implementation details of an object. Only state and behavior of an object that are designated as public can be viewed from outside its scope. This provides an important advantage to scripting languages by preventing objects from accidentally modifying attributes in another object that may be vital to the scripts functionality.

In most programming languages, the common levels of access to an object are:

  • Public : All objects can access it.
  • Protected : Access is limited to members of the same class or subclass.
  • Private : Access is limited to members of the same class. [10]

Code Reuse

Object-oriented design promotes code reuse by allowing programmers to take preexisting classes and integrating them into new scripts. This helps to improve readability of the code as well as promoting the "Don't Repeat Yourself" principle, which aims at reducing repetition of information. [11]

Advantages that scripting capability bring to an object-oriented language

Scripting provides a few advantages to object-oriented languages:

Interpreted Code

One of the main differences between scripting languages and system programming languages is that the scripting languages are interpreted whereas system programming languages are mostly compiled. Being an interpreted language, scripting languages make applications flexible, provide rapid turnaround while in development, eliminates compile time errors, and allows for code generation on the fly [12].

Dynamic Typing

Scripting languages were originally designed to serve as tools for automating repetitive tasks such as rotating a system log. In order to permit easy interfacing between components, a script language must be as typeless as possible. In strongly typed languages, extra code may be required in order to allow to components to communicate. This dynamic typing provides a distinct advantage that eventually made its way into popular programming languages such as Python and Ruby [13].

Glue Code

While not contributing any additional functionality to a program, glue code allows a programmer to connect two different pieces of existing code that were not designed to work together. [14]

Are there any advantages to a scripting language that is not object-oriented?

The only advantage to a scripting language that is not object-oriented is that it makes it a little easier if the language used for a particular project doesn’t require much complexity and OOP features don’t really make a difference. There are many non-object-oriented scripting languages in use, or scripting languages that have "object extensions" that often go unused like Perl, PHP, and various UNIX shells.

All these languages enable one to write small programs very quickly and efficiently without any complexity of OOP features. Perl was not originally designed or implemented as an object-oriented language. Its version of object-orientation is simple and well integrated, but not fundamental to the language. In a larger system, an object-oriented implementation of a system in Perl will almost never be faster than the equivalent non-object-oriented implementation [15]

Tcl also did not originally support object-oriented (OO) syntax before 8.6, so OO functionality was provided by extension packages, such as incr Tcl and XOTcl. Tcl is more suited at OO in the large than OO in the small. Fine-grained "an int is an object" OO would not fit well in Tcl. Everything is a string, after all [16]

A non-object-oriented PHP program

<html>
<head><title>Random</title></head>
<body>
<p>I have randomly selected the number
<?php $choice=rand(1,100); echo $choice;?>.
Its square root is <?php echo sqrt($choice);?>.</p>
</body>
</html>

Is scripting essentially synonymous with dynamic typing?

Scripting languages are dynamically typed, usually interpreted, and very high-level for e.g. Perl, Tcl, Python, Rexx, Visual Basic). Because of dynamic typing and interpretation they are very flexible and encourage experimentation [17]

The figure on the right shows a comparison of various programming languages based on their level (higher level language execute more machine instructions for each language statement) and their degree of typing. System programming languages like C tend to be strongly typed and medium level (5-10 instructions/statement). Scripting language like Tcl tend to be weakly typed and very high level (100-1000 instructions/statement) [18]

Objects in scripting languages tend to be typeless. To enable easy interfacing between the components that are combined together in a script. In a typeless environment, the output of one can be taken as a generic system of bytes and accepted by the receiving component just on that basis. Or, as is more commonly the case with scripting languages because string processing is main focus of such languages, the components can be assumed to produce characters at their outputs and to accept character streams at their inputs.

Perl is known as one of "the three Ps" (along with Python and PHP), the most popular dynamic languages for writing Web applications. Python is dynamically typed, so there is no need for variable declarations. This reduces the amount of code that students have to write and also eliminates common errors stemming from misunderstanding the subtle distinctions of declaration, definition and use [19] Ruby also features dynamic typing.
The following program shows power and simplicity of dynamic typing in Ruby

class Class
    def attr_reader2(*vars)
        vars.each do |symbol|
            define_method(symbol) { instance_variable_get "@#{symbol}" }
        end
    end
    def attr_writer2(*vars)
        vars.each do |symbol|
            define_method("#{symbol}=") { |value| instance_variable_set("@#{symbol}", value) }
        end
    end
    def attr_accessor2(*vars)
        attr_reader2(*vars)
        attr_writer2(*vars)
    end
end

Object-Oriented Scripting Languages

AppleScript

AppleScript is a scripting language created by Apple Inc., through which scriptable applications and parts of Mac OS can be controlled directly. AppleScript scripting language appears to be a simple language but it is a very rich, object-oriented language, capable of performing complex programming tasks. It has the concept of classes and objects. It is basically an inter-application processing system, intended to exchange data between different applications and control them to automate recurring tasks.
Example of a simple script with one property, one handler, one nested script object, and an implicit run handler with two statements

property defaultClientName : "Mary Smith"
on greetClient(nameOfClient)
    display dialog ("Hello " & nameOfClient & "!")
end greetClient
 script testGreet
    greetClient(defaultClientName)
end script
run testGreet --result: "Hello Mary Smith!"
greetClient("Joe Jones") --result: "Hello Joe Jones!"

Curl

Curl is a reflective object-oriented programming language for interactive web applications whose goal is to provide a effortless transition between formatting and programming. Curl is a markup language like and also includes an object-oriented programming language that supports multiple inheritance.

A modern web document, which comprises of different building blocks mostly requires various kinds of methods of implementation: different languages, different tools, different frameworks and sometimes completely different teams. The biggest problem has been getting all of these blocks to communicate with each other in a consistent manner. Curl attempts to side step these problems by providing a consistent syntactic and semantic interface at all levels of web content creation: from simple HTML to complex object-oriented programming. Curl combines text markup (as in HTML), scripting (as in JavaScript), and heavy-duty computing (as in Java, C#, or C++) within one common framework. It is used in a range of internal enterprise, B2B, and B2C applications.
Java-Like Object Oriented Programming

{curl 6.0 applet}
{curl-file-attributes character-encoding = "shift-j is"}
{define-class public Foo
 {method public {hello}:void
   {popup-message "Hello!"}
}
{define-class public Bar {inherits Foo}
  {method public {hello}:void
     {popup-message "Hello World!"}
}
{ do
   let foo:Foo = {Bar}
   {foo.hello}
}

Groovy

Groovy is an object-oriented programming scripting language for the Java platform. It is a dynamic language with features similar to those of Python, Ruby, Perl, and Smalltalk. It makes writing shell and build scripts easy with its powerful processing primitives, OO abilities and an Ant DSL. It makes testing simpler by supporting unit testing and mocking out-of-the-box. It seamlessly integrates with all existing Java classes and libraries. Groovy uses a Java-like bracket syntax. It is dynamically compiled to Java Virtual Machine (JVM) bytecode and interoperates with other Java code and libraries.

class Greet {
  def name
  Greet(who) { name = who[0].toUpperCase() +
                      who[1..-1] }
  def salute() { println "Hello $name!" }
}

g = new Greet('world')  // create object
g.salute()              // Output "Hello World!"

JavaScript

JavaScript, also known as Mocha, LiveScript, JScript, and ECMAScript, is one of the world's most popular programming languages. It is a class-free, object-oriented language, and uses prototypal inheritance instead of classical inheritance. It is a prototype-based scripting language, which is dynamic, weakly typed, and has first-class functions. It is a multi-paradigm language, which supports object-oriented, imperative, and functional programming styles. It supports OOP because it supports inheritance through prototyping as well as properties and methods. Many developers cast off JS as a suitable OOP language because they are so used to the class style of C# and Java. The primary use of JavaScript is to write functions that are embedded in or included from HTML pages and that interact with the Document Object Model (DOM) of the page. JavaScript is an excellent language to write object oriented web applications. It can support OOP because it supports Encapsulation, Polymorphism and inheritance through prototyping as well as properties and methods [20]

 
function A()
{
    var x = 7;
 
    this.GetX = function() { return x;}
    this.SetX = function(xT) { x = xT; }
}
 
obj = new A;
obj2 = new A;
document.write(obj.GetX() + ' ' + obj2.GetX());
obj.SetX(14);
document.write(' ' + obj.GetX() + ' ' + obj2.GetX());

Object Rexx

Object REXX programming language is an object-oriented scripting language initially produced by IBM for OS/2. As an object-oriented language, Rexx provides data encapsulation, polymorphism, an object class hierarchy, class-based inheritance of methods, and concurrency[21] It includes a number of useful base classes and allows you create new object classes of your own.
factorialProgram.rex -- computes the factorial of a number

  arg N .
  call factorial N
  say result
  exit 0 /* don't fall through to the PROCEDURE instruction */
  factorial : PROCEDURE
  n = arg( 1 )
  if n  = 1 then
    return 1 
  return n * factorial( n - 1 )

Perl 5

Perl is a high-level, general-purpose, interpreted, dynamic programming language. Perl was originally developed by Larry Wall in 1987 as a general-purpose Unix scripting language to make report processing easier. There are three main terms, explained from the point of view of how Perl handles objects. The terms are object, class, and method.

  • Within Perl, an object is merely a reference to a data type that knows what class it belongs to. The object is stored as a reference in a scalar variable.
  • A class within Perl is a package that contains the corresponding methods required to create and manipulate objects.
  • A method within Perl is a subroutine, defined with the package. The first argument to the method is an object reference or a package name, depending on whether the method affects the current object or the class.

Perl provides a bless() function which is used to return a reference and which becomes an object. Perl has a special variable, @ISA which governs (method) inheritance.
Inheritance in Perl 5

    { package Animal;
    sub speak {
      my $class = shift;
      print "a $class goes ", $class->sound, "!\n";
    }
    sub name {
      my $self = shift;
      $$self;
    }
    sub named {
      my $class = shift;
      my $name = shift;
      bless \$name, $class;
    }
  }
  { package Horse;
    @ISA = qw(Animal);
    sub sound { "neigh" }
  }

PHP

PHP is a widely-used general-purpose scripting language that is especially suited for Web development and can be embedded into HTML. Basic object-oriented programming functionality was added in PHP 3 and improved in PHP 4. Object handling was completely rewritten for PHP 5, expanding the feature set and enhancing performance. PHP 5 introduced private and protected member variables and methods, along with abstract classes and final classes as well as abstract methods and final methods. It also introduced a standard way of declaring constructors and destructors, similar to that of other object-oriented languages such as C++, and a standard exception handling model. Furthermore, PHP 5 added interfaces and allowed for multiple interfaces to be implemented. There are special interfaces that allow objects to interact with the runtime system. Objects implementing ArrayAccess can be used with array syntax and objects implementing Iterator or IteratorAggregate can be used with the foreach language construct. There is no virtual table feature in the engine, so static variables are bound with a name instead of a reference at compile time.

 
class Person {
   public $firstName;
   public $lastName;
 
   public function __construct($firstName, $lastName = '') { //Optional parameter
       $this->firstName = $firstName;
       $this->lastName = $lastName;
   }
 
   public function greet() {
       return "Hello, my name is " . $this->firstName . " " . $this->lastName . ".";
   }
}
 
$he = new Person('John', 'Smith');
 echo $he->greet(); // prints "Hello, my name is John Smith."

Python

Python is a remarkably powerful dynamic programming language that is used in a wide variety of application domains. Python is often compared to Tcl, Perl, Ruby, Scheme or Java. Python is a general-purpose, high-level programming language whose design philosophy emphasizes code readability. The class statement, which executes a block of code and attaches its local namespace to a class, for use in object-oriented programming. Python allows programmers to define their own types using classes, which are most often used for object-oriented programming.
An object oriented program in Python

# Function defined outside the class
def f1(self, x, y):
    return min(x, x+y)

class C:
    f = f1
    def g(self):
        return 'hello world'
    h = g

Ruby

Ruby is a dynamic, reflective, general-purpose object-oriented programming language that combines syntax inspired by Perl with Smalltalk-like features. Matsumoto has stated, "I wanted a scripting language that was more powerful than Perl, and more object-oriented than Python. That's why I decided to design my own language" Ruby is object-oriented: every data type is an object, including classes and types that many other languages designate as primitives (such as integers, booleans, and "nil"). Variables always hold references to objects. Every function is a method and methods are always called on an object. Methods defined at the top level scope become members of the Object class. Since this class is an ancestor of every other class, such methods can be called on any object. They are also visible in all scopes, effectively serving as "global" procedures. Ruby supports inheritance with dynamic dispatch, mixins and singleton methods (belonging to, and defined for, a single instance rather than being defined on the class). Though Ruby does not support multiple inheritance, classes can import modules as mixins.

class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
  def <=>(person) # Comparison operator for sorting
    @age <=> person.age
  end
  def to_s
    "#@name (#@age)"
  end
end
 
group = [
  Person.new("Bob", 33), 
  Person.new("Chris", 16), 
  Person.new("Ash", 23) 
]
 
puts group.sort.reverse

Tcl-Tk

Tcl originally from "Tool Command Language" is a scripting language created by John Ousterhout. It is commonly used for rapid prototyping, scripted applications, GUIs and testing. Tcl is used on embedded systems platforms, both in its full form and in several other small-footprinted versions. Tcl 8.6 provides an OO system in Tcl core [22] The combination of Tcl and the Tk GUI toolkit is referred to as Tcl/Tk.

oo::class create fruit {
    method eat {} {
        puts "yummy!"
    }
}
oo::class create banana {
    superclass fruit
    constructor {} {
        my variable peeled
        set peeled 0
    }
    method peel {} {
        my variable peeled
        set peeled 1
        puts "skin now off"
    }
    method edible? {} {
        my variable peeled
        return $peeled
    }
    method eat {} {
        if {![my edible?]} {
            my peel
        }
        next
    }
}
set b [banana new]
$b eat               → prints "skin now off" and "yummy!"
fruit destroy
$b eat               → error "unknown command"

References

1. Object-oriented programming http://en.wikipedia.org/wiki/Object-oriented_programming
2. Loui, R. (2008). In Praise of Scripting: Real Programming Pragmatism , IEEE Computer, vol. 41, no. 7.
3. Scripting Language http://en.wikipedia.org/wiki/Scripting_language
4, 13. Kak, A. C. (2008). Scripting With Objects. Hoboken, NJ: John Wiley & Sons.
5. What is an Object? http://download.oracle.com/javase/tutorial/java/concepts/object.html
6. Classes http://en.wikipedia.org/wiki/Class_%28computer_programming%29
7. Single Inheritance http://www.inf.ufsc.br/poo/smalltalk/ibm/tutorial/oop.html
8. Multiple Inheritance http://www.java-samples.com/showtutorial.php?tutorialid=462
9. Polymorphism http://www3.ntu.edu.sg/home/ehchua/programming/java/J3b_OOPInheritancePolymorphism.html
10. Booch, G., Maksimchuk, R. A., Engle, M. W., Young, B. J., Conallen, J., & Houston, K. A. (2007). Object-Oriented Analysis and Design With Applications, Third Edition. Upper Saddle River, NJ: Addison-Wesley.
11. Don't Repeat Yourself http://www.artima.com/intv/dry.html
12, 18. Scripting http://www.tcl.tk/doc/scripting.html
14. Glue Code http://www.site.uottawa.ca:4321/oose/index.html#gluecode
15. What object-oriented Perl isn't http://www.manning.com/conway/excerpt_preface.html
16. The strength on Tcl http://equi4.com/moam/strength.html
17. Barron, D., & Barron, W. D. (2000). The world of scripting languages (August 2000 ed.). NY: John Wiley & Sons
19. The Jython Tutorial http://www.jython.org/docs/tutorial/indexprogress.html
20. Object Oriented Programming in JavaScript http://mckoss.com/jscript/object.htm
21. Open Object Rexx http://www.oorexx.org/docs/rexxref/c188.htm
22. Tcl Core http://www.tcl.tk/man/tcl8.6/TclCmd/class.htm#M13