Programming Languages Presentation Perl Simula and Smalltalk PERL

Programming Languages Presentation Perl, Simula and Smalltalk

PERL

Perl – An Overview �Developed in 1987 by Larry Wall �High Level, general purpose, interpreted, dynamic language �Latest major stable version is 5. 18 Perl 5 �Perl 5 and Perl 6 – two different languages developed independently �Derived broadly from C, SH and AWK

Perl – “Hello World” �In Perl, one would write the Hello World program as: print "Hello World!n"; �Good Perl practices require more complex programs to add the use strict and use warnings pragmas, leading into something like: use strict; use warnings; print "Hello World!n";

Perl-Design & Features � Names Letters, numbers and underscores characters Variables are prefixes with a special sign § § § $ for scalars @ for arrays % for hashes Variables are case sensitive � Bindings § Dynamic typed in terms of binding § Can simulate static typing by using “strict” � Scoping § ‘my’ provides static scoping, else generally dynamic §

Perl-Design & Features �Objects �Reference to a data type, which knows its class �Stores as reference in a scalar variable �Class �A package that contains the methods required to create and manipulate objects �Method �A sub-routine defined within a package

Perl-Design & Features �Data Types �Three built in data types �Scalars �Arrays of Scalars �Associative Arrays of Scalars known as “Hashes” �A scalar is a single string, number or reference �Arrays are ordered lists of scalars indexed from 0. �Arrays are versatile and dynamic �Hashes are unordered collection of scalar values indexed by their associated string key

Perl-Design & Features �Expressions and Assignment Statements �Simplest form – ‘matching expressions’ �Special operator ‘=~’ �Use module ‘overload. pm’ to perform operator overloading �Stetement Level Control Structures �while, foreach and if statements are most commonly used control structures �until and unless - variations of while and if respectively �control block – another form of while, useful to test conditions

Perl-Design & Features �Sub-programs �Are global in scope, and can be invoked anywhere by name or by reference �Cannot be private, however the subroutine variables can be private �Exception Handling and Event Handling � Built in exception handling mechanism- eval{} block �$@ variable to check for exceptions �Error. pm module handles OO exception handling �Event handling procedures offered through a subclass

Perl-Design & Features �Implementation �Hybrid Implementation where the program is compiled for errors and then interpreted using the perl interpreter �Garbage Collection �Perl employs reference garbage collector. �Cannot handle circular references leading to memory leaks

Perl – Object oriented Features �Inheritance �Easily defined using special variable “@ISA”, that governs the inheritance �Encapsulation constructs �Known as packages �Use the constructors and destructors subroutines to handle incorporation in packages �Abstractions �Psedo-hashes: like hashes, but scoped. �Objects have automatically called methods

Perl – Object oriented Features �Polymorphism (Method Override) �Implicitly polymorphic, because of weak typing, we can override and redefine methods in subclasses

Perl - Evaluation Readability �Reputation of being ugly and hard to maintain �Poor Readability in general �Variables because of special symbols are easy to read �Syntax is non trivial Orthogonality �Not orthogonal but has many shortcut features

Perl - Evaluation Writability � Good writability because of many new features � Simple data types and data type abstraction, special symbols increases writability Reliability � Increased stability with continuous evolution since 1987 � Security problems due to improperly validated user input � Increased complexity decreases reliability

Perl - Evaluation Cost �Open source software, no cost of ownership �Similarly compilation costs, execution costs are free. �Cost of maintenance is a question of time vs money

Perl - Applications �Widespread popularity as a CGI scripting language �Powerful text processing facilities without the data length limitations �Used in graphics programming, system administration, network programming and biometrics �Called the “glue language” or the “duct tape that holds internet together” �Favored for database applications

SIMULA

Simula – An Overview �Initially designed for doing Simulations �Later recognized as a general purpose programming language �Developed in 1960 s by Ole-Johan Dahl and Kristen Nygard. �First object oriented programming language �Two versions – Simula 1 and Simula 67 �Influenced later generations of programming languages notably C++, Smalltalk �Extension of Algol 60

Simula: “Hello World” �An example of a Hello world program in Simula: Begin Out. Text ("Hello World!"); Outimage; End;

Simula- Design & features �Class �A procedure which returns a pointer to its activation record �Similar to Java, uses “begin …. . end” like braces in Java �Comments begin with “!” and end with “; ” �Prefix Class (superclass) – defines a superclass and provides inheritance �Object �Activation record produced by call to a class �Ref(Class) – form of the type of a object variable (Simula term for pointers)

Simula- Design & features � Data types �Integer, Short Integer, Real, Long Real, Character, Boolean �Text – a class instance �Case sensitive � Assignments �Uses “: =“ for standard value assignments �And “: -” for reference assignments � Parameters �Transmitted by value �Only for Ref type, parameters are transmitted by reference

Simula- Design & features �Procedures �Method/function implemented using keyword procedure in all cases �Procedures can be declared anywhere in a program �No return statements �Allows procedures to have procedure parameters (“Formal procedures”) �Virtual Mechanism �Procedures can be declared virtual or not �Can also be abstract as no implementation is given in class

Simula- Design & features �Co-routines and quasi parallel execution �A multi stack language �Each objects 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.

Simula- Design & features � Type checking � Later versions, type check during compilation was added � List processing �Class “Simset” adds list processing capabilities � Simulation �Class “Simulation” allows for discrete event simulation � Modularization �Separate compilation of classes and procedures �Strong Typing extends to separately compiled modules

Simula- Design & features �Memory Management �Objects are garbage collected automatically �User destructors considered undesirable �No issues with life span of objects �Portability �Highly standard definition �Programs are highly portable �Implementation �Compiler implementation, uses Simula compiler to implement

