Programming Languages

What is a Programming
Language?
1.2
 A formal language for describing computation
 A “user interface” to a computer
 Syntax + semantics
 Compiler, or interpreter, or translator
 A tool to support a programming paradigm
A programming language is a notational
system for describing computation in a
machine-readable and human-readable form.
— Louden

What is a Programming
Language? (II)
1.3
A programming language is a tool for
developing executable models for a
class of problem domains.
consists of words, symbols, and
rules for writing a program

Language Definition
4
Syntax
set of rules that define form
Grammar or syntax diagram
Semantics
specify meaning of well-formed programs
formal semantics: pre- and post- conditions
Lexical Rules
rules for determining tokens
tokens: syntactic units (e.g., number,
identifier, semicolon, equals)
Syntactic Rules
Grammar: set of productions
productions: terminals (tokens) and non
terminals

Programming Paradigms
1.5
Paradigms
How do different language paradigms
support problem-solving?
Semantics
How can we understand the semantics
of programming languages?
Foundations
What are the foundations of
programming languages?

Paradigms of Programming?
6
There are several ways to think about computation:
a set of instructions to be executed
a set of expressions to be evaluated
a set of rules to be applied
a set of objects to be arranged
a set of messages to be sent and received

Some Programming Paradigms
7
 Procedural
◦ examples: C, Pascal, Basic, Fortran
 Functional
◦ examples: Lisp, ML
 Object-oriented
◦ examples: C++, Java, Smalltalk
 Rule-based (or Logic)
◦ example: Prolog

Procedural Languages
8
Focus is on writing good functions and procedures
use the most appropriate implementation and
employ correct efficient algorithms
Describes computation in terms of
Statements that change a program state
Explicit control flow
Synonyms
Imperative programming
Operational

Procedural Languages
9
Program State
Collection of Variables and their values
Contents of variables change
Expression (to be computed) : a + b + c
Recipe for Computation
Account for machine limitations
Intermediate Location
T := a + b; T := T + c;

Functional Languages
10
Program as a collection of (math) functions
functional programming is a programming
paradigm that treats computations as the
evaluation of mathematical functions and avoids
state.
It emphasizes the application of functions, in
contrast to the Procedural style, which
emphasizes changes in state.

Procedural V/s Functional Languages
11
tsum := 0;
i := 0;
while (i < n) do
i := i + 1;
tsum := tsum + I
od
func sumto(n: int): int;
if n = 0
then 0
else n + sumto(n-1)
fi
endfunc;
Procedural Style Functional Style

12
Object-Oriented Concepts
 Data Abstraction (specifies behavior)
 Encapsulation (controls visibility of names)
 Polymorphism (accommodates various
implementations)
 Inheritance (facilitates code reuse)
 Modularity (relates to unit of compilation)

Object-Oriented Concepts
13
Abstraction –
a concept or idea not associated with any specific
instance.
Data abstraction allows handling data bits in meaningful
ways. For example, it is the basic motivation behind data
types. One can regard the notion of an object as an
attempt to combine abstractions of data and code.
Encapsulation:
Encapsulation of data and operations on that data.
The data and operation to be performed are written
together within same class.

Object-Oriented Concepts
14
Polymorphism:
Overloading of functions and operators
Same function may be found in two or more classes
Function with the same name appears in one class with different
sets of arguments
Inheritance (facilitates code reuse)
Code from one class can be reuse in another class by deriving a
relationship between parent class and child class.
Modularity is a software design technique that increases the
extent to which software is composed of separate,
interchangeable components called modules by breaking down
program functions into modules, each of which accomplishes one
function and contains everything necessary to accomplish this

Why so many?
15
 Most important: the choice of paradigm
(and therefore language) depends on
how humans best think about the
problem
 Other considerations:
◦ efficiency
◦ compatibility with existing code
◦ availability of translators

Lots of Languages
© Oscar Nierstrasz Safety Patterns 16
 There are many programming languages out
there
 Lots of other PL-like objects
◦ document languages, e.g. LaTeX,
Postscript
◦ command languages, e.g. bash, MATLAB
◦ markup languages, e.g. HTML and XML
◦ specification languages, e.g. UML

Generations of Programming
Languages
1GL: machine codes
2GL: symbolic assemblers
3GL: (machine-independent) imperative
languages (FORTRAN, Pascal, C ...)
4GL: domain specific application
generators
5GL: AI languages …
Each generation is at a higher level of
abstraction
1.1
7

How do Programming Languages Differ?
Common Constructs:
 basic data types (numbers, etc.); variables;
expressions; statements; keywords; control
constructs; procedures; comments; errors ...
Uncommon Constructs:
 type declarations; special types (strings,
arrays, matrices, ...); sequential execution;
concurrency constructs; packages/modules;
objects; general functions; generics; modifiable
state; ...
1.1
8

Programming Paradigms
A programming language is a problem-solving tool.
Imperative style:
program = algorithms + data
good for decomposition
Functional style:
program = functions o functions
good for reasoning
Logic programming style:
program = facts + rules
good for searching
Object-oriented style:
program = objects + messages
good for modeling(!)
Other styles and paradigms: blackboard, pipes and filters,
constraints, lists, ...
1.1
9

A Brief Chronology
Early 1950s ―order codes‖ (primitive assemblers)
1957 FORTRAN the first high-level programming language
1958 ALGOL the first modern, imperative language
1960 LISP, COBOL Interactive programming; business programming
1962 APL, SIMULA the birth of OOP (SIMULA)
1964 BASIC, PL/I
1966 ISWIM first modern functional language (a proposal)
1970 Prolog logic programming is born
1972 C the systems programming language
1975 Pascal, Scheme two teaching languages
1978 CSP Concurrency matures
1978 FP Backus’ proposal
1983 Smalltalk-80, Ada OOP is reinvented
1984 Standard ML FP becomes mainstream (?)
1986 C++, Eiffel OOP is reinvented (again)
1988 CLOS, Oberon, Mathematica
1990 Haskell FP is reinvented
1990s Perl, Python, Ruby, JavaScript Scripting languages become mainstream
1995 Java OOP is reinvented for the internet
2000 C#
1.2
0

Fortran
History
 John Backus (1953) sought to write programs in conventional
mathematical notation, and generate code comparable to
good assembly programs.
 No language design effort (made it up as they went along)
 Most effort spent on code generation and optimization
 FORTRAN I released April 1957; working by April 1958
 The current standard is FORTRAN 2003
(FORTRAN 2008 is work in progress)
1.2
1

Fortran …
Innovations
 Symbolic notation for subroutines and functions
 Assignments to variables of complex expressions
 DO loops
 Comments
 Input/output formats
 Machine-independence
Successes
 Easy to learn; high level
 Promoted by IBM; addressed large user base
 (scientific computing)
1.2
2

Object-Oriented Languages
History
 Simula was developed by Nygaard and Dahl (early 1960s) in
Oslo as a language for simulation programming, by adding
classes and inheritance to ALGOL 60
 Smalltalk was developed by Xerox PARC (early 1970s) to
drive graphic workstations
1.2
3
Begin
while 1 = 1 do begin
outtext ("Hello World!");
outimage;
end;
End;
Transcript show:'Hello World';cr

Object-Oriented Languages
Innovations
 Encapsulation of data and operations
(contrast ADTs)
 Inheritance to share behaviour and interfaces
Successes
 Smalltalk project pioneered OO user
interfaces
 Large commercial impact since mid 1980s
 Countless new languages: C++, Objective C,
Eiffel, Beta, Oberon, Self, Perl 5, Python,
Java, Ada 95 ...
1.2
4

Issues for all Languages
25
 Can it be understood by people and
processed by machines?
◦ although translation may be required
 Sufficient expressive power?
◦ can we say what needs to be said, at an
appropriate level of abstraction?

Translation
26
 Compilation
◦ Translate into instructions suitable for some other (lower
level) machine
◦ During execution, that machine maintains program state
information.
◦ Translate the program into machine code at once. That
Machine code then executes and perform similar
function as interpreter.
 Interpretation
◦ May involve some translation
◦ Interpreter maintains program state
◦ Translate, Analyze & Execute program instruction by
instruction.

Trade-offs
27
 Compilation
◦ lower level machine may be faster, so
programs run faster
◦ compilation can be expensive
◦ examples: C (and Java?)
 Interpretation
◦ more ability to perform diagnostics (or
changes) at run-time
◦ examples: Basic, UNIX shells, Lisp

Variable
28
A named location in memory that can hold a value
Formally, a 5-tuple:
1. name
2. scope
3. type
4. l-value
5. r-value

Variable
 Name and Scope
Declaration
Identifier rules and significant characters
Scope
range of instructions over which variable name is known.
 Type:
Consists of
Set of values
Operations
Built-in/Primitive vs User-defined types
29

Variable
 l-value: address/location
◦ lifetime
◦ memory allocation
 r-value: contents/encoded value
◦ initialization
◦ constants
30