Connor's Notes

⬅️ Back to portfolio

COSC 2P05: Week 2 Notes

11 min read

Evolution of Programming Languages (cont.)

Note

Most information in this section will not be tested on. Some examples of stuff that COULD be asked on is “which language first included lists”, “what happened with programming languages when they were first invented”, etc.

PL/I

  • Pronounced “P L One”
  • First attempt to design a language that could be used for a broad spectrum of application areas
  • Developed by IBM in 1963
  • PL/I includes the best parts of:
    • Algol 60 (block structure and recursion)
    • Fortran IV (separate compilation with communication through global data/global variables)
    • COBOL (data structures, input/output, report generating facilities)
  • Huge language with lots of features; first in having:
    • Creating concurrently executing subprograms
    • Exception handling; 23 different types of exceptions or run-time errors
    • Efficient linking for non-recursive subprograms
    • Pointers were included as a data type
    • Cross-sections of arrays could be referenced

PL/I Example Program

/* PL/I PROGRAM EXAMPLE
INPUT: AN INTEGER, LISTLEN, WHERE LISTLEN IS LESS THAN 100, FOLLOWED 
	   BY LISTLEN-INTEGER VALUES
OUTPUT: THE NUMBER OF INPUT VALUES THAT ARE GREATER THAN THE AVERAGE 
		OF ALL INPUT VALUES */
PLIEX: PROCEDURE OPTIONS (MAIN);
	DECLARE INTLIST (1:99) FIXED.
	DECLARE (LISTLEN, COUNTER, SUM, AVERAGE, RESULT) FIXED;
	SUM = 0;
	RESULT = 0;
	GET LIST (LISTLEN);
	IF (LISTLEN > 0) & (LISTLEN < 100) THEN
	    DO;
/* READ INPUT DATA INTO AN ARRAY AND COMPUTE THE SUM */
    DO COUNTER = 1 TO LISTLEN;
	    GET LIST (INTLIST (COUNTER));
		SUM = SUM + INTLIST (COUNTER);
    END;
/* COMPUTE THE AVERAGE */
    AVERAGE = SUM / LISTLEN;
/* COUNT THE NUMBER OF VALUES THAT ARE > AVERAGE */
    DO COUNTER = 1 TO LISTLEN;
	    IF INTLIST (COUNTER) > AVERAGE THEN
	    RESULT = RESULT + 1;
    END;
