Programming Language
Concepts
Tatjana Petkovi
[email protected]
1
Programming Language
Pragmatics
Michael Scott
http://www.cs.rochester.edu/u/
scott/pragmatics/
2
Contents
1 Introduction
2 Programming Language Syntax
2.1 Specifying Syntax
2.2 Recognizing Syntax
2.3* Theoretical Foundations
3 Names, Scopes, and Bindings
3.1 The Notion of Binding Time
3.2 Object Lifetime and Storage
Management
3.3 Scope Rules
3.4 The Binding of Referencing
Environments
3.5 Overloading and Related Concepts
3.6 Naming-Related Pitfalls in Language
Design
4
4 Semantic Analysis
5 Assembly-Level Computer Architecture
6 Control Flow
6.1 Expression Evaluation
6.2 Structured and Unstructured Flow
6.3 Sequencing
6.4 Selection
6.5 Iteration
6.6 Recursion
5
7 Data Types
7.1 Type Systems
7.2 Type Checking
7.3 Records (Structures) and Variants
(Unions)
7.4 Arrays
7.5 Strings
7.6 Sets
7.7 Pointers and Recursive Types
7.8 Lists
6
8 Subroutines and Control Abstraction
8.1 Review of Stack Layout
8.2 Calling Sequences
8.3 Parameter Passing
8.4 Generic Subroutines and Modules
8.5 Exception Handling
8.6 Coroutines
9 Building a Runnable Program
10 Data Abstraction and Object
Orientation
11 Alternative Programming Models:
Functional and Logic Languages
12 Concurrency
13 Code Improvement
8
Introduction
Computing devices:
Mechanical:
Fingers, abacus
Blaise Pascal 1642 +Gottfried Wilhelm von Leibnitz +-*/
Charles Babbage 1832 programmable
Electronical:
COLOSSUS 1943
ENIAC (Electronic Numerical Integrator and Computer)
1946
9
Machine language
binary system - John Von Neumann
GCD for MIPS R4000
10
coding in the true meaning of the word
code is not
reusable: monolithic structure
relocatable: consider adding one instruction in
the middle
readable
practically impossible to create large
programs
11
Assembly languages
assembler
GCD
12
Assembler
translator from symbolic language to machine
language (one-to-one mapping)
tool to assemble the symbolic program in the
machine
Advantages
relocatable & reusable (copy) programs
macro expansion
first step towards higher-level programming
larger programs (like operating systems)
possible
13
But,
each kind of computer has its own
programmers must learn to think like
computers
maintenance of larger programs is difficult
Higher-level languages
portability
natural notation (for anything)
support to software development
14
Machine independent languages
Fortran 1956
Cobol 1959
Algol 1958, 1960
...
compilers
15
16
Fortran (Mathematical Formula Translator)
Backus, 1957
IBM
compilation instead of translation
language for scientific computing
most important task in those days
efficiency important to replace assemblers
introduced many important language
concepts that are still in use
Fortran 99 array operations
17
Cobol (Common Business Oriented Language)
1959
COBOL commetee (IBM, Honeywell, FlowMatic,...)
at some point 60% of all business applications
18
Algol 60 (Algorithmic Language)
the first European language
never very present in practice
introduced modern concepts
big influence on further development
Ada
Basic (Beginers All-purpose Symbolic
Instruction Code)
1961
popular in the eighties
Visul Basic, Visual Basic for Application
19
PL/1 (Programming Language One)
general-purpose
meant to replace Fortran, Cobol and Algol
Algol 68
the same idea of universality
too complex
hardware could not support them
Algol 68 compiler never completely realized
20
Pascal
N. Wirth
late sixties
simple to learn, easy to use, ...
introduces subrange and enumeration types,
unified structures, unions
Pascal-like notion
Turbo Pascal
free availability
Modula
21
an analysis from the beginning of seventies
for the next 15-20 years predicted
software cost not in proportion to hardware cost
about 450 languages
ADA
1983
new attempt for the universal language
US DOD
too big expectations never fulfilled
theoreticaly significant, data types, moduls,
abstraction, concurrency, exception handling
22
C
1970
UNIX, system software programming
1978 D. M. Ritchi and B. W. Kernighan
1983 ANSI C
close to assembly languages
not reliable, weak type checking, no dynamic
semantic checks
C++
23
object-oriented languages
data abstraction
objects, classes
inheritance, polimorphism
roots in Simula 67
Smalltalk 80, Eiffel, Omega, Oberon, C++,
Delta, Java
visul environment, interactive,
events driven programming: Visual Basic,
Delphi
24
Language classification
imperative
how the computer should solve the problem
first do this, then repeat that, then branch there...
procedural languages (Pascal, C, Basic, ...)
computing via side-effects
Von Neumann architecture (1946)
object-oriented
25
declarative languages
program = description of the problem
a formal statement of what is the problem
closer to humans than computers
functional languages
Lisp, 1958
-calculus, Church 1930
computing without variables
logic programming
predicate logic, Fredge 1871
Prolog, seventies
computing with relations
26
The programming language
spectrum
27
sequential
concurrent
in conjuction with sequential (Fortran, C,...)
explicite (Java, Ada, Modula-3)
28
Why so many languages?
evolution
goto while, case, ... object-oriented
special purposes
symbolic data Lisp
character strings Snobol, Icon
low-level programming C
numeric data Fortran
logic programming - Prolog
personal preference
iteration : recursion
pointers : implicit dereferencing
29
What makes a language successful?
expressive power
ease of use for a novice
Basic, Logo, Pascal, Java, ...
ease of implementation
excellent compilers
Fortran
economics, patronage, inertia
Cobol
programming vs. implementation
conceptual clarity vs. implementation efficiency
30
Language characteristics
formally defined syntax
(grammars, syntax diagrams)
data types
(predefined, others)
data structures
(array, record, file, set)
control
(if, case, for, while)
subroutines
31
modules
abstract data types
data + procedures + functions
closed
concurrency
parallelism
low-level mechanisms
to access registers, memory, format data
exception handling mechanisms
I/O procedures
32
Evaluating languages
readability
more readable less documentation
factors: key words .. modularity degree
simplicity
num = num + 1
num += 1
++num
num++
33
readability (still...)
orthogonality
small number of concepts and ways to combine
them
control flow
structural languages
data structures
records more clear than arrays
syntax
begin .. end, if .. fi (end if)
34
easy of use
depends on the application
simplicity and orthogonality
programmers accept limitted number of new concepts
small numbers of concepts and constructs
abstraction support
emphasses global characteristics
subroutines, modules, classes
expressivity
num = num + 1 or num++
while or for
35
reliability
to decrese number of run-time errors
early binding
data types
explicitly defined
operators types determined
casting
exceptions handling
run-time errors caused by the program or system
aliasing
mutual references to the same memory location
Fortran: equivalence
Pascal: pointers
may cause errors
36
effectivity
of a program
important for real-time systems
of the compiler
important for often modified programs
overall
important for widely used software
37
Why to study programming
languages?
interesting, practical
choose the most appropriate language
scientific applications, system software, embedded
systems, word processor
C, Fortran, Java, Ada, Visual Basic, Modula-2
easier to learn new languages
C C++ Java
Pascal Modula-2
common concepts: types, control, naming, abstraction
38
Our aim is to:
Understand obscure features
C: unions, arrays vs. pointers, separate compilation,
varargs, ...
understanding the basic concepts is a necessity to
understand non-basic ones
Choose the best alternative depending on
implementation costs
alternative ways of doing the same thing
x * x or of x**2
pointer arithmetic or arrays
computation vs. memory (function or table)
things to avoid
Pascal & value parameters for large types
Make good use of the environment
39
Simulate features where they do not exist
Fortran (pre -90)
bad control structures use comments &
programmer discipline
no recursion eliminate recursion
no named constants use variables
C, Pascal
no modules use naming & discipline
Equip with basic knowledge for further
study of language design and
implementation, or interactions of
languages with operating systems
40
Useful in designing command interpreters,
programmable editors, text processors, ...
Many system programs are like languages
command shells
programmable editors
programmable applications
Many system programs are like compilers
read & analyze configuration files and
command line options
Easier to use and design such things once
you know about real languages
41
Compilation and interpretation
42
Interpretation
greater flexibility
better diagnostics
excellent source-level debugger
cope with variables sizes, types, names
write and execute on fly program pieces
(Prolog, Lisp)
Compilation
better performance
saves time, memory
43
a mixture of both
compilation or interpretation?
44
preprocessor (in interpreted languages)
removes comments and white space, forms
tokens, expand abbriviations, identifies highlevel structures
compilation
thorough analysis and nontrivial
transformation
45
examples
Basic, pure interpreted
Fortran, pure compiled
format interpreter
46
preprocessor
removes comments, expands macros, conditional compilation
47
C++
early AT&T compiler
48
Pascal
early compilers:
- a Pascal compiler written in Pascal
the same compiler in P-code
- a P-code interpreter written in Pascal
1. translate (by hand) the P-code interpreter into a
local language
49
still both for Pascal, C, other imperative
late binding
Prolog, Lisp
Java, byte code (interpreter or just-in-time
compiler)
Assembly languages run on interpreter
some compilers produce C-code
translating automaticaly from one nontrivial
language to another
text processors, query language processors
for databases
50
Programming environments
Assemblers, debuggers, preprocessors,
linkers, editors, configuration management
tools
Explicit request of the user (Unix)
Integrated enviroments (Smalltalk, Visual
Studio env.)
51
Overview of compiling
phases
front end
figure out the meaning of the source program
back end
construct target program
52
53
passes
a serialized set of phases
separate programs, input/output files
economic memory use
division such that
front end for more than one machine
back end for more than one language
54
Lexical and Syntax Analysis
program gcd (input,output);
var i , j : integer;
begin
read (i, j);
while i<>j do
if i>j then i := i j
else j := j i;
writeln (i)
end.
55
scanner
lexical analysis
tokens: program, gcd, (, i, ,, j, ), ;, ... , end, .
removes comments, tags tokens with line and
column numbers
parser
syntactic analysis
parse tree
CFG (context-free grammar)
56
program PROGRAM identifier ( identifier
more_identifiers ) ; block .
block labels constants types variables subroutines
BEGIN statement more_statements END
more_identifiers , identifier more_identifiers |
57
58
Semantic Analysis
Intermediate code generation
meaning
recognizes multiple occurances of an
identifier, tracks types of identifiers and
expressions
symbol table
identifier, type, internal structure, scope
59
60
checks that
identifiers defined before used
not used inappropriatelly
correct arguments in subrotine calls
arms in CASE distinct constants
exist return values for functions
semantic action routines invoked by
parser
61
static semantics (at compile time)
dynamic semantics (at run time)
variables in expressions have values
pointers refer to valid objects
array subscript is in the bounds
functions return values
exception if a dynamic check fails
erroneous if a program breaks a rule expensive
to be checked
62
parse tree (concrete syntax tree)
syntax tree (abstract syntax tree)
decorated by attributes, i.e., pointers from
identifiers to their symbolic table entries
intermediate form between front and back
end:
- annotated syntax tree
- traversal of some intermediate tree
(resembles asembly language)
63
Target code generation
code generation:
intermediate form target language
traverses the symbol table to assign locations to variables
traverses the syntax tree generating loads and stores
arithmetics, tests, branches
64
65
Code improvements
more efficient
quicker and/or less memory
two phases:
machine independent, on intermediate form
target program improvement, register
distribution, reordering instructions
66
