Perl, simula and smalltalk perl Introduction

10/26/2013

Programming Languages Research Paper

PERL, SIMULA and SMALLTALK
Perl Introduction
Perl is a high level, general purpose, interpreted, dynamic language. It was developed in 1987 by Larry Wall, while working in Unisys. The latest stable version of Perl is ver. 5.18. There is also Perl ver. 6 which is a different programming language altogether and is being developed separately from Perl ver. 5. The Perl language broadly derives its features from C, sh (Shell Scripting), AWK and sed.
Perl – Hello World Program
In Perl, one would write the “Hello World” program as
print “Hello World!\n”;
However as the language evolved so did the Perl practices which now require more complex programs to add the “use strict” and “use warnings” pragmas, changing the “Hello World” program now to:
use strict;

use warnings;

print “Hello World!\n”;
Pragma is a directive /language construct that specifies how a compiler processes its input.
Perl Design and Features
In Perl all the names have letters, numbers and underscore characters. Variables are prefixes with a special sign – All scalar variables start with $, arrays with @ and hashes with %. Also the language is case sensitive.

The bindings in Perl are dynamically typed, however one can simulate a static typing by using the “strict” pragma.

The “my” function provides static scoping; else by default Perl language is dynamic in its scoping.

The objects in Perl are references to data types, which knows its class. They are stored as reference in a scalar variable. A class in Perl is a package that contains the methods required to create and manipulate objects. Similarly, methods are sub routines defined within a package.

Perl Supports three built in data types – scalars which is a single string, number or reference, arrays of scalars which are ordered list of scalars indexed from 0 and hashes which are unordered collection of scalar values indexed by their associated string key.

Expressions in their simplest form are “matching expressions” in Perl. They use a special operator “=~”.

Operator overloading is permitted in Perl through using module “overload.pm”.

“while”, “for”, “foreach” and “if” statements are most commonly used control structures. “until” and “control” are variations of while useful to test conditions.

In Perl, Subprograms are global in scope, and can be invoked anywhere by name or by reference. They cannot be private; however the subroutine variables can be private.

Perl has built in exception handling mechanism through the “eval{}” block .”$@” variable is used to check for exceptions. The “Error.pm” module handles Object Oriented exception handling with returns in Perl. Special Event handling procedures are also offered in Perl through a subclass

Perl is a hybrid implementation where the program is compiled for errors and then interpreted using the Perl interpreter.

Perl employs reference garbage collector. However it cannot handle circular references leading to memory leaks.

Inheritance is easily defined using special variable “@ISA”, which governs the inheritance.

In Perl, encapsulation constructs are known as packages. It uses the constructors and destructors subroutines to handle incorporation in packages.

Abstractions are achieved through pseudo-hashes, which are like hashes, but scoped in its nature.

Objects have automatically called methods.

Polymorphism (Method Override in Perl) is implicitly present in Perl; because of weak typing one can override and redefine methods in subclasses.

Orthogonality - Not orthogonal but has many shortcut features defined to achieve various constructs.

Writability - Good writability because of many new features/functionalities which are continuously being added. It has simple data types and data type abstraction, also the special symbols increases writability.

Reliability - Increased stability with continuous evolution since 1987. However one can face security problems due to improperly validated user input. Continuous evolution has increased complexity in turn decreasing reliability.

Cost – Perl is open source software, thus no cost of ownership. Similarly compilation costs, execution costs are free. While cost of maintenance is a question of time vs. money as the more complex the code the more the time which may be needed.
Perl – Application in Real World
Perl has widespread popularity as a CGI scripting language and has powerful text processing facilities without the data length limitations. As such it is often used in graphics programming, system administration, network programming and biometrics. It’s called the “glue language” or the “duct tape that holds internet together”. Because of its text processing capabilities it is also favored for database applications.
Simula Introduction
Initially designed for doing Simulations it was later recognized as a general purpose programming language. It was developed in 1960s by Ole-Johan Dahl and Kristen Nygard. It is considered the first object oriented programming language. Its two known stable versions are – Simula 1 and Simula 67. It influenced later generations of programming languages greatly notably C++, Smalltalk. Simula introduced objects, classes, subclasses, virtual methods, coroutines and discrete event simulation. It was developed as an Extension of Algol 60, when the developers could not solve their problem using ALGOL 60.
Simula – Hello World Program
An example of a Hello world program in Simula:
Begin

OutText ("Hello World!");

Outimage;

End;

Simula has special type of class called prefix class (superclass), which defines a superclass and provides inheritance.

Objects in Simula are activation records produced by call to a class.

A special keyword “Ref” like Ref(Class) is a form of the type of an object variable (Simula term for pointers).

In Simula the following are the built in data types - Integer, Short Integer, Real, Long Real, Character, Boolean. And uses “:=“ for standard value assignments and “:-” for reference assignments.

Here the parameters are transmitted by value by default and only for the Ref type, parameters are transmitted by reference.