Simula – Object Oriented Features �Dynamic Lookup �Operations on an object are selected from the activation record of that object �Inheritance (“Class prefixing”) �Form of class prefixing, including the ability to redefine parts of a class in a subclass �Subtyping �Arising from the way types are associated with classes �Abstraction – introduced in later versions

Simula – Object Oriented Features Unique Object oriented features of Simula �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 Encapsulation �Initially no distinction �Later versions incorporated “protected” and “hidden”

Simula: Evaluation �Readability �Too complicated �Missing data types (records, sets) as such orthogonality very poor �Writability �Limited file access facilities (typed files)

Simula: Evaluation �Reliability �No multiple inheritance �No interfaces �Long executable files for short programs �No advanced parallelism and real time support �No GUI support �No proper security mechanism �Cost �Expensive, never became a widespread language �Does not have a modern IDE �Very portable

Simula - Applications �Designed for doing Simulation during the 1960 s �Also used in wide range of applications such as simulating VLSI designs, process modeling, protocols, typesetting, computer graphics and education

SMALLTALK

Smalltalk – An Overview �An object-oriented, dynamically typed, reflective programming language �Developed at Xerox PARC �Smalltalk-76, Smalltalk-80 important versions �Created by Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Scott Wallace in the 1970 s �Major language that popularized objects �Motivating application – Dynabook by Alan Kay

Smalltalk - Overview �Main advances of Smalltalk over Simula: �The Object metaphor was extended and refined �Everything is an object including class �All operations are messages to objects �Objects and classes can be used to build entire system �Abstraction was added using private instance variables, public methods

Smalltalk – “Hello World” �Message "show: " is sent to the object "Transcript“ �Invocation of the "show: " method displays the string Transcript show: 'Hello, World!'. �To see results, need transcript window

Smalltalk – Design & Features �Object �A combination of private data and functions �Each object is an instance of some class �Have local memory, inherent processing capability �Ability to communicate with other objects �Can be passed as parameters and returned as objects �Messages and Methods �Message is a request to object to perform operation (function call) �Methods: (function) implementation of an operation

Smalltalk – Design & Features �Classes �A template defining the implementation of a set of objects �A special editor �Class variable-shared by all objects in class �Subclass defined by inheriting from its superclass �Selector �The name of a message (function name)

Smalltalk – Design & Features �Message �A selector together with actual parameter values �Contains the names and parameters of methods �Method �The code in a class for responding to a message �Functions to manipulate objects �Instance Variable �Data stored in an individual object (instance of a class) �Repeated for each object

Smalltalk – Design & Features �Expressions �Computation achieved by evaluating expressions, which always return an object �Types –Literals, Variable names, Message Expressions, Blocks of Code �Variables �All variables are pointers to objects and inherently typeless �Case sensitive (public –start with upperclass, private lowerclass)

Smalltalk – Design & Features �Message Expressions �Involves �Receiver �Arguments �Message selector �Message Answer �Message Syntax Types �Unary (no parameters) �Binary : 2+3 �Keyword : my. Array at: 42 put: 5

Smalltalk – Design & Features � Self references �“self” is used to the object itself � Assignment �Uses “: =‘ for assignment � Blocks � Control structures formed by passing block objects as parameters �Expressions evaluated when block receives the message “value” [index : = index+1. Sum: =sum+index. ] value �Blocks can be assigned to variables

Smalltalk - Design & Features �Implementation �Just in time compilation �Smalltalk programs are usually compiled to byte code, which is then interpreted by a virtual machine into machine-native code. �Portability �All smalltalk systems follow the same virtual machine specification making it very portable �Incremental Compilation �Compilation done at method level, compilation is faster and instantaneous

Smalltalk - Design & Features �Garbage Collection �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 �On error in objects type, a message “doesnotunderstand” pops up, and a debugger can be invoked to deal with it.

Smalltalk - Design & Features �Reflection �Each object can be examined and if required modified at run time �Operating System �Was originally developed as a complete operating system �Includes code for activities typically performed at OS level

Smalltalk - Object Oriented Features �Abstraction �Provided through protected instance variables �All methods are public, instance variables accessed only by methods of the class and subclasses �Subtyping �Does not have compile time type system �Arises implicitly, based on set of messages understood by an object

Smalltalk - Object Oriented Features �Inheritance �Subclasses inherit all instance variables and methods of superclasses �Methods of a superclass may be redefined in a subclass or deleted �Is a strict tree structure: a subclass can have only one and only one parent class �Subclasses can add new variables or methods, also can hide inherited functionality

Smalltalk - Object Oriented Features �Polymorphism �Supports by allowing methods defined in class to be over ridden with methods of the same name �Encapsulation �Encapsulates all objects, which can be interact with other objects through messages to the objects interface

Smalltalk - Evaluation �Readability �Developed for non programming users �Simple and constructible �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 �Good support for abstraction

Smalltalk - Evaluation �Reliability �No inherent type checking �But type checking carried out implicitly at run time for object types �Exception handling performed at run time, with debugging capabilities �Aliasing possible decreasing reliability �Cost �When released relatively expensive and uncommon �Was not widely adopted resulting in shortage of trained people and matured models

Smalltalk - Evaluation �Whole “OS” approach, was a barrier when there were more widely used OS like Unix �Hasn’t kept up in the application area �However very portable because of same virtual machine specification

Smalltalk - Applications �Prototyping –a program can be prototyped quickly in smalltalk and later deployed in other languages. This is possible due to incremental compilation �Operating System – not widespread

Thank You