CS 363 Comparative Programming Languages
description
Transcript of CS 363 Comparative Programming Languages
![Page 1: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/1.jpg)
CS 363 Comparative Programming Languages
Evolution of Programming Languages
![Page 2: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/2.jpg)
CS 363 GMU Spring 2005 2
Genealogy (incomplete)
![Page 3: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/3.jpg)
CS 363 GMU Spring 2005 3
FORTRAN - 1957
• FORmula TRANslating systems
• FORTRAN I - 1957
(FORTRAN 0 - 1954 - not implemented)– Designed by John Backus for the new IBM 704,
which had index registers and floating point hardware
– Environment of development:• Computers were small and unreliable• Applications were scientific• No programming methodology or tools• Machine efficiency was most important
![Page 4: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/4.jpg)
CS 363 GMU Spring 2005 4
FORTRAN
• Impact of environment on design of FORTRAN I– No need for dynamic storage– Need good array handling and counting loops– No string handling, decimal arithmetic, or powerful input/output
(commercial stuff)
• First implemented version of FORTRAN – Names could have up to six characters– Post-test counting loop (DO)– Formatted I/O– User-defined subprograms– Three-way selection statement (arithmetic IF: neg,0,pos)– No data typing statements – implicit types (I-N are integer)– Fixed program format
![Page 5: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/5.jpg)
CS 363 GMU Spring 2005 5
FORTRAN
• FORTRAN IV - 1960-62– Explicit type declarations– Logical selection statement– Subprogram names could be parameters– ANSI standard in 1966
• FORTRAN 77 - 1978– Character string handling– Logical loop control statement– IF-THEN-ELSE statement
![Page 6: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/6.jpg)
CS 363 GMU Spring 2005 6
FORTRAN
• FORTRAN 90 - 1990– Modules– Dynamic arrays– Pointers– Recursion– CASE statement– Parameter type checking
![Page 7: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/7.jpg)
CS 363 GMU Spring 2005 7
FORTRAN
• Contributions– First widely used programming language– Changed the way people interacted with computers– Set the standard for compilers
• Goal: generate machine code similar to that of machine language programmers highly optimized compiler
• Much of the theory of compilers was developed in this compiler.
![Page 8: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/8.jpg)
CS 363 GMU Spring 2005 8
Sample Fortran subroutine defcolor(rgb,nframe) implicit none integer nframe integer ihpixf, jvpixf parameter(ihpixf = 256, jvpixf = 256) ! pixel size character*1 rgb(3,ihpixf,jvpixf) ! RGB data array local integer i, j, idummy do 100 j = 1, jvpixf do 100 i = 1, ihpixf idummy = i*3*nframe + j*2 idummy = mod(idummy,256) ! assuming color depth is 256 (0--255) rgb(1,i,j) = char(idummy) ! red idummy = i*1*nframe + j*3 idummy = mod(idummy,256) rgb(2,i,j) = char(idummy) ! green idummy = i*5*nframe + j*7 idummy = mod(idummy,256) rgb(3,i,j) = char(idummy) ! blue 100 continue return end
![Page 9: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/9.jpg)
CS 363 GMU Spring 2005 9
Sample Fortran real*4 one,eps, ht, tf real*8 one8, eps8 one = 1. one8 = 1. eps = 1. eps8 = 1. ht = 100000 tf = 24. print *, 'Test for precision of real*4, based on
1+eps=1' 10 eps = eps/2. if (one .ne. one+eps) go to 10 eps = 2.*eps print *,' relative precision is ',eps print * print *,'Test for precision of real*4,', + 'based
on 100000+eps=100000' eps = 1. 15 eps = eps/2.
if (ht .ne. ht+eps) go to 15 eps = 2.*eps print *,' relative precision is ',eps print * print *,'Test for precision of real*4,', + 'based
on 24+eps=24' eps = 1. 17 eps = eps/2. if (tf .ne. tf+eps) go to 17 eps = 2.*eps print *,' relative precision is ',eps print * print *, 'Test for precision of real*8, based on
1+eps=1' 20 eps8 = eps8/2. if (one8 .ne. one8+eps8) go to 20 eps8 = 2.*eps8 print *,' relative precision is ',eps8 end
![Page 10: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/10.jpg)
CS 363 GMU Spring 2005 10
LISP - 1959
• LISt Processing language• AI research needed a language that:
– Processed data in lists (rather than arrays)– Allowed symbolic computation (rather than numeric)
• Only two data types: atoms and lists• Syntax is based on lambda calculus• No variables or assignment• Control via recursion and conditional expressions• (A B C D) – apply function A to arguments B C D
![Page 11: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/11.jpg)
CS 363 GMU Spring 2005 11
LISP
(A B (C D) E) A B E
C D
(A B C D)
A B DC
Data Structures for Lists
![Page 12: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/12.jpg)
CS 363 GMU Spring 2005 12
LISP
• Pioneered functional programming
• First interpreters slow
• COMMON LISP and Scheme are contemporary dialects of LISP
• ML, Miranda, and Haskell are related languages
![Page 13: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/13.jpg)
CS 363 GMU Spring 2005 13
LISP Sample
Problem: remove the first occurrence of atom A from list L
(define (remove L A) (cond ( (null? L) '() ) ( (= (car L) A) (cdr L)) ; Match found! (else (cons (car L)(remove (cdr L) A))) ; keep searching ) )
![Page 14: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/14.jpg)
CS 363 GMU Spring 2005 14
ALGOL 58 and 60
• Designed as a ‘universal language’ by committee (ACM and European committee)
• Goals of the language:– Close to mathematical notation– Good for describing algorithms– Must be translatable to machine code
• Environment of development:– FORTRAN had (barely) arrived for IBM 70x– Many other languages were being developed, all for specific
machines– No portable language; all were machine-dependent– No language for communicating algorithms
![Page 15: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/15.jpg)
CS 363 GMU Spring 2005 15
ALGOL 58• Language Features:
– Concept of type was formalized
– Names could have any length
– Arrays could have any number of subscripts
– Parameters were separated by mode (in & out)
– Subscripts were placed in brackets
– Compound statements (begin ... end)
– Semicolon as a statement separator
– Assignment operator was :=– if had an else-if clause
– No I/O - “would make it machine dependent”
– Not meant to be implemented, but variations were (MAD, JOVIAL)
– Although IBM was initially enthusiastic, all support was dropped by mid-1959
![Page 16: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/16.jpg)
CS 363 GMU Spring 2005 16
ALGOL 60
• Modified ALGOL 58 at 6-day meeting in Paris
• New features:– Block structure (local scope)– Two parameter passing methods– Subprogram recursion– Stack-dynamic arrays– Still no I/O and no string handling
![Page 17: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/17.jpg)
CS 363 GMU Spring 2005 17
ALGOL 60
• Contribution:– It was the standard way to publish algorithms for over 20 years– All subsequent imperative languages are based on it– First machine-independent language– First language whose syntax was formally defined (BNF)
• Never widely used, especially in U.S.– No I/O and the character set made programs non-portable– Too flexible--hard to implement– Entrenchment of FORTRAN– Formal syntax description– Lack of support of IBM
![Page 18: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/18.jpg)
CS 363 GMU Spring 2005 18
BASIC - 1964
• Beginner’s All-purpose Symbolic Instruction Code
• Designed by Kemeny & Kurtz at Dartmouth• Design Goals:
– Easy to learn and use for non-science students– “pleasant and friendly”– Fast turnaround for homework– Free and private access– User time is more important than computer time
• Current popular dialect: Visual BASIC • First widely used language with time sharing
![Page 19: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/19.jpg)
CS 363 GMU Spring 2005 19
PL/I - 1965• Computing situation in 1964 (IBM's point of view)
– Scientific computing• IBM 1620 and 7090 computers with FORTRAN
– Business computing• IBM 1401, 7080 computers with COBOL
• By 1963, however, – Scientific users began to need more elaborate I/O, like
COBOL had; Business users began to need floating point and arrays (MIS)
– It looked like many shops would begin to need two kinds of computers, languages, and support staff--too costly
• The obvious solution:– Build a new computer to do both kinds of applications– Design a new language to do both kinds of applications
![Page 20: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/20.jpg)
CS 363 GMU Spring 2005 20
PL/I
• Designed in five months
• PL/I contributions:– First unit-level concurrency– First exception handling– Switch-selectable recursion– First pointer data type– First array cross sections
• Comments:– Many new features were poorly designed– Too large and too complex– Was (and still is) actually used for both scientific and
business applications
![Page 21: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/21.jpg)
CS 363 GMU Spring 2005 21
APL and SNOBOL
• Characterized by dynamic typing and dynamic storage allocation
• APL (A Programming Language) 1962– Designed as a hardware description language (at
IBM)– Highly expressive (many operators, for both
scalars and arrays of various dimensions)– Programs are very difficult to read
• SNOBOL(1964)– Designed as a string manipulation language (at
Bell Labs)– Powerful operators for string pattern matching
![Page 22: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/22.jpg)
CS 363 GMU Spring 2005 22
Snobol Example
* Find biggest words and numbers in a test string * BIGP = (*P $ TRY *GT(SIZE(TRY,SIZE(BIG))) $ BIG FAIL STR = 'IN 1964 NFL ATTENDANCE JUMPED TO 4,807,884; ‘ 'AN INCREASE OF 401,810.' P = SPAN('0123456789,') BIG = STR BIGP OUTPUT = 'LONGEST NUMBER IS ' BIG P = SPAN('ABCDEFGHIJKLMNOPQRSTUVWXYZ') BIG = STR BIGP OUTPUT = 'LONGEST WORD IS ' BIG END
![Page 23: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/23.jpg)
CS 363 GMU Spring 2005 23
SIMULA 67 - 1967
• Designed primarily for system simulation
• Based on ALGOL 60 and SIMULA I• Primary Contribution:
– Co-routines - a kind of subprogram– Implemented in a structure called a class
• Classes are the basis for data abstraction• Classes are structures that include both local data and
functionality
– Objects and inheritance
![Page 24: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/24.jpg)
CS 363 GMU Spring 2005 24
ALGOL 68 - 1968
• From the continued development of ALGOL 60, but it is not a superset of that language
• Features:– User-defined data structures– Reference types– Dynamic arrays (called flex arrays)
• Contribution:– Had even less usage than ALGOL 60 BUT had
strong influence on subsequent languages, especially Pascal, C, and Ada
![Page 25: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/25.jpg)
CS 363 GMU Spring 2005 25
Important ALGOL Descendants
• Pascal - 1971– Designed by Wirth, who quit the ALGOL 68
committee (didn't like the direction)– Designed for teaching structured
programming– Small, simple, nothing really new– From mid-1970s until the late 1990s, it was
the most widely used language for teaching programming in colleges
![Page 26: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/26.jpg)
CS 363 GMU Spring 2005 26
Pascal Sample
program fibonacci(input, output);type natural 0..maxint;var fnm1,fnm2, fn,n,i: naturalbegin readln(n); if n <= 1 then writeln(n) {F0 = 0 and F1 = 1} else begin {compute Fn} fnm2 := 0; fnm1 := 1; for i := 2 to n do begin fn := fnm1 + fnm2; fnm2 := fnm1; fnm1 := fn; end writeln(fn); endend.
![Page 27: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/27.jpg)
CS 363 GMU Spring 2005 27
Important ALGOL Descendants
• C - 1972– Designed for systems programming (at Bell
Labs by Dennis Richie)– Evolved primarily from B, but also ALGOL 68– Powerful set of operators, but poor type
checking– Initially spread through UNIX
![Page 28: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/28.jpg)
CS 363 GMU Spring 2005 28
C Sample
#include <stdio.h>main() { int fnm1,fnm2, fn,n,i; scanf(“%d”,&n); if (n <= 1) printf(“%d\n”, n) /* F0 = 0 and F1 = 1*/ else { /* compute Fn*/ fnm2 = 0; fnm1 = 1; for (i = 2; i<=n ;++i) { fn = fnm1 + fnm2; fnm2 = fnm1; fnm1 = fn; } printf(“%d\n”,fn); }}
![Page 29: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/29.jpg)
CS 363 GMU Spring 2005 29
Important ALGOL Descendants
• Modula-2 - mid-1970s (Wirth)– Pascal plus modules and some low-level features
designed for systems programming• Modula-3 - late 1980s (Digital & Olivetti)
– Modula-2 plus classes, exception handling, garbage collection, and concurrency
• Oberon - late 1980s (Wirth)– Adds support for OOP to Modula-2 – Many Modula-2 features were deleted (e.g., for
statement, enumeration types, with statement, non-integer array indices)
![Page 30: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/30.jpg)
CS 363 GMU Spring 2005 30
Prolog - 1972
• Developed at the University of Aix-Marseille, by Comerauer and Roussel, with some help from Kowalski at the University of Edinburgh
• Applications in AI, DBMS• Based on formal logic• Non-procedural• Can be summarized as being an intelligent
database system that uses an inferencing process to infer the truth of given queries
• Inefficient execution
![Page 31: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/31.jpg)
CS 363 GMU Spring 2005 31
Prolog Sample
parent(X,Y) :- mother(X,Y). parent(X,Y) :- father(X,Y). sibling(X,Y) :- mother(M,X), mother(M,Y),
father(D,X), father(D,Y),X \== Y. haschildren(X) :- parent(X,_). grandparent(X,Y) :-
parent(X,M),parent(M,Y). cousin(X,Y) :-
parent(A,X),parent(B,Y),sibling(A,B).
mother(anne,mary). mother(anne,liz). mother(anne,susan). mother(anne,virginia). mother(elizabeth,russ). mother(mabel,anne). father(james,zelie). father(james,harry). father(james,ned). father(john,will). father(john,russell). father(jim,rachel). father(jim,maggie). father(tim,patrick).
grandparent(anne,Y).
![Page 32: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/32.jpg)
CS 363 GMU Spring 2005 32
Ada - 1983 (began in mid-1970s)
• Huge design effort, involving hundreds of people, much money, and about eight years
• Environment: More than 450 different languages being used for DOD embedded systems (no software reuse and no development tools)
• Named for Ada Lovelace (1815-1851) – first programmer (worked with Charles Babbage).
![Page 33: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/33.jpg)
CS 363 GMU Spring 2005 33
Ada• Contributions:
– Packages - support for data abstraction– Exception handling - elaborate – Generic program units– Concurrency - through the tasking model
• Comments:– Competitive design– Included all that was then known about software engineering
and language design– First compilers were very difficult; the first really usable
compiler came nearly five years after the language design was completed – Compilers had to be ‘validated’
– Strong typechecking
![Page 34: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/34.jpg)
CS 363 GMU Spring 2005 34
Ada
• Ada 95 (began in 1988)– Also designed by committee– Support for OOP through type derivation– Better control mechanisms for shared data
(new concurrency features)– More flexible libraries
![Page 35: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/35.jpg)
CS 363 GMU Spring 2005 35
Ada Sample
package ArrayCalc is type Mydata is private; function sum return integer; procedure setval(arg:in integer); private size: constant:= 99; type myarray is array(1..size) of
integer; type Mydata is record val: myarray; sz: integer := 0; end record; v: Mydata; end;
package body ArrayCalc is function sum return integer is temp: integer; -- Body of function sum begin temp := 0; for i in 1..v.sz loop temp := temp + v.val(i); end loop; v.sz:=0; return temp; end sum; procedure setval(arg:in integer) is begin v.sz:= v.sz+1; v.val(v.sz):=arg; end setval; end;
with Text_IO; use Text_IO; with ArrayCalc; use ArrayCalc; procedure main is k, m: integer; begin -- of main get(k); while k>0 loop for j in 1..k loop get(m); put(m,3); setval(m); end loop; new_line; put("SUM ="); put(ArrayCalc.sum,4); new_line; get(k); end loop; end;
![Page 36: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/36.jpg)
CS 363 GMU Spring 2005 36
Smalltalk - 1972-1980
• Developed at Xerox PARC, initially by Alan Kay, later by Adele Goldberg
• First full implementation of an object-oriented language (data abstraction, inheritance, and dynamic type binding)
![Page 37: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/37.jpg)
CS 363 GMU Spring 2005 37
C++ - 1985
• Developed at Bell Labs by Stroustrup
• Evolved from C and SIMULA 67 • Facilities for object-oriented programming, taken
partially from SIMULA 67, were added to C• Also has exception handling• A large and complex language, in part because it
supports both procedural and OO programming• Rapidly grew in popularity, along with OOP• ANSI standard approved in November, 1997
![Page 38: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/38.jpg)
CS 363 GMU Spring 2005 38
C++ Related Languages
• Eiffel - a related language that supports OOP– (Designed by Bertrand Meyer - 1992)– Not directly derived from any other language– Smaller and simpler than C++, but still has most of
the power
• Delphi (Borland)– Pascal plus features to support OOP– More elegant and safer than C++
![Page 39: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/39.jpg)
CS 363 GMU Spring 2005 39
Java (1995)
• Developed at Sun in the early 1990s
• Based on C++– Significantly simplified (does not include struct, union, enum, pointer arithmetic, and half of the assignment coercions of C++)
– Supports only OOP– Has references, but not pointers– Includes support for applets and a form of
concurrency
![Page 40: CS 363 Comparative Programming Languages](https://reader036.fdocuments.in/reader036/viewer/2022062309/5681518b550346895dbfc2ab/html5/thumbnails/40.jpg)
CS 363 GMU Spring 2005 40
Scripting Languages
• JavaScript– HTML-embedded at client side and executed by the
client (i.e. web browser)– create dynamic HTML documents
• PHP– HTML enabled server side– Interpreted by server when a document in which it is
embedded is requested.– Output of interpretation is HTML that replaces the
PHP