In Simula methods/functions are implemented using keyword procedure in all cases. Procedures can be declared anywhere in a program and do not allow return statements. Simula allows procedures to have procedure parameters (“Formal procedures”).

Virtual mechanism is achieved by declaring procedures virtual or not. These can also be termed abstract as no implementation is given in class.

It is a multi stack language. Each object executes in quasi parallel, gets its own call stack by calling procedures. “Detach” statement transfers the execution control back to main program. “Resume” continues the execution from the point of detachment.

Subclasses can only be declared at the same block level as the superclass.

Only in later versions, type check during compilation was added where initially it used to be performed at runtime.

List processing capabilities are provided through a class “Simset”. Similarly, class “Simulation” allows for discrete event simulation.

The language has strong modularization as it allows separate compilation of classes and procedures. Also the strong typing extends to separately compiled modules.

Objects are garbage collected automatically, as such user destructors are considered undesirable.

Simula has a highly standard definition; as such the programs are highly portable.

This language is a compiler implementation, uses the Simula compiler.

Inner - Indicates that the method of a subclass be called in combination with execution of superclass code.

Inspect/Qua - Provide ability to test the type of an object at run time and to execute appropriate code accordingly.

Initially no distinction for encapsulation, however later versions incorporated “protected” and “hidden” packages.

Writability – It has very limited file access facilities (typed files).

Reliability – It does not support multiple inheritances and has no interfaces. Often results in long executable files for short programs. It also has no advanced parallelism and real time support. A security mechanism is also missing as well as poor GUI support.

Cost – It is an expensive language. It never became a widespread language as such very few developers available and a small applications base. It also does not have a modern IDE which adds to its cost. However it is very portable because of its standardized definition.

Message “show:” is sent to the object “Transcript”. Invocation of the “show:” method displays the string. To see results, need transcript window.

A message is a request to object to perform operation (function call). In Smalltalk methods (function) are an implementation of an operation

Classes in Smalltalk are in defined as a template defining the implementation of a set of objects. This is performed using a special editor. A class variable is shared by all objects in that class. A Subclass is defined by inheriting from its superclass.

Selector in Smalltalk is the name of a message (function name). As such a message is a selector together with actual parameter values which contains the names and parameters of methods

In Smalltalk, method is the code in a class for responding to a message and are functions to manipulate objects. An instance variable is data stored in an individual object (instance of a class) and is repeated for each object

The expression types in Smalltalk are as follows –Literals, Variable names, Message Expressions, Blocks of Code.

All variables are pointers to objects and inherently type less. The variables are also case sensitive (public –start with upper class, private lower class)

A typical Message Expression in Smalltalk involves receiver, arguments, message selector and message answer.

The following are its message syntax types

Unary (no parameters)

Binary Ex: 2+3

Keyword Ex: myArray at: 42 put: 5

Self referencing is allowed by using “self”, this would reference the object itself.

The language uses “:=“ for assignment. And in here control structures are formed by passing block objects as parameters. Expressions evaluated when block receives the message value.

Ex: [Index:=index+1.

Sum:=sum+index.] value

Blocks can be assigned to variables.

Smalltalk is a “Just in Time” compilation. Smalltalk programs are usually compiled to byte code, which is then interpreted by a virtual machine into machine-native code.

All Smalltalk systems follow the same virtual machine specification making it very portable.

As this compilation done at method level, compilation is faster and instantaneous in Smalltalk resulting in it being a good language to perform prototypes.

Smalltalk has automatic garbage collection. Objects are allocated in a heap and the heap is collected for garbage automatically. “Nil” is an object used to check the “NULL” condition.

Error Handling is implicitly handled in this language. On error in objects type, a message “doesnotunderstand” pops up, and a debugger can be invoked to deal with it.

Reflection is supported in Smalltalk. Each object can be examined and if required modified at run time

Since the language was originally developed as a complete operating system, it includes code for activities typically performed at OS level.

Sub typing - Does not have compile time type system. Arises implicitly, based on set of messages understood by an object

Inheritance - Subclasses inherit all instance variables and methods of superclasses. Methods of a superclass may be redefined in a subclass or deleted. It is a strict tree structure wherein a subclass can have only one and only one parent class. Subclasses can add new variables or methods, also can hide inherited functionality.

Polymorphism - Supports by allowing methods defined in class to be over ridden with methods of the same name.

Encapsulation - Encapsulates all objects, which interact with other objects through messages to the objects interface.
Smalltalk Language Evaluation
Readability – It was developed for non programming users, simple and constructible. It has very few special words

Orthogonality - As all constructs are object specific, every possible combination is possible between the constructs leading to high orthogonality.

Writability - Readable and Orthogonal and as such has good support for abstraction.

Reliability – There is no inherent type checking but type checking carried out implicitly at run time for object types. Exception handling is performed at run time along with debugging capabilities. In Smalltalk aliasing is possible which decreases its reliability.