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 micro-
programmable 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
 Variable names and types
 Bindings chosen by the translator
 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