COURSE TITLE: ORGANIZATION OF PROGRAMMING

LANGUAGES
COURSE CODE: CMP 411

INTRODUCTION

A programming language is a language designed to communicate instructions to a computer.

They are used to create programs that control the behaviour of a machine. A programming
language is a notation for writing programs, which are specifications of a computation or
algorithm. It has syntax, grammar, and semantics.
• Syntax is a set of rules that define how the commands must be arranged to make sense and
to be correctly translatable to the machine code.
• Grammar is a set of rules of using different punctuation, quotation marks, semicolons, and
other symbols to divide and clarify the syntax of a particular language.
• Semantics is a set of meanings assigned to every command of the language and is used to
properly translate the programme to machine code.

CLASSIFICATION OF PROGRAMMING LANGUAGE

Programming Language can be grouped into three namely, Machine Languages, Assembly
Languages and High-level Languages.
Machine Language:
Machine language is a collection of binary digits or bits that the computer reads and
interprets. Machine language is the only language a computer is capable of understanding.
Machine level language is a language that supports the machine side of the programming or
does not provide human side of the programming. It consists of (binary) zeros and ones. Each
instruction in a program is represented by a numeric code, and numerical addresses are used
throughout the program to refer to memory locations in the computer’s memory.
Assembly language:
Assembly language is easier to use than machine language. An assembler is useful for
detecting programming errors. Programmers do not have the absolute address of data items.
Assembly language encourage modular programming.
High level language
High level language is a language that supports the human and the application sides of the
programming. A language is a machine independent way to specify the sequence of
operations necessary to accomplish a task. A line in a high-level language can execute
powerful operations. Examples of high-level languages are BASIC,
FORTRAN etc.

ATTRIBUTE OF GOOD PROGRAMMING LANGUAGE

There are various factors why the programmers prefer one language over the another. Some
of very good characteristics of a good programming language are,

Clarity, Simplicity and Unity: A Programming language provides both a conceptual

framework for Algorithm planning and means of expressing them. It should provide a clear,
simple and unified set of concepts that can be used as primitives in developing algorithms.

Efficiency –An “efficient” language is one which permits fast compilation and execution on
the machines where it is implemented. Traditionally, FORTRAN and COBOL have been
relatively efficient languages in their respective application areas.

Generality
–This means that a language is useful in a wide range of programming applications. For
instance, APL has been used in mathematical applications involving matrix algebra and in
business applications as well.

Orthogonality: Orthogonality is the property that says " Changing A does not change B then
the features of a language are orthogonal, language is easier to learn, and programs are easier
to write because only few exceptions and special cases to be remembered.

Support for Abstraction: There is always found that a substantial gap remaining between
the abstract data structure and operations that characterize the solution to a problem and their
particular data structure and operations built into a language.
Programming Environment: A good programming language is such that has appropriate
programming environment (reliable documentation and testing packages) or integrated
programming environment.

Ease of program verification/Reusability: The reusability of program written in a language

is always a central concern. A program is checked by various testing technique like Formal
verification method Desk checking Input output test checking. We verify the program by
many more techniques. A language that makes program verification difficult may be far more
troublesome to use. Simplicity of semantic and syntactic structure is a primary aspect that
tends to simplify program verification.

Portability of programs: Programming language should be portable means it should be easy

to transfer a program from which they are developed to the other computer. A program whose
definition is independent of features of a Particular machine forms can only support
Portability. Example: Ada, FORTRAN, C, C++, Java.
Modularity : Modularity has two aspects: the language’s support for sub-programming and
the language’s extensibility in the sense of allowing programmer – defined operators and data
types. By sub programming, we mean the ability to define independent procedures and
functions (subprograms), and communicate via parameters or global variables with the
invoking program.
Input-Output facilities :in evaluating a language’s “Input-Output facilities” we are looking
at its support for sequential, indexed, and random access files, as well as its support for
database and information retrieval functions
PROGRAMMING LANGUAGE EVOLUTION AND PARADIGMS

Chronological development of programming languages

1883: The Beginning
In the early days, Charles Babbage had made the device, but he was confused about how to give
instructions to the machine, and then Ada Lovelace wrote the instructions for the analytical
engine. The device was made by Charles Babbage and the code was written by Ada Lovelace for
computing Bernoulli’s number. That was the first time in history that the capability of computer
devices was judged.

1949: Assembly Language

It is a type of low-level language. It mainly consists of instructions (kind of symbols) that only
machines could understand. In today’s time, assembly language is used in real-time programs
such as simulation flight navigation systems and medical equipment e.g. – Fly-by-wire (FBW)
systems. It is also used to create computer viruses.

1954 : FORTRAN
FORTRAN was developed in 1954 by John Backus and IBM. It was designed for numeric
computation and scientific computing. Software for NASA probes voyager-1 (space probe) and
voyager-2 (space probe) was originally written in FORTRAN. It is first high-level language. It
was developed using the first compiler and it is Machine Independent Language. In 1958
FORTRAN 2nd version was developed which introduces subroutines, functions, loops and
primitive for loop. It started as a Project and later renamed as ALGOL58.

1958: ALGOL
ALGOL stands for ALGOrithmic Language and was the initial phase of the most popular
programming languages of C, C++, and JAVA. It was also the first language implementing the
nested function and has a simple syntax than FORTRAN. The first programming language to
have a code block like “begin” that indicates that your program has started and “end” means you
have ended your code. ALGOL(ALGOrithmic Language) was a first "Block Structured Language
released in 1960.
It was Considered to be the first second generation Computer Language and Machine
Independent language. It introduced concepts like: Block structure code (Marked by BEGIN and
END), Scope
of variables (Scope of local variables inside blocks), BNF (Backus Naur Form), Notation for
defining syntax, Dynamic Arrays, Reserved words and IF THEN ELSE, FOR, WHILE loops

1959: COBOL
It stands for COmmon Business-Oriented Language. In 1997, 80% of the world’s business ran on
Cobol. The US internal revenue service scrambled its path to COBOL-based IMF (individual
master file) to pay the tens of millions of payments mandated by the coronavirus aid, relief, and
economic security. COBOL was rated in May 1959 by the Short-Range committee of the US
department of DOD.

1964: BASIC
BASIC (Beginner's All-purpose Symbolic Instruction Code). It was designed as a teaching
language in 1963 by John George Kemeny and Thomas Eugene Kurtz of Dartmouth college.
Intended to make it easy to learn programming. In 1991 Microsoft released Visual Basic, an
updated version of Basic but the first microcomputer version of Basic was co-written by Bill
Gates, Paul Allen, and Monte Davidoff for their newly-formed company, Microsoft.

1970: Pascal
Pascal is named after a French religious fanatic and mathematician Blaise Pascal. It was Created
in 1970 with the intension of replacing BASIC for teaching language. It was quickly developed as
a general-purpose language. It was Programs compiled to a platform-independent intermediate
pcode. The compiler for Pascal was written in Pascal.

1972: C
C is a general-purpose, procedural programming language and the most popular till now. All the
previous codes (like operating system and kernel) written in assembly language gets replaced by
the C language. C can be used to implementing operating system, embedded system, and on the
website using the Common Gateway Interface (CGI). C is the mother of almost all higher-level
programming languages like C#, D, Go, Java, JavaScript, Limbo, LPC, Perl, PHP, Python, and
Unix’s C shell.

1. PROGRAMMING PARADIGMS

there are four groups of programming languages (and, therefore, programming styles)
distinguishable:

1. Imperative/Procedural programming languages,

2. Functional/ Applicative programming languages,
3. Logic/ Declarative/ Rule-based programming languages,
4. Object-oriented programming languages.

Imperative languages (sometimes also called procedural languages) are mostly influenced
by the von Neumann computer architecture. They express computation by fully specified and
controlled manipulation of named data in a stepwise fashion. In other words, data or values are
initially stored in variables (memory locations), taken out of (read from) memory, manipulated in
ALU (arithmetic logic unit), and then stored back in the same or different variables (memory
locations). Finally, the values of variables are sent to the I/O devices as output. Typical elements
of such languages are assignment statements, data structures and type binding, as well as
control mechanisms; active procedures manipulate passive data objects. Typical
representatives are FORTRAN or PASCAL.

functional programming languages: while the assignment statement is central for

imperative programming languages, (pure) functional programming languages (sometimes
also called applicative languages) have no assignment statements. Their syntax is closely
related to the formulation of mathematical functions. Thus, functions are central for
functional programming languages. Typical representatives are LISP or APL.

Logic programming languages (sometimes also called declarative or rule-based

languages) are another group of languages which are totally different from imperative
languages (and even from functional languages). Facts and rules (the logic) are used to
represent information (or knowledge) and a logical inference process is used to produce
results. In contrast to this, control structures are not explicitly defined in a program, they are
part of the programming language (inference mechanism). The most important representative
is PROLOG.

Object-oriented programming languages: While in imperative programming languages

data and their manipulating procedures form separate units, object-oriented programming
languages just know the object representing data as well as procedures. Data structures and
their appropriate manipulation processes are packed together to form a syntactical unit called
a class. related variables and operations on variables are organized into classes of objects. The
access privileges of variables and methods (operations) in objects can be defined to reduce
(simplify) the interaction among objects. Typical representatives are SIMULA 67,
SMALLTALK, C++, or EIFFEL.
Often programming languages cannot be clearly associated with one of these four groups. For
example, languages like MODULA-2 or OBERON are sometimes said to be imperative
although they contain object-oriented features.

Reasons For Studying Concepts Of Programming Languages

1. Increased ability to express ideas/algorithms

2. Improved background for choosing appropriate Languages

3. Increased ability to learn new languages

4. Better Understanding of Significance of implementation

5. Better use of languages that are already known

6. The overall advancement of computing

Application Domains of programming languages

1. Scientific Applications

2. Data processing Applications

3. Text processing Applications

4. Artificial intelligence Applications

5. Systems Programming Applications

6. Web software

Trade-Offs In Language Design

1. Reliability Vs. Cost of Execution: For example, Java demands that all references to array
elements be checked for proper indexing, which leads to increased execution costs.

2. Readability vs. Writability: –APL provides many powerful operators land a large number
of new symbols), allowing complex computations to be written in a compact program but at
the cost of poor readability.

3. Writability (Flexibility) vs. reliability: The pointers in c++ for instance are powerful and
very flexible but are unreliable.

Methods of implementing programming language

1. Compilation– Programs are translated into machine Language & System calls
2. Interpretation– Programs are interpreted by another program (an interpreter)
3. Hybrid– Programs translated into an intermediate language for easy interpretation
4. Just –in-time – Hybrid implementation, then compile sub programs code the first time they
are called.
S/NO Compilation Interpretation
1 Slow translation, fast - Slower execution (10 to 100
execution times slower than compiled
programs)
2 Less Memory Often requires more memory
space and is now rare3 for
traditional
High level languages.
3 Run time errors are less easier Easier implementation of
to catch programs (run-time errors can
easily and
immediately be displayed).
4 Source program translated Interpreter executes each
(“compiled”) to instruction in source
another language program one step at a time
5 Great for debugging

THE CONCEPT OF ABSTRACTION AND LANGUAGE STRUCTURE

1. CONCEPT OF ABSTRACTION
The most important concept introduced by high level languages is abstraction, which is a
process that allows the general pattern to be observed while ignoring the nonessential.
Implementation details and certain irrelevant properties will be hidden for clarity. An
abstraction is thereby also a simplification of facts. An example of abstraction could be the
description of a memory cell as a location to store data values, the physical details are of no
interest from a programmer's point of view. Thus, two principal mechanisms of abstraction
can be distinguished: 1. Data abstraction. 2.Control abstraction.

Data abstraction is a mechanism providing types and allowing the declaration of variables
of these types, as well as providing operations for the manipulation of these variables. Thus,
data abstraction in its simplest form is given by standard types such as real, for example. In
high level programming languages, the data type real allows the definition of floating-point
variables, and the set of operations on this data type allow the arithmetic manipulation of
objects of this type. As a form of user-defined data type, An abstract data type is a (user-
defined) data type and the set of permitted operations on objects of this type, by which the
internal representation is hidden to those using that type.
Control abstraction is the mechanism defining the order in which certain activities or
groups of activities should be performed. By this we mean not only control structures on the
statement level like conditional and unconditional branching, but also the construction of
subprograms up to concurrent programs. Control abstraction on the subprogram level was
already introduced in assembler languages by allowing macro definitions.

2. LANGUAGE STRUCTURE
The structures of programming languages are grouped into four structural layers which are
lexical, syntactic, contextual, and semantic.

Lexical structure
Lexical structure defines the vocabulary of a language. Lexical units are considered the building
blocks of programming languages. The lexical structures of all programming languages are
similar and normally include the following kinds of units:
1. Identifiers - Names that can be chosen by programmers to represent objects like
variables, labels, procedures, and functions. Most programming languages require that an
identifier start with an alphabetical letter and can be optionally followed by letters, digits,
and some special characters.
2. Keywords: Names reserved by the language designer and used to form the syntactic
structure of the language.
3. Operators: Symbols used to represent the operations. All general-purpose programming
languages should provide certain minimum operators such as mathematical operators like
+, −, *, /, relational operators like <, ?, ==, >, ?, and logic operators like AND, OR, NOT,
etc.
4. Separators: Symbols used to separate lexical or syntactic units of the language. Space,
comma, colon, semicolon, and parentheses are used as separators.
5. Literals: Values that can be assigned to variables of different types. For example, integer
type literals are integer numbers, character-type literals are any character from the
character set of the language, and string-type literals are any string of characters.
6. Comments: Any explanatory text embedded in the program. Comments start with a
specific keyword or separator. When the compiler translates a program into machine
code, all comments will be ignored.
7. Layout and spacing: Some languages are of free format such as C, C++, and Java. They
use braces and parentheses for defining code blocks and separations. Additional
 whitespace characters (spaces, newlines, carriage returns, and tabs) will be ignored. Some
languages consider layout and whitespace characters as lexical symbols. For example,
Python does not use braces for defining the block of code. It uses indentation instead.
Different whitespace characters are considered different lexical symbols.
Syntactic structure
Syntactic structure defines the grammar of forming sentences or statements using the lexical
units. An imperative programming language normally offers the following basic kinds of
statements:
1. Assignments: An assignment statement assigns a literal value or an expression to a
variable.
2. Conditional statements: A conditional statement tests a condition and branches to a
certain statement based on the test result (true or false). Typical conditional
statements are if-then, if-then- else, and switch (case).
3. Loop statements: A loop statement tests a condition and enters the body of the loop or
exits the loop based on the test result (true or false). Typical loop statements are for-
loop and while-loop.
Contextual structure/ static semantics
Contextual structure (also called static semantics) defines the program semantics before
dynamic execution. It includes variable declaration, initialization, and type checking. Some
imperative languages require all variables be initialized when they are declared at the
contextual layer, while other don’t as long as the variables are initialized before their values
are used. This means that initialization can be done either at the contextual layer or at the
semantic layer. Contextual structure starts to deal with the meaning of the program. A
statement that is lexically correct may not be contextually correct. For example:

Str name = “CMP 411”;

Int code = 411, details;
details = name + code;

The declaration and the assignment statements are lexically and syntactically correct, but the
assignment statement is contextually incorrect because it does not make sense to add an integer
variable to a string variable.

Semantic structure
Semantic structure describes the meaning of a program, or what the program does during the
execution. The semantics of a language are often very complex. In most imperative
languages, there is no formal definition of semantic structure; informal descriptions are
normally used to explain what each statement does. The semantic structures of functional and
logic programming languages are normally defined based on the mathematical and logical
foundation on which the languages are based. For example, the meanings of Scheme
procedures are the same as the meanings of the lambda expressions in lambda calculus on
which Scheme is based, and the meanings of Prolog clauses are the same as the meanings of
the clauses in Horn logic on which Prolog is based.

BACKUS NAUR FORM (BNF) NOTATION AND SYNTAX GRAPH

Defining a programming language means describing the syntax and semantic of that
language. Formal methods for the description of the syntax, i.e. the syntactical form of a
programming language are Backus-Naur form (BNF) and syntax diagrams. important
elements of languages.
Definitions
• Alphabet An alphabet is an arbitrary but finite set of symbols. For example, machine
code is based on the binary alphabet A1 = {D, 1}; other examples are A2 = {D,
1,2,3,4,5,6, 7, 8, 9}, A3 = {+, -, *,1} etc.
• Symbols: The elements of the vocabulary (alphabet) of a formal language are called
symbols, while for natural languages we call them words.
• Token: Multiple occurrences of symbols (or words) are called tokens.
• Sentence: A sequence of symbols is called a sentence.
• Grammar (Syntax): The grammar or the syntax of a language defines the form of the
language, this means whether an arbitrary sequence of symbols is correct. We will say
that a correct sentence will be accepted by the language.
• Semantics: The meaning of correct sentences of a language is defined by semantic
rules. In general, we have no formal description of the semantics of a language.
• String: A (finite) sequence of elements of a certain set (alphabet) is called a string. In
analogy to the empty set-in set theory, we can consider an empty string E. The empty
string e is that string which contains no symbols. The sequence 0011 is an example of
a string over the alphabet A1.
 • Production: Rules for string substitution are called productions. The symbols ~
and ::= are widely used to represent productions. For example, the rule (production)
s ~ a b (or s ::= a b )
means that s can be substituted by a b, or s is defined as a b.
• Terminal symbols: The symbols which actually occur in a sentence are called
terminal symbols. They will never occur on the left side of a production. The symbols
begin, end, if, then, else are an example for terminal symbols belonging to the
grammar which describes PASCAL. Terminal symbols must be valid symbols of the
language. T indicates the set of terminal symbols, while T* indicates the set of all
possible strings over T.
• Nonterminal symbols: The nonterminal symbols must be defined by other
productions, i.e. they occur also on the left side of productions. Nonterminal symbols
are syntactical variables. N indicates the set of nonterminal symbols, while N*
indicates the set of all possible strings over N.
• Vocabulary = Alphabet Like natural languages, formal languages are based on a
specific vocabulary, i.e. the elements of the language. The vocabulary of a formal
language is the union of the terminal and nonterminal symbols. V = N∪T indicates
the vocabulary, while V* indicates the set of all possible strings over V. The * in
these definitions indicates the closure of a certain set. We will find a similar usage of
this operator for productions.
BACKUS-NAUR FORM (BNF)
Backus-Naur form (BNF) was first introduced for the definition of the syntactical structure of
the programming language ALGOL 60. BNF (Backus-Naur Form) is a meta language that
can be used to define the lexical and syntactic structures of another language. The Backus-
Naur form is a meta-language, i.e. a language which is used to describe other languages.
A BNF rule or production defines a (single) nonterminal symbol by other nonterminals
and/or terminal symbols using the "~" as the defining symbol. On the left side of an arrow
only nonterminals can occur, while on the right side both terminals and nonterminals are
allowed. The table below shows some common (meta-) symbols of the BNF.
Using this notation and the set of terminal symbols
T= { +, -, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }
as well as the set of nonterminal symbols
N= {int, unsigned_int, digit},
we can define integers by the following BNF-rules (productions):
int → [+|−¿ unsigned_int
unsigned_int. → digits¿
digit → 0|1 |2|3|4 |5 |6 |7 |8 |9

The first rule defines that an integer is an unsigned integer with a leading sign. This
sign can be absent, or "+", or "_". The second rule shows that BNF allows recursive
Syntax graph
BNF notation provides a concise way to define the lexical and syntactic structures of
programming languages. However, BNF notations, especially the recursive definitions, are not
always easy to understand. A graphic form, called a syntax graph, also known as railroad tracks,
is often used to supplement the readability of BNF notation.
LANGUAGE PROCESSING
Syntax vs Semantics
Formal descriptions of the syntax of programming languages, for simplicity’s sake, often do not
include descriptions of the lowest-level syntactic units. These small units are called lexemes. The
description of lexemes can be given by a lexical specification, which is usually separate from the
syntactic description of the language. The lexemes of a programming language include its
numeric literals, operators, and special words, among others. One can think of programs as
strings of lexemes rather than of characters.
Lexemes are partitioned into groups—for example, the names of variables, methods, classes, and
so forth in a programming language form a group called identifiers. Each lexeme group is
represented by a name, or token. So, a token of a language is a category of its lexemes. For
example, an identifier is a token that can have lexemes, or instances, such as sum and total. In
some cases, a token has only a single possible lexeme. For example, the token for the arithmetic
operator symbol + has just one possible lexeme. Consider the following Java statement:
index = 2 * count + 17;
The lexemes and tokens of this statement are

Language Recognizers
The syntax analysis part of a compiler is a recognizer for the language the compiler
translates. In this role, the recognizer need not test all possible strings of characters from
some set to determine whether each is in the language. Rather, it need only determine
whether given programs are in the language. In effect then, the syntax analyzer determines
whether the given programs are syntactically correct.

Grammars and Languages

A complete syntactical description of a language - using, for example, BNF-rules - is called a
grammar. A grammar G is defined as a 4-tuple G (T, N, P, S), where:
T is the set of terminal symbols,
N is the set of nonterminal symbols,
P is the set of productions,
S ∈N is the start symbol.
Thus, a grammar consists of a set of rules, where each nonterminal symbol is defined. One of
the nonterminal symbols is marked as a start symbol of the grammar.

For example, A Grammar for Simple Assignment Statements

The statement
A=B*(A+C)
is generated by the leftmost derivation:

Pass Tree
One of the most attractive features of grammars is that they naturally describe the hierarchical
syntactic structure of the sentences of the languages they define. These hierarchical structures
are called parse trees.
A grammar can be used to generate sentences of a specific language. However. a compiler
has to check strings of symbols to see whether they belong to that language. i.e. to find how a
sequence of symbols might be derived from the start symbol using the productions of the
grammar and to display the derivation (or to show that the sentence cannot be derived from
the start symbol). This problem is known as the parsing problem. pass tree of an expression x
+ y - x * y is given below as an example

Binding
Binding concept is the process of associating a variable, constant, expressions, functions and
procedures with their respective type, memory location and passing mechanism for
parameters, the association of such attributes or properties to an entity in a language is what
is known as binding. (or any suitable explanation)
types of binding
static binding is done before program execution and stay permanent through program
execution. dynamic binding is done and can be changed during program execution. Binding
can be perform during :
- Language definition time
- Language implementation time
- compile time
- run time.