/* PRINT RESULT */
    PUT SKIP LIST ('THE NUMBER OF VALUES > AVERAGE IS:’);
    PUT LIST (RESULT);
    END;
	ELSE
		PUT SKIP LIST ('ERROR-INPUT LIST LENGTH IS ILLEGAL');
END PLIEX;

APL and SNOBOL

  • Both languages are not based on any previous languages (completely original)
  • Common: Dynamic typing and storage allocation
  • APL
    • Designed around 1960 at IBM
    • Published in the book “A Programming Language” in 1962
    • Large number of powerful operators
    • Hard to maintain
  • SNOBOL
    • Designed in the early 1960s for text procrssing
    • Powerful operations for string pattern matching
      • Regex (native implementation)

SIMULA 67

  • SIMULA I was developed between 1962 and 1964 in Norway
    • Designed for simulations
    • Later extended to become a general purpose language
  • SIMULA 67 presented in 1967
    • Extends ALGOL 60
    • Introduces co-routines
    • Introduces the class construct

C

  • Developed by Bell Laboratories in 1972
  • Ancestors: CPL, PCPL, B, and Algol 68
  • Designed as a language to implement UNIX
  • First official standard in 1989 (ANSI C); next in 1999 (C99)
  • Lack of complete type checking

C Example Program

/* C Example Program
Input: An integer, listlen, where listlen is less than
       100, followed by listlen-integer values
Output: The number of input values that are greater than
        the average of all input values */
int main (){
	int intlist[99], listlen, counter, sum, average, result;
	sum = 0;
	result = 0;
	scanf("%d", &listlen);
	if ((listlen > 0) && (listlen < 100)) {
/* Read input into an array and compute the sum */
		for (counter = 0; counter < listlen; counter++) {
		    scanf("%d", &intlist[counter]);
		    sum += intlist[counter];
	    }
/* Compute the average */
	    average = sum / listlen;
/* Count the input values that are > average */
	    for (counter = 0; counter < listlen; counter++)
		    if (intlist[counter] > average) result++;
/* Print result */
        printf("Number of values > average is:%d\n", result);
	}
	else printf("Error-input list length is not legal\n");
}

C Examples

What does this program print?

int j;
for(int i=(j=1)*n; i; j=j*i--);
printf("%d",j);

“The person who wrote this program should be shot”

  • Prints

What about this one?

for(char *p=str, *q=str+strlen(str)-1; p<q; *p^=*q, *q^=*p, *p++^=*q--);
printf("%s",str);
  • Reverses a string

C++

  • Object-oriented version of C
  • Goals:
    • Add classes & inheritance
    • No performance penalty
  • Development steps
    1. C with Classes (1983)
    2. Extension with virtual methods (1984), first version called C++
    3. First implementation in 1985 (Cfront)
    4. Multiple inheritance, abstract classes (1989, C++ Release 2.0)
    5. Templates, parametrized types, exception handling (1990, C++ Release 3.0)
    6. Current C++ standardized in 1998, described in ISO
  • Features:
    • Supports procedural and object-oriented programming
    • Multiple inheritance
    • Operator overloading
    • Virtual methods
    • Class and method templates
    • Exception handling
  • Very popular language
  • Very large and complex
  • Inherits the insecurities of C, less safe than Ada or Java

Prolog

  • Completely different than any other language mentioned
  • Language for logic programming
    • Uses predicate calculus to formulate programs
    • Nonprocedural
    • Describes the form and/or characteristics of the result rather than how to compute it
  • Developed in 1972 in Marsaille
  • Prolog program consists of two kinds of statements: facts and rules
mother(joanne, jake). % fact
father(vern, joanne). % fact
 
grandparent(X, Y) :- parent(X, Y), parent(Y, Z) % rule
  • Queries are resolved using resolution (prove method)

Ada

  • Developed by Department of Defence in 1980
    • More than 450 different programming languages were used in DoD projects
    • None were suitable for embedded system design
    • Design competition from 1975 onwards
    • First complete language specification was published in ACM SIGPLAN for discussion
    • Revised version became Ada Language Reference Manual (1980)
    • Revised again in 1982
    • In 1983 the American National Standards Institute standardized Ada; design frozen for at least 5 years
  • Most important aspects of Ada
    • Anybody could participate in the design competition
    • Includes most concepts of software engineering and language design of the late 1970s
    • First compiler was available in 1985
    • Very large and highly complex
  • Ada 95 and Ada 2005
    • Inheritance
    • Polymorphism
    • Improved sharing of data between concurrent processes
    • DoD stopped requiring Ada in military software

Ada Example Program

-- Ada Example Program
-- Input: An integer, List_Len, where List_Len is less
-- than 100, followed by List_Len-integer values
-- Output: The number of input values that are greater
-- than the average of all input values
with Ada.Text_IO, Ada.Integer.Text_IO;
use Ada.Text_IO, Ada.Integer.Text_IO;
procedure Ada_Ex is
	type Int_List_Type is array (1..99) of Integer;
	Int_List : Int_List_Type;
	List_Len, Sum, Average, Result : Integer;
begin
	Result:= 0;
	Sum := 0;
	Get (List_Len);
	if (List_Len > 0) and (List_Len < 100) then
	-- Read input data into an array and compute the sum
	for Counter := 1 .. List_Len loop
	    if Int_List(Counter) > Average then
		    Result:= Result+ 1;
	    end if;
	end loop;
	-- Print result
	Put ("The number of values > average is:");
	Put (Result);
	New_Line;
	else
	Put_Line ("Error-input list length is not legal");
	end if;
end Ada_Ex;

Ada Tasks (Concurrency)

with TEXT_IO;
procedure PRODUCER_CONSUMER is
    use TEXT_IO;
    task PRODUCER is
    end PRODUCER;
    task CONSUMER is
	entry NO_MORE_CARDS;	
    end CONSUMER;
    task BUFFER is
        entry STORE(C: in CHARACTER); 
        entry RETRIEVE(C: out CHARACTER); 
        entry PRODUCER_DONE;
    end BUFFER;
    task body PRODUCER is separate;
    task body CONSUMER is separate;
    task body BUFFER is separate;
begin
    PUT_LINE("They're off and running");
end PRODUCER_CONSUMER;
separate (PRODUCER_CONSUMER)
task body BUFFER is
    BUFFER_SIZE: constant INTEGER := 100;
    BUFFER_DATA: array (0..BUFFER_SIZE - 1) of CHARACTER;
    BUFFER_FRONT: INTEGER := 0;
    BUFFER_REAR:  INTEGER := 0;
    BUFFER_EMPTY: BOOLEAN := TRUE;
    BUFFER_FULL:  BOOLEAN := FALSE;
    PRODUCER_IS_DONE: BOOLEAN := FALSE;
begin
    while not (BUFFER_EMPTY and PRODUCER_IS_DONE) loop
        select
            when not BUFFER_FULL =>
                accept STORE(C: in CHARACTER) do
                    BUFFER_DATA(BUFFER_REAR) := C;
                    BUFFER_REAR := (BUFFER_REAR + 1) rem BUFFER_SIZE;
                    BUFFER_EMPTY := FALSE;
                    BUFFER_FULL  := BUFFER_REAR = BUFFER_FRONT;
                end STORE;
        or
                   when not BUFFER_EMPTY =>
                accept RETRIEVE(C: out CHARACTER) do
                    C := BUFFER_DATA(BUFFER_FRONT);
                    BUFFER_FRONT  := (BUFFER_FRONT+1)rem BUFFER_SIZE;
                    BUFFER_EMPTY := BUFFER_FRONT = BUFFER_REAR;
                    BUFFER_FULL  := FALSE;
                end RETRIEVE;
        or
                accept PRODUCER_DONE do
                    PRODUCER_IS_DONE := TRUE;
                end PRODUCER_DONE;
        end select;
    end loop;
    CONSUMER.NO_MORE_CARDS;
end BUFFER;

Note

End of lecture 1.

Smalltalk

  • First object-oriented programming language
  • Originated in the PhD thesis of Alan Kay in the late 1960s as part of the Dynabook idea
  • Kay developed an “Interim” Dynabook, consisting of Xerox Alto hardware and Smalltalk-72 at Xerox
  • In 1980 a better Dynabook using Smalltalk-80 was developed
  • Features
    • Everything is an object
    • Computing is done by sending messages to an object by invoking one of its methods
    • A reply to a message is an object
    • Classes are object abstractions that can create objects
  • Disadvantages
    • No type checking
  • Smalltalk used a graphical user interface
    • First to use a window type system (operating systems didn’t support this type of thing previously)

Smalltalk Example Program

"Smalltalk Example Program"
"The following is a class definition, instantiations of which can draw equilateral polygons of any number of sides"
class name Polygon
superclass Object
instance variable names ourPen
numSides
sideLength
 
"Class methods“
"Create an instance"
new
  ^ super new getPen
 
"Get a pen for drawing polygons"
getPen
  ourPen <- Pen new defaultNib: 2
 
"Instance methods"
"Draw a polygon"
draw
  numSides timesRepeat: [ourPen go: sideLength; turn: 360 // numSides]
 
"Set length of sides"
length: len
  sideLength <- len
 
"Set number of sides"
sides: num
  numSides <- num

Smalltalk 80

Java

  • Based on C++
    • Similar power and flexibility
    • Smaller, simpler, and safer
  • Developed by Sun Microsystems in 1990 as a language for embedded consumer electronics devices
  • Primary goal: Reliability
  • Become a useful tool for web programming starting in 1993
    • Servlets, applets
  • Java Virtual Machine (JVM) is not part of the design language
  • Garbage collector

C#

  • Based on C++ and Java
  • Adds ideas from Delphi (OO version of Pascal)
  • Brings back a lot of features from C++ that were removed in Java, e.g.
    • Enum types
    • Operator overloading
  • Much safer than C++

Why not use C# over C++ all the time?

  • C# is basically a Microsoft product
    • works better on MS products (windows)
  • C++ is faster
    • Less time spent being safe
    • Better for low-level/embedded programming

End of week 2 slides, moving to week 3 (slides not available at time of lecture)

Names

Names are used to identify variables, formal parameters, subprograms, and multiple other program constructions

Names are strings of characters.

Design issues

  • Are names case sensitive?
    • Most modern languages are case sensitive
    • Most older languages are not case sensitive
  • Is the length of a name limited or unlimited?
  • Which characters are allowed resp. is there a special format for names?
    • Usually has to start with a alphanumeric character
    • Later on, can include numbers & some special characters (-, _, …
  • Are special words of the language reserved or keywords?

Special words

Keywords

  • A word that has a special meaning in certain contexts
  • Fortran is the only remaining widely used language whose special words are keywords. Examples:
    • Integer n: Declaration of variable name of type integer
    • Integer = 3: Assignment of 3 to variable Integer

Reserved Word

  • A word that cannot be used as a name
  • Potential problem: Large amounts of reserved words makes it hard to find proper names
    • COBOL has more than 300 reserved words including some of the most commonly chosen names by programmers (LENGTH, BOTTOM, DESTINATION, COUNT)

Predefined Words

  • A word with a predefined meaning that can be redefined

Variables

A program variable is an abstraction of a computer memory cell or collection thereof. A variable has usually 6 attributes:

Name

  • Most variables have a name

Address

  • Machine memory address associated with the variable
  • Might be different at different times in the program
  • Sometimes called l-value
  • Aliases

Value

  • Content of the memory cell(s) associated with the variable
  • Sometimes called r-value

Type

  • The type of the variable determines the range of values that the variable can store

Lifetime

  • The lifetime is the time during which the variable is bound to a specific memory location
  • Starts when the variable is bound to a cell
  • Ends when the variable is unbound from that cell

Scope

  • The scope of a variable is the range of statements in which the variable is visible
  • The scope rules of a language determines how a name is associated with a variable

Concept of Binding

  • A binding is an association, such as between an attribute and an entity
  • The Time at which a binding takes place is called binding time Example:
count = count + 5 // Java statement
  • The type of count is bound at compile time
  • The set of possible values of count is bound at compiler design time
  • The meaning of the operator symbol + is bound at compile time
  • The internal representation of the literal 5 is bound at the compiler design time
  • The value of count is bound at execution time with this statement

Binding Attributes to Variables

Any binding can be:

  • static
    • occurs before run time and remains unchanged throughout program execution
    • typed errors at compile time (in java, using static keyword)
  • dynamic
    • occurs during run time or can change during execution
    • variables can contain any type, like in JavaScript

Type Bindings

  • Static type binding
    • Explicit declaration
      • Statement in the program binding a type to a variable
      • int x = 0
    • Implicit declaration
      • A type is associated wit ha variable by default conventions
      • First appearance of the variable constitutes its implicit declaration
  • Type inference
    • Type of most entities is determined without requiring the programmer to speciffy types of the variables
    • Examples: ML, Haskell
area r = 3.14*r*r

Continued in week 3

Graph View

Backlinks