8 Programming Languages - 2 PDF

7/12/2007
Babbage initiated programmable

computers
Invented the difference engine
Polynomial
y actions
Part I Using finite differences
Supported programmable
output formatting!
Amir Vaxman
Still not a freely programmed
device…
7/12/2007 1 7/12/2007 2
Born Augusta Ada King, daughter of Herman Hollerith encoded train

Lord Byron timetables on punched cards.
Known for having written a First usage of codes to express
description
p of Babbage's
g early
y information separately.
p y
mechanical GP computer
An adept scientific author, she
devised a method to compute
Bernoulli’s numbers.
7/12/2007 3 7/12/2007 4
Hollerith Got the idea from train

conductor punch tickets
Used to read and collate the Introduced by Church and Kleene in the
American census of 1890 (19)30’s.
The machine originated with A formal system – a logical language – defining
Joseph-Marie Jacquard in his the set of computable
p functions.
textile factory Equivalent to the Turing Machine formalism
Examples (f is the incremental function)

The CTR (later: IBM) census PLUS := λ m n f x. n f (m f x)
machine utilized these cards MULT := λ m n. m (PLUS n) 0,
7/12/2007 5 7/12/2007 6
1
7/12/2007
Turing is considered the father of A machine that implements

computer science. Turing’s universal Machine
Invented the idea of an Algorithm, The separations between
and the notions of computability
p y CPU, CU and Memoryy
Both Turing and Church proved that allows for general purpose
Hilbert’s Entscheidungsproblem programming
has a negative answer.
Can any truth be computationally

acknowledged? Guess not!
7/12/2007 7 7/12/2007 8
Konrad Zuse Built the Z3 – the first German: “Plan Calculus”

general purpose program-stored First high-level non-Von-Neumann
computer.
“programming language”
Proved to be Turing complete in 1998.
A set of notions invented by Zuse
Was never implemented..
P1 max3 (V0[:8.0],V1[:8.0],V2[:8.0]) => R0[:8.0]
max(V0[:8.0],V1[:8.0]) => Z1[:8.0]
max(Z1[:8.0],V2[:8.0]) => R0[:8.0]
END
P2 max (V0[:8.0],V1[:8.0]) => R0[:8.0]

V0[:8.0] => Z1[:8.0]
(Z1[:8.0] < V1[:8.0]) -> V1[:8.0] => Z1[:8.0]
Z1[:8.0] =>R0[:8.0]
7/12/2007 9 7/12/2007 END 10
Invented by Mauchly, and implemented for the Developed during the 50’s
BINAC computer. Mapped human understandable code to
A “Hand Compiled” Language machine code – usually 1-to-1
correspondence.
p
Architecture dependant.
X3 = (X1+Y1)/X1*Y1 =>
Examples:
X3 03 09 X1 07 Y1 02 04 X1 =>
MIPS
07Y10204X1Y1.
Sun SPARC
0000X30309X1
PDP 11
7/12/2007 11 7/12/2007 12
2
7/12/2007
Noam Chomsky invented generative BNF is a metasyntax used to describe formal

languages.
grammars. i.e. a method to parse and realize
Was developed to express the context-free grammars.
strings.
Was used to create ALGOL.
He also created the Chomsky y Hierarchy
y Example (U.S. postal address):
<postal-address> ::= <name-part> <street-address> <zip-part>
<name-part> ::= <personal-part> <last-name> <opt-jr-part>
<EOL> | <personal-part> <name-part> <EOL> <personal-part>
::= <first-name> | <initial> "."
<street-address> ::= <opt-apt-num> <house-num> <street-name>
<EOL>
<zip-part> ::= <town-name> "," <state-code> <ZIP-code> <EOL>
7/12/2007 13 7/12/2007 14
A few languages set the basic template for

known languages today. FORmula TRANslator.
Fortran Invented by IBM team lead
ALGOL by John W. Backus.
COBOL Not the first high-level
Lisp programming language, nor
Simula the first compiled language,
but the first successful one.
Fathered GOTO languages
(such as BASIC)
7/12/2007 15 7/12/2007 16
ALGOrithmic COmmon Business-

Language Oriented Language.
Designed specifically Still in active use! Mostly
for scientific for banking and (old) DB
calculations. accounting.
ti
Did not support local
Structure similar to C
variables, recursion,
Like Fortran – dynamic memory
machine independent allocation, or structured
programming constructs.
7/12/2007 17 7/12/2007 18
3
7/12/2007
LISt Processing The first language to

