CSC/ECE 517 Fall 2011/ch1 1g jn

Comparing Object-Oriented and Scripting Languages

Overview:-Object Oriented and Scripting Languages

Object-Oriented Languages
1.OOP languages focus on abstract relationships and hierarchy of related functionality.
2.Any problem is handled as a collection of real-world objects that provide services to solve that problem.
3.It bounds data closely to the functions that operate on it and protects it from accidental modification from outside functions.
4.Encapsulation and polymorphism emphasizes on re-usability by keeping the implementation flexible without having the need to change a great deal of code.
5.Object-orientation is a sturdy compromise between performance and organization. Programmer needs to know how to effectively represent real-life scenarios into objects to fill the needs of market.
Scripting Languages
1.High-level software development language,primarily used for the purpose of adding dynamic and interactive components to web pages.
2.They are not stand-alone programming languages with support of large system development. However, they can be integrated with existing technologies to provide required functionality.
3.Portable and Platform independent because they can be created and edited easily on any text editors.
4.Easy to learn and require minimum programming knowledge or experience.
5.It must be efficient when calling system resources such as file operations, inter-process communications, and process control.

Advantages that object orientation brings to a scripting languages

Advantages of object orientation on scripting languages can be explained on the basis of core O-O concepts:-

Code Reusablity

To allow developers to pay more attention on program functionality, code reuse is a very effective technique that saves time and effort by significantly reducing the redundant code. Administrators and script developers can share functionality by breaking their programs into reusable units like modules functions etc. and using them as other program’s components. For example:-

• Python supports program reusability by implementing modules and packages in standard Python Library.
• Windows PowerShell offer Modules that enable production-ready scripting solutions. These redistributable components have added benefit of allowing users to repackage and abstract multiple components to create custom solutions.
• CPAN (Comprehensive Perl Archive Network) is an online repository of Perl modules which are collection of files of Perl code that can be reused from program to program.

Inheritance

One major advantage of Object Inheritance, apart from its usefulness in defining and abstracting functionality, is it permits the implementation of additional functionality in similar objects without the need to re-implement all of the shared functionality. Object oriented languages implement class-based inheritance and thus have deep hierarchies. Whereas most of the scripting languages use prototypical inheritance where classes and objects have shallow hierarchies and are more expressive. Since scripting languages are loosely-typed languages, object references don’t need casting. For example :-

• JavaScript and PowerShell support inheritance through prototyping as well as properties and method.
• In JavaScript,Class objects are soft and thus new members can be added by simple assignment. All object types have a prototype property that can be both extended and inherited. Prototyping also has its disadvantages like object creation can much slower than it can be in a more conventional class/object dichotomy scheme.
• Inheritance in Python has close resemblance with classical inheritance as it allows multiple base classes, a derived class can override any methods of its base class or classes, and a method can call the method of a base class with the same name.
• @ISA variable defined for each package in PERL governs inheritance.If a call to a method on an object or class returns null in that object’s package, Perl looks to @ISA for other packages to go looking through in search of the missing method.

The main reason behind inheritance exhibiting a different behavior in scripting languages is, it needs to be as dynamic as the environment it is in.

Encapsulation

Encapsulation is a useful technique in programming which allows you to separate an abstraction's implementation from its interface, thus allowing enhancements without affecting the interface.

• JavaScript implements encapsulation using Closures which can be used to group interrelated and dependent code. For example, A Closure allows the buffer array to be associated with the function that is dependent upon it and simultaneously keep the property name to which the buffer array as assigned out of the global namespace and free of the risk of name conflicts.
• Python supports encapsulation with naming conventions; however they are not strictly implemented. For Example, it differentiates between identifiers starting with a single versus double underscore (akin to protected versus private).

        function Classroom(studname, std) { this.toString = function() {
                           return 'Student Name: ' + studname + ', Standard: ' + std;
                          };}

Polymorphism Polymorphic variable in scripting languages contributing significantly in memory conservation as a single variable can be used to store multiple data types (integers, strings, etc.),rather than declaring variable for each data format to be used.

• JavaScript implement it using the prototype operator.
• Python’s dynamic typing in an object-oriented context helps in accomplishing generic programming and polymorphism.

Few polymorphism examples:-

In Python:-

myString = 'Hello, world!'
myList = [0, 'one', 1, 'two', 3, 'five', 8]
print myString[:5]  # prints Hello
print myList[:5]    # prints [0, 'one', 1, 'two', 3]
print 'e' in myString   # prints True
print 5 in myList       # prints False

In Perl:-

package Animal;
sub new {
    my ($class, $name) = @_;
    bless {name => $name}, $class;
}   

package Cat;
@ISA = "Animal";
sub talk {"Meow"}

package Dog;
@ISA = "Animal";
sub talk {"Woof! Woof!"}

package main;
my @animals = (
    Cat->new("Missy"),
    Cat->new("Mr. Mistoffelees"),
    Dog->new("Lassie"),
);
for my $animal (@animals) {
    print $animal->{name} . ": " . $animal->talk . "\n";
}

# prints the following:
# Missy: Meow
# Mr. Mistoffelees: Meow
# Lassie: Woof! Woof!

For more examples please refer following wiki page :- Polymorphism in Object Oriented Programming

Abstraction and Real-World Modeling

Object-oriented system tends to model the real world in a more complete manner than do traditional methods. Objects are organized by classes and focus is more on their behavior than data and processing. Real-world constructs can be best described and represented using Abstract data types. Scripting languages like JavaScript use functions as object descriptors.

Advantages that scripting capability bring to an object-oriented languages

Scripting functionality in addition with Object-orientation creates a favorable environment for Web application Development. Following are few advantages that scripting capability adds :-

Gluing

Scripting Languages assume existence of a set of powerful components and that can be connected to implement web features or extend features of existing components. Tcl and Visual Basic offer collection of UI controls whereas Shell Scripts are used to assemble filter programs into pipelines. They are not intended for writing application from scratch.

Rapid and Incremental Application Development

Scripting languages provide rapid turnaround during development by eliminating compile times and allowing interpreters to program application at runtime. Browser can parse web page by translating the HTML for the page into a script using a few regular expression substitutions and then executing that script to render page on browser screen.

Dynamic Typing

Dynamic typed programming does not require the explicit declaration of the variables before they’re used. For example num=5, num can be assigned value before being initialized.In order to implement dynamic typing, Names are bound to objects at execution time by means of assignment statements, and it is possible to bind a name to objects of different types during the execution of the program. As a result of dynamic typing, programs are not limited by the expressiveness of the type system of the language — e.g. heterogeneous data structures w/o explicit tagging. It also opens door for open recursion, late binding, dynamic scope, and duck typing.

Embedded within HTML

Scripting Languages are easy to use because they are contained directly in an HTML page and created in plain ASCII text, thus simple to implement and change. They have their application in the field of gaming as they provide good interactive experience as well as perform basic interactive functions required by website such as data validation.