The document discusses programming language evolution, paradigms, and translators. It describes how programming languages have evolved from machine language to assembly language to high-level languages. It outlines four main programming paradigms: imperative, object-oriented, functional, and logic programming. It also defines the three main types of translators - assemblers, compilers, and interpreters - and explains their functions in translating programs to machine-executable code.

1. INTRODUCTION TO
PROGRAMMING
Week 2

2. Topic
•Programming Evolution
•Programming Language Paradigm
•Translators

3. Programming Language Evolution
1. Machine Language
• Machine language is a collection of binary digits or bits that the
computer reads and interprets.
2. Assembly Language
• Uses symbolic operation code to represent the machine
operation code.
3. High level Language
• Uses English like statements

4. Programming Language Evolution
• High level language
Example : C++ Add 2 numbers
#include<iostream>
Void main()
{
int a, b, c;
cout <<“Enter two numbers:n”;
cin >>a;
cin >>b;
c = a+b;
cout <<“Sum of 2 numbers is {0}”, c);
}
• Machine Language
Example: check if low-order 4 bits of value in reg 1 = 0
2000 load load zero into reg 0
220F load load string 00001111 into reg 2
8312 AND c(reg 1) AND c(reg 2) —> reg 3 — masking
B3XY JMP jump to address XY if c(reg 3) = c(reg 0)
• Assembly Language
Example : Add 2 numbers
name "add"
mov al, 5 ; bin=00000101b
mov bl, 10 ; hex=0ah or bin=00001010b
add bl, al ; 5 + 10 = 15 (decimal) or hex=0fh or
bin=00001111b

5. Programming Language Paradigm
• Programming paradigm is a fundamental style of computer programming
• Programming paradigm is an approach to solving programming problems.
• Programming paradigm that describes computation in terms of
statements that change a program state.
• It defines sequences of commands for the computer to perform
• For example,
• X := X+2
• Assignment changes the value at a location.
• A program execution generates a sequence of states

6. Programming Language Paradigm
Common programming paradigms:
1.Imperative or Procedural Programming
2.Object-Oriented Programming
3.Functional Programming
4.Logic Programming

7. Programming Language Paradigm

8. Programming Language Paradigm
1. Imperative or Procedural Programming
• a program is a series of statements containing variables.
• Program execution involves changing the memory contents of the computer
continuously.
• Example of imperative languages are: C, FORTRAN, Pascal, COBOL etc
• Advantages
low memory utilization
relatively efficient
the most common form of
programming in use today.
• Disadvantages
difficulty of reasoning about
programs
difficulty of parallelization.
Tend to be relatively low level

9. Programming Language Paradigm
2. Object-Oriented Programming
• A program in this paradigm consists of objects which communicate
with each other by sending messages
• Example object oriented languages include: Java, C#, Smalltalk, etc
• Advantages
Conceptual simplicity
Models computation better
Increased productivity
• Disadvantages
Can have a steep learning
curve, initially
Doing I/O can be cumbersome

10. Programming Language Paradigm
3. Functional Programming
• A program in this paradigm consists of functions and uses functions in a similar way as used in
mathematics
• Program execution involves functions calling each other and returning results. There are no variables
in functional languages
• Example functional languages include: ML, MirandaTM, Haskell
• Advantages
 Small and clean syntax
 Better support for reasoning about programs
 They allow functions to be treated as any other data values.
 They support programming at a relatively higher level than the
imperative languages
• Disadvantages
 Difficulty of doing
input-output
 Functional languages
use more storage space
than their imperative
cousins

11. Programming Language Paradigm
4. Logic Programming
• A program in the logic paradigm consists of a set of predicates and rules of inference.
Predicates are statements of fact like the statement that says: water is wet.
• Rules of inference are statements like: If X is human then X is mortal.
The predicates and the rules of inference are used to prove statements that the
programmer supplies.
• Example: Prolog
• Advantages
Good support for
reasoning about
programs
Can lead to concise
solutions to problems
• Disadvantages
Slow execution
Limited view of the world
That means the system does not know about facts that are
not its predicates and rules of inference.
Difficulties in understanding and debugging large programs

12. Translators
• A translator is a computer program that performs the translation
of a program written in a given programming language into
a functionally equivalent program in a different ways computer
language, without losing the functional or logical structure of the
original code (the "essence" of each program)
• Programs must be translated into machine codes before execution

13. Translators
Types of translator
1. Assembler
2. Compiler
3. interpreter

14. Translators
1. Assembler
• Assembler is a computer program which is used to translate
program written in Assembly Language in to machine language.
• A program which translates an assembly language program into a
machine language program
• Assembler are used to convert assembly language code into
machine code.

15. Translators
2. Compiler
• A compiler is a program that translates a programme written in
HLL to executable machine language
• It is a program which translates a high level language program into
a machine language program.
• A compiler is more intelligent than an assembler.
• Compilers are used to convert high level languages (like C, C++ )
into machine code

16. Translators
3. Interpreter
• Interpreter translates each instruction, executes it and then the
next instruction is translated and this goes on until end of the
program.
• An interpreter is a program which translates statements of a
program into machine code.
• It translates only one statement of the program at a time.
• An interpreter is a computer program which executes a statement
directly (at runtime)