A family of functional programming languages. utilize the ideas of
Built as a model to utilize Church’ λ-calculus. Object-Oriented
Fundamental operations
p CAR ((head of list)) and Programming,
CDR (tail of list) originate in the structure of the introducing objects,
IBM 704 classes, garbage
collection and so
Examples: forth.
((lambda (arg) (+ arg 1)) 5) – Evaluates to 6
(append '(1 2) '(3 4)) - Output: (1 2 3 4)
7/12/2007 19 7/12/2007 20
Some languages utilized the An Array Programming language.

ideas of these fundamental
languages. May be considered the father of MATLAB..
BASIC: A tutorial language Used incomprehensible characters.
which became popular in
PCs (and in ATARI!)
because of its simplicity. The following example assigns the set of
Inserting lines in the middle primes in the range [1,R] to the array PRIMES!
was a headache..
Not all implementations PRIMES : (~ R ∈ R°.xR ) / R ← 1 ↓ R
supported GOSUB
recursion.
7/12/2007 21 7/12/2007 22
Was widely used as a tutorial language for 1st With the development of languages, several
semester students. principles guided the needs:
Totally free-form – Application vs. system programming
No reserved keywords. Imperative languages (OOP or non-OOP), functional
languages, logic.
Semantics: scopes, recursion, encapsulation,
modularity, platform-independence
Memory abstraction
Type checking
Compiled vs. interpreted.
7/12/2007 23 7/12/2007 24
4
7/12/2007
A basic part of Turing- There are many variants, some are newer.
completeness (can be Call-by-Value – most common, used in C and
realized with loops) scheme, for example. The expression is
Had to submit to the evaluated and then ppassed as argument.
g
invention of the function call Call-by-reference – using “L-Value”. Used by
stack. most modern languages, and some middle
Early languages, like ones (e.g. ML, and to some extent FORTRAN).
FORTRAN on the HP 210
computer did not support
recursion.
7/12/2007 25 7/12/2007 26
The same syntax may cause different effect in Example #1:

different languages (and sometimes, in the (String) x
same language with a different compiler!) Same syntax in C++, Java
Commonly-affected
y areas: Semantics:
Order of evaluation in an IF statement C++: Blind Cast (always succeeds)
Default initialization of variable. Java: Checked cast (may fail at run-time)
Variable casting (example in next slide).
7/12/2007 27 7/12/2007 28
”Ignoring inessential details” A mapping from integers onto { 0, 1 }

This is a bit-by-bit view
A computer is a complex
The programming model:
machine
Read a bit (from a location in memory)
Optionally change its value (0 <--> 1)
Many views of computers Write a bit (to a location in memory)
(of various level of abstraction)
Very difficult for most tasks
A programming language:
A simple yet comprehensive
view
7/12/2007 29 7/12/2007 30
5
7/12/2007
A computation - Reading/Writing values A computation – Evaluating a formula

from/into cells Almost like in the 7-th grade...
A Turing-machine based approach ... but with recursion
Additional abstraction evolved A Lambda-calculus based approach
Stack, types, ... Example: computing next factorial number
Example: Computing factorial numbers f (n) = nf (n − 1)
For n=1 to k
temp = n
x = x * temp
End for
7/12/2007 31 7/12/2007 32
A computation – Finding all tuples which satisfy Functional

certain conditions Logical
Imperative
A Relational-algebra based approach Object-oriented
j
... but with recursion
Example: Computing next factorial number
( x, n) ∈ F ⇒ ( x ⋅ (n + 1), n + 1) ∈ F
7/12/2007 33 7/12/2007 34
35/57
Some of the languages from this

HoPL: The History Of
decade are still live and kicking
Programming Languages E.g.: ML, C, SQL, Smalltalk
Older languages are rarely used
today
Part 2
Itay Maman
236801 Seminar lecture – 9 Jul 2007
36/57
6
7/12/2007
Designer: Niklaus Wirth

function fib(N : integer) : longint;
Paradigm: Imperative
var
Type system: static, strong tmp, first, second : integer;
Based on: Algol begin
while n <> 0 do
Intended to be used as a teaching language begin
n := n - 1;
First Pascal compiler was written in Fortran tmp = first
i + second;
Subsequent version were bootstrapped first = second;
second = tmp;
end
fib := first;
end
37/57 38/57
Designer: Dennis Ritchie 1973- First Robust implementation

Paradigm: Imperative 1978- ”The C Programming Language” (AKA: K&R)
Type system: static, weak The de-facto standard
Based on: ALGOL, Assembly No type checking of parameters

Old style:
Designed for system-programming tasks int main(argc, argv)

int argc; char **argv; { ... }
Till 1973 the Unix kernel was written in assembly
y ((PDP-7,,
11) 1983- C's ANSI standard committee formed
1988- 2nd edition published
Philosophy: 1989- ANSI standard ratified (AKA: C89)
Simple language => simple compiler function prototypes
Many language constructs are based on machine void pointers/functions, enum types
instructions 1990- ANSI C adopted by ISO
Fine-grain control over memory, I/O AKA: C90 ( == C89)
Minimal run-time support
39/57 40/57
Designers: Alan Kay, Dan Ingalls, Adele Goldberg

Paradigm: Object-oriented
Type system: dynamic, strong
Based on: Simula, Lisp
Class: CookieMonster
Philosophy: Superclass: Monster
Category: Sesame Street
Everything is an object
Instance variables: state hunger
Program is a data structure in memory
à The program can examine/modify itself nag
Three primitive constructs: | item |
item := self askForCookie.
send a message to a receiver
(item isKindOf: Cookie)
return a value ifTrue: [self eat: item]
assign a value to a variable ifFalse: [self complainAbout: item].
41/57 42/57
7
7/12/2007
Designers: Alain Colmerauer pred('Washington', 'Adams').

Paradigm: Logic programming pred('Adams', 'Jefferson').
Type system: varies pred('Jefferson', 'Madison').
pred('Madison', 'Monroe').
pred('Monroe', 'Adams').
Designed for AI tasks (searching in trees/graphs)
Philosophy: before(X,Z) :- pred(X,Z).
A rule defines an implication (right implies left) ( , ) :- pred(X,Y),
before(X,Z) p ( , ), before(Y,Z).
( , )
Predicate – A set of rules with the same left-hand side term
before(A,'Madison')?
Predicate invocation: <'Jefferson'>
à Returns all tuples matching the value passed-in <'Adams'>
<'Washington'>
43/57 44/57
Designer: Robin Milner

Paradigm: Functional
Large scale programs are here
Type system: static, strong, inferred Language features for coping
with the complexity of the code
A functional language w/ static type checking
Lisp is functional but dynamically typed
Not purely functional =>> Allows side effects
fun step x y 0 = x
| step x y n = step y (x+y) (n-1);
val fib = step 0 1;
45/57 46/57
Designer: Jean Ichbiah, S. Tucker Taft function fib(n : integer) return integer is
Paradigm: Imperative f : integer := 0;
Type system: static, strong s : integer := 1;
tmp : integer;
Based on: Algol 68, Pascal
begin
for i in 1..n loop
Developed for the US Department of Defence tmp := f + s;
Requirements f :=
: s;
Modular, safe, high level of abstraction
s := tmp;
end loop;
High maintainability return f;
Should replace ad-hoc hardware-dependent languages end fib;
à Frequent in embedded systems
47/57 48/57
8
7/12/2007
Designed using the ”waterfall” approach Designer: Bjarne Stroustrup

The same design procedure as in weapon systems Paradigm: Object-oriented
Type system: static, weak
1975- Working group for a new computer language formed Based on: C, Simula
1977- Ideal language specification, ”Ironman”, published
1979- The Green proposal is chosen Philosophy:
1980
1980- Ada
Ada'ss reference manual approved C
C'ss performance
1983- First implementation validated Simula's features
+ Ada becomes an ANSI standard Three major stages: 1985, 1989, 1998 (First standard)
1987- DoD adopts the Ada mandate Next version: C++0x (...Hopefully x <= 9)
Requires the use of Ada in projects with > 30% new code Drawbacks: C, poor standard library, no GC
1997- DoD adopts the COTS policy
Commercial Off-The-Shelf technologies
49/57 50/57
Designer: Bertrand Meyer

Type system: static, strong
Based on: Simula, Ada
Software Engineering oriented

Design by Contract
Automatic documentation
51/57 52/57
fib (n: INTEGER): INTEGER is

require -- Design By Contract: Performance is less of a problem
pre_fib: n > 0 -- Precondition
local
i, tmp, f, s: INTEGER Hybrid software systems
do Interoperability
from
Rapid prototyping
f := 0; s := 1; i := 1;
until
i = n; The Internet
loop
tmp := f + s; f := s; s := tmp; Web servers
i = i + 1; Browser-side programs
end; Accessibility to open source libraries
Result := s;
end;
53/57 54/57
9
7/12/2007
Designer: Simon Peyton-Jones, Paul Hudak, Philip Wadler module Main where
Paradigm: Functional import System.Environment
Type system: static, strong, inferred
Based on: ML, Miranda fib = 1 : 1 : zipWith (+) fib (tail fib)
main = do
Philosophy: Purely functional args <- getArgs
No side effects (unless you ask nicely) print (fib !! (read(args!!0)-1))
(read(args!!0) 1))
2D grammar
Lazy evaluation: fib is recursive but has no if's
do construct for sequential execution
Type inference
55/57 56/57
Designer: James Gosling

Is Java's popularity due its OO nature?
Type system: static, strong Powerful runtime system
Based on: C++, Smalltalk, Eiffel JVM, JIT, GC
Philosophy A huge standard library

Compile once run anywhere Networking,
N t ki JDBC
JDBC, GUI
GUI, Th
Threading,
di C
Cryptography,
t h ...
Safe yet dynamic (applets)
=>Internet ready! Enterprise Applications
J2EE, hotswapping
As of 2006, mostly open sourced (!)
Unicode
57/57 58/57
Interpreters:
e p e e s: Thee Resurrection
esu ec o
59/57 60/57
10
7/12/2007
1987- Perl
1990- Python
1991- Visual Basic
1995- Ruby
e p e e s: Thee Resurrection
Interpreters: esu ec o 1995- Javascript
1995
Coming soon to an IDE near you 1997- PHP
=> 2005- Ajax
61/57 62/57
Designer: Yukihiro Matsumoto

Paradigm: Object-oriented class Someone
Type system: dynamic, strong def initialize(name)
Based on: Smalltalk, Lisp, Python @name = name
end
end
Philosophy: ”programmer productivity and fun”
b = S
Someone.new("Bart")
("B t")
Highlights
Implicit declaration of setter, getters # puts b.name # Error: undefined method 'name'
Mixings, open classes/objects
class Someone
RoR: Ruby-on-Rails attr_accessor :name
à Framework for DB-based web application end
puts b.name # Output: 'Bart'
63/57 64/57
Designer: Rasmus Lerdorf .

Paradigm: Imperative .
Type system: dynamic, strong
Based on: C, Perl .
Highlights </languages>
Server side scripting <IDEs.abridged>
<IDEs abridged>
HTML text embedded within the source code
PHP = PHP: Hypertext Preprocessor .
.
<b>Server
<?php .
echo ' Side '
?>
Scripting</b>
65/57 66/57
11
7/12/2007
1976-VI 1976-Emacs
67/57 68/57
1986-GDB 1987-Turbo Pascal 4
69/57 70/57
1991-XEmacs 1994-DDD
71/57 72/57
12
7/12/2007
1996-Squeak 2002-Visual Studio .NET
73/57 74/57
2007-Eclipse 3.2.2
.
.
.
</IDEs.abridged>
<conclusions>
.
.
.
75/57 76/57
Productivity Machine code

Performance Virtual machine
p
Interpreter
Seems to be decided in favor of productivity

Strongly related to the question of portability...
77/57 78/57
13
7/12/2007
1) Machine specific languages: Assembly

Almost no portability
Static
Dynamic
2) Compiler + O/S isolate from hardware: Algol, C
Source compatibility on same O/S
Binary compatibility on same O/S & CPU
Currently, the hottest debate
3) Comprehensive standard libraries: Eiffel Manifested by the ”performance is not an issue”
Source compatibility on all platforms claim
4) Virtual machine: Java, Smalltalk

Full source + binary compatibility
79/57 80/57
No absolute answer
Functional
Too many contradicting factors
Imperative
Too many players (languages)
Very easy to produce a new language
Extremely difficult to measure the market
A 71-years old debate Still, here are a few attempts...
81/57 82/57
Source:
83/57 http://www.cs.berkeley.edu/~flab/languages.html Source:
84/57 http://radar.oreilly.com/archives/2007/03/programming_lan.html
14
7/12/2007
Source:
85/57 http://www.tiobe.com/index.htm?tiobe_index Source:
86/57 April 2005 data of http://www.tiobe.com
Software is cheaper the Hardware http://www.cs.fit.edu/~ryan/ada/ada-hist.html

http://www.tiobe.com/index.htm?tiobe_index
(to a certain degree)
http://radar.oreilly.com/archives/2007
A researcher can easily develop http://thomer.com/vi/vi.html
new language constructs http://www.squeak.org/Smalltalk/
=> Wealth of languages http://acs.ucsd.edu/info/dbx.debug.php
Compared to hardware technologies http://www.research.att.com/~bs/homepage.html
Each making one small step forward http://pascalprogramming.byethost15.com
http://www.levenez.com/lang/history.html
=> Languages evolve
http://en.wikipedia.org
It is hard to detect the major http://st-www.cs.uiuc.edu/balloon.html
trends http://www.sppn.nl/logo.html
87/57 88/57
.
http://www.juixe.com/techknow/index.php/2006/06/15/mixins-
in-ruby .
http://www.scriptol.org/fibonacci-any-programming-
language.html .
http://en.wikipedia.org/wiki/History_of_programming_language
s </conclusions>
http://www.whitehouse.gov/history/presidents/chronological.ht
http://www whitehouse gov/history/presidents/chronological ht </lecture>
ml
http://www.dcs.ed.ac.uk/home/stg/NOTES/node59.html
89/57 90/57
15
7/12/2007
91/57
16

8 Programming Languages - 2 PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

8 Programming Languages - 2 PDF

Încărcat de

Drepturi de autor:

Formate disponibile

7/12/2007

 Babbage initiated programmable

 Born Augusta Ada King, daughter of  Herman Hollerith encoded train

 Hollerith Got the idea from train

 Examples (f is the incremental function)

 Turing is considered the father of  A machine that implements

 Can any truth be computationally

 Konrad Zuse Built the Z3 – the first  German: “Plan Calculus”

P2 max (V0[:8.0],V1[:8.0]) => R0[:8.0]

 Noam Chomsky invented generative  BNF is a metasyntax used to describe formal

 A few languages set the basic template for

 ALGOrithmic  COmmon Business-

 LISt Processing  The first language to

 Some languages utilized the  An Array Programming language.

 The same syntax may cause different effect in Example #1:

 ”Ignoring inessential details” A mapping from integers onto { 0, 1 }

 A computation - Reading/Writing values  A computation – Evaluating a formula

 A computation – Finding all tuples which satisfy  Functional

 Example: Computing next factorial number

Some of the languages from this

236801 Seminar lecture – 9 Jul 2007

 Designer: Niklaus Wirth

 Designer: Dennis Ritchie  1973- First Robust implementation

 Based on: ALGOL, Assembly  No type checking of parameters

 Designed for system-programming tasks int main(argc, argv)

 Designers: Alan Kay, Dan Ingalls, Adele Goldberg

 Designers: Alain Colmerauer pred('Washington', 'Adams').

 Designer: Robin Milner

val fib = step 0 1;

 Designed using the ”waterfall” approach  Designer: Bjarne Stroustrup

 Designer: Bertrand Meyer

 Software Engineering oriented

fib (n: INTEGER): INTEGER is

 Designer: James Gosling

 Philosophy  A huge standard library

 => 2005- Ajax

 Designer: Yukihiro Matsumoto

puts b.name # Output: 'Bart'

 Designer: Rasmus Lerdorf .

1986-GDB 1987-Turbo Pascal 4

1996-Squeak 2002-Visual Studio .NET

 Productivity  Machine code

Seems to be decided in favor of productivity

1) Machine specific languages: Assembly

4) Virtual machine: Java, Smalltalk

 Software is cheaper the Hardware http://www.cs.fit.edu/~ryan/ada/ada-hist.html

S-ar putea să vă placă și

Babbage initiated programmable

Born Augusta Ada King, daughter of Herman Hollerith encoded train

Hollerith Got the idea from train

Examples (f is the incremental function)

Turing is considered the father of A machine that implements

Can any truth be computationally

Konrad Zuse Built the Z3 – the first German: “Plan Calculus”

Noam Chomsky invented generative BNF is a metasyntax used to describe formal

A few languages set the basic template for

ALGOrithmic COmmon Business-

LISt Processing The first language to

Some languages utilized the An Array Programming language.

The same syntax may cause different effect in Example #1:

”Ignoring inessential details” A mapping from integers onto { 0, 1 }

A computation - Reading/Writing values A computation – Evaluating a formula

A computation – Finding all tuples which satisfy Functional

Example: Computing next factorial number

Designer: Niklaus Wirth

Designer: Dennis Ritchie 1973- First Robust implementation

Based on: ALGOL, Assembly No type checking of parameters

Designed for system-programming tasks int main(argc, argv)

Designers: Alan Kay, Dan Ingalls, Adele Goldberg

Designers: Alain Colmerauer pred('Washington', 'Adams').

Designer: Robin Milner

Designed using the ”waterfall” approach Designer: Bjarne Stroustrup

Designer: Bertrand Meyer

Software Engineering oriented

Designer: James Gosling

Philosophy A huge standard library

=> 2005- Ajax

Designer: Yukihiro Matsumoto

Designer: Rasmus Lerdorf .

Productivity Machine code

Software is cheaper the Hardware http://www.cs.fit.edu/~ryan/ada/ada-hist.html