Transcript Programming Languages Marjan Sirjani

Programming
Languages
Marjan Sirjani
2. Language Design
Issues
Design to
Run efficiently : early languages
 Easy to write correctly : new languages

Data typing features in ML
 Class of C++
 Package of Ada

2
Major influences on
designing a language
The underlying computer which
programs execute upon;
The execution model, or virtual
computer that supports the language on
the actual hardware;
The computational model that the
language implements.
3
2.1. The Structure And
Operation Of A
Computer
A computer is an integrated set of
algorithms and data structures capable
of storing and executing programs.
Hardware computer or
 virtual computer

4
Major Components of a
Computer (From a Programming
Language Designers View)
Data

Various kinds of elementary and structured
data.
Primitive operations
Sequence control

Controlling the sequence of primitive
operations execution.
5
Major Components of a
Computer (From a Programming
Language Designers View)
Data access

Controlling the data supplied to each execution of
an operation.
Storage management

Controlling the allocation of storage for programs
and data.
Operating environment

Providing mechanisms for communication with an
external environment containing programs and
data.
6
Data
Main memory
High-speed register
High-speed cache memory
External files
Data and Program
7
operations
A set of build-in primitive operations





Arithmetic operations on each built-in numeric
data (+,-,*,/)
Testing various properties of data items (test for
zero, positive, and negative numbers)
Accessing and modifying various parts of a data
item
Controlling input-output devices
Sequence control (jumps)
8
Sequence Control
There is an interpreter :
Fetch the instruction
 Decode instruction
 Fetch designated operands
 Branch to designated operation
 Execute primitive operations 1 to n

Using an address register
9
Data Access
Access to operands of the operation
10
Storage Management
Keeping all resources of the computer
operating as much as possible
Memory
 Central processor
 External data devices

Multiprogramming
Cache memory
11
Operating Environment
The outside world of computer;
a set of peripherals and input-output
devices
12
Computer States
We saw the static organization of the
computer,
We also must see the dynamic
operation of it during program
execution.
13
Language
Implementation
Translation (compilation)
Accept programs in some source language
as input and produce functionally equivalent
programs in another object language as output.




Assembler : assembly to machine language.
Compiler : a high level language to assembly or
machine code.
Loader,linker editor : machine code in relocatable
form to machine code really executable.
Preprocessor : a high level language to a high
level language in a standard form .
14
Language
Implementation
Software simulation (interpretation)
the simulator executes the input
program directly.
15
Differences Between
Software
Implementations
Translation versus Interpretation
Physical input sequence –
Logical flow of control
Process each program statement
exactly once –
might process some statements
repeatedly
16
Differences Between
Software
Implementations
Faster program execution –
slow program execution
Loss of information about program –
leaving statements in their original form
Object program much larger then the
source program –
no space is needed for object program
17
Firmware Computers
A common alternative to the strict
hardware realization of a computer is
the firmware computer,
simulated by a micro-program
running on a special microprogrammable hardware computer.
(emulation)
18
2.2. Virtual Computers
Hardware realization

Physical devices
Firmware realization

microprogramming
Software simulation

Some other programming language
Combination of these techniques
19
Syntax and Semantics
Syntax: what the program looks like.
Semantics: the meaning given to the
various syntactic constructs.
Example:
V: array [0..9] of integer;
int V[10];
20
Hierarchies of
Computers
Virtual computer developed by
programmer
The language virtual computer
Operating system virtual computer
Firmware virtual computer
Actual hardware computer
21
Binding and Binding
Times
Binding of a program element to a
particular characteristic or property : the
choice of the property from a set of
possible properties.
Binding time of the property for that
element: the time during program
formulation or processing when this
choice is made.
22
Examples Of Binding
Setting the value of an attribute
A variable: name , type, storage area
 A routine: name formal parameters of a
certain type, certain parameter-passing
conventions,
 A statement: associated actions.

23
Classes of Binding
Times
1. Execution time (run time)
(dynamic binding)
2. Translation time (compile time)
3. Language implementation time
4. Language definition time
24
1. Execution time :

On entry to subprogram or block.


Binding of formal to actual parameters in C.
At arbitrary points during execution .

Binding of variables to values by assignments.
(can be modified repeatedly during execution)
25
2. Translation time (compile time)

Bindings chosen by the programmer


Bindings chosen by the translator


Variable names and types
Relative locations of a data object in the
storage allocated for a procedure
Bindings chosen by the loader

Actual addresses
26
3. Language implementation time

The details associated with the
representation of numbers and of
arithmetic operations.
(integer type memory representation)
4. Language definition time

Possible statement forms, data structure
types, program structures.
(integer type definition)
27
Programming languages differ in
The number of entities with which they can
deal,
 The number of attributes to be bound to
attributes,
 The time at which such bindings occur
(binding time),
 The stability of the binding (fixed or
modifiable)

28
Importance of Binding
Times
Many of the most important differences
among languages involve differences in
binding times.
Early binding : efficiency.
(FORTRAN types, arithmetic operations)
Late binding : flexibility.
(ML types, string manipulations)
29
Binding Time: An
Example
X := X + 10
Set of possible types for variable X.
Type of variable X.
Set of possible values for variable X.
Value of the variable.
Representation of the constant 10.
Properties of the operator +.
30
Attributes of a variable:
Name
 Scope
 Type
 L-value
 R-value

31
Name and Scope
Static scope binding: defines the scope
in terms of the lexical structure of a
program . (C, Pascal)
Dynamic scope binding: defines the
scope of a variable’s name in term of
program execution. (same dcl until new dcl)
(APL, LISP, SNOBOL)
32
Name and Scope
(dynamic binding)
{ /* block A*/
int x;
…}
{ /* block B*/
int x;
…}
{ /* block C*/
…
x:= …;
…}
33
Type
Static typing: bind variables to their type
at compile time, and the binding can not
be changed during execution.
Static type checking
Dynamic typing: run-time binding
between variables and their types.
(according to the value assigned)
34
2.3. Language
Paradigms
How does the program execute?
What sort of constructs does the
language provide?
35
Four basic computational models:
Imperative languages
Applicative language
Rule-based language
Object-oriented programming
36
Imperative Languages
Imperative or procedural languages are
command-driven or statement-oriented
languages.
Basic concept : machine state.
The syntax has the form like:
statement1;
statement2;
…
37
Applicative Languages
Applicative or functional languages look
at the function that program represents
rather than just to the state changes as
the program executes, statement by
statement.
The syntax has the form like:
functionn(…function2(function1 (data))…)
38
Rule-based Languages
Rule-based or logical languages execute by
checking for the presence of a certain
condition and when it is satisfied, they
execute an appropriate action.
The syntax has the form like:
enabling condition1 action1
enabling condition2 action2
…
enabling conditionn actionn
39
Object-Oriented
Languages
Object-oriented languages can be viewed as
combining imperative and functional
paradigms.


Abstract data types
inheritance
 efficiency of imperative languages
 flexibility and reliability of functional
languages.
40
Generality of
Computational Model
How one uses a programming language
depends on the programmer.
41