CSC 423 – Organization of Programming Languages
Lecture 1: How to Describe
a Programming Languages
The CSC423 Team
[Alpha, 2024/25 Session]
What is Programming
Language
A programming language is an artificial formalism in
which algorithms can be expressed.
Its study can make good use of the many concepts
and tools developed in the last century in linguistics
(which studies both natural and artificial languages).
L4 2
What is Programming
Language
Morris [6] studied the various levels at which a
description of a language can occur.
Grammar
Semantics
Pragmatics.
L4 3
What is Programming
Language
Grammar is that part of the description of
the language which answers the question:
which phrases are correct?
Lexical component => word/token => Legal
phrases (syntax).
L4 4
What is Programming
Language
Semantics is that part of the description of
the language which seeks to answer the
question “what does a correct phrase
mean?”
L4 5
What is Programming
Language
Pragmatics is that part of a language
description which asks itself “how do we use
a meaningful sentence?
L4 6
What is Programming
Language
In the case of programming languages, we can add a fourth
level to the three classical ones: the implementation level.
Given that the languages that interest us are procedural
languages (that is, languages whose correct phrases specify
actions), it remains for us to describe “how to execute a
correct sentence, in such a way that we respect the
semantics”.
L4 7
What is Programming
Language
For example:
Consider the word “recipes” in cooking
Syntax determines the correct sentences with
which a recipe is expressed
The semantics is about explaining “what is” a
recipe,
L4 8
What is Programming
Language
Pragmatics studies how a cook (“that
cook”) interprets the various sentences of
the recipe
The implementation describes the way
(where, and with what ingredients) the
kitchen recipe transforms into the dish
that the semantics prescribes.
L4 9
History and Evolution of Programming
Languages
Programming languages have evolved
through several generations:
First Generation (Machine Language): The earliest form of
programming involved writing instructions in binary (0s and
1s). These are directly understood by the computer's CPU but
are extremely difficult for humans to read and write.
L4 10
History and Evolution of Programming
Languages
Second Generation (Assembly Language):
Introduced mnemonics (e.g., ADD, MOV) that made
it easier for humans to write code. Assemblers were
used to convert assembly code into machine code.
L4 11
History and Evolution of Programming
Languages
Third Generation (High-Level Languages -
1950s-1970s): Languages like FORTRAN, COBOL,
and C introduced higher-level abstractions, making
programming more accessible and reducing
hardware dependency.
L4 12
History and Evolution of Programming
Languages
• Fourth Generation (Declarative Languages -
1980s-1990s): Languages like SQL, MATLAB, and
Prolog focused on specifying what should be done
rather than how to do it.
L4 13
History and Evolution of Programming
Languages
Fifth Generation (AI and Domain-Specific
Languages - 2000s-Present): Languages like
Python, R, and Julia facilitate machine learning, data
science, and artificial intelligence.
L4 14
Why Are There So Many Programming
Languages?
Different application domains: Some languages
excel in web development (JavaScript, PHP), while
others are suited for system programming (C, Rust)
or data science (Python, R).
Security and safety: Some languages (e.g., Rust)
are designed with built-in protections against
memory-related vulnerabilities.
L4 15
Why Are There So Many Programming
Languages?
Performance optimization: Some languages
prioritize execution speed (C, C++) while others
focus on ease of use and flexibility (Python, Ruby).
Ease of learning and productivity: Modern
languages like Python emphasize simplicity, while
older languages like Assembly provide fine-grained
control over hardware.
L4 16
Why Are There So Many Programming
Languages?
• Community support and ecosystem: A strong
developer community leads to continuous
improvement, evolution, and widespread adoption of
certain languages (e.g., Java, JavaScript, Python).
• New computing paradigms: Advances in cloud
computing, IoT, and quantum computing have
driven the creation of specialized languages like
Swift, Go, and Q#.
L4 17
Why Are There So Many Programming
Languages?
• Community support and ecosystem: A strong
developer community leads to continuous
improvement, evolution, and widespread adoption of
certain languages (e.g., Java, JavaScript, Python).
• New computing paradigms: Advances in cloud
computing, IoT, and quantum computing have
driven the creation of specialized languages like
Swift, Go, and Q#.
L4 18
Application Domains
Programming languages are tailored to different
domains:
• System Programming: C, Rust, Assembly
• Web Development: JavaScript, PHP, Ruby
• Data Science & AI: Python, R, Julia
• Mobile App Development: Swift (iOS), Kotlin
(Android)
• Game Development: C++, C#, Unity
• Embedded
L4 Systems: C, Assembly 19
Language Design Considerations
When designing a language, key considerations
include:
Readability: the ease with which programs can be
read and understood
Writability: the ease with which a language can be
used to create programs
Reliability: conformance to specifications
(i.e.,performs to its specifications)
L4 20
Cost: the ultimateDesign
Language total costConsiderations
Performance and efficiency: Execution speed and
memory usage are crucial for certain applications.
Portability: The ability to run on multiple platforms
(e.g., Java’s JVM allows cross-platform execution).
Security: Languages like Rust prioritize memory
safety.
Concurrency support: Modern languages like Go
and Erlang are designed for handling multiple tasks
simultaneously
L4 21
Evaluation Criteria: Readability
• Usability, readability, maintainability, and
expressiveness
• Overall simplicity • Data types
• A manageable set of features and • Adequate predefined data types
constructs • Syntax considerations
• Minimal feature multiplicity
• Identifier forms: flexible composition
• Minimal operator overloading
• Special words and methods of forming
• Orthogonality compound statements
• A relatively small set of primitive constructs • Form and meaning: self-descriptive
can be combined in a relatively small constructs, meaningful keywords
number of ways
• Every possible combination is legal
L4 22
Evaluation Criteria: Reliability
Reliability is influenced by several factors:
Type checking
Testing for type errors Readability and writability
Exception handling A language that does not support
“natural” ways of expressing an
Intercept run-time errors and take corrective
algorithm will require the use of
measures
“unnatural” approaches, and hence
Aliasing reduced reliability
Presence of two or more distinct referencing
methods for the same memory location
L4 23
Language Design Considerations
• Portability: The ability to run on multiple platforms
(e.g., Java’s JVM allows cross-platform execution).
• Security: Languages like Rust prioritize memory
safety.
• Concurrency support: Modern languages like Go
and Erlang are designed for handling multiple tasks
simultaneously
L4 24
Influences on Language Design
1. Computer Architecture
• Most programming languages have historically been designed around the von
Neumann architecture.
• In this architecture:
• Programs and data share the same memory.
• Instructions are executed sequentially via the fetch-decode-execute cycle.
• As a result:
• Languages often feature variables, assignment statements, and loops that mirror
hardware design.
• Imperative languages like C, Pascal, and Fortran align well with this model.
L4 25
von Neumann architecture
Fetch-execute-cycle (on a von Neumann architecture computer)
initialize the program counter
repeat forever
fetch the instruction pointed by the counter
increment the counter
decode the instruction
execute the instruction
end repeat
L4 26
Influences on Language Design
2. Program Design Methodologies
• Evolving software engineering methodologies influence
how languages are designed.
• For example:
• The rise of object-oriented programming (OOP) led to
languages like C++, Java, Python, and C#.
• Functional programming gained traction with the need for
parallelism and immutability, influencing languages like
Haskell, Scala, and F#.
L4 27
Programming Methodologies Influences
🕰 1950s – Early 1960s: Machine-Oriented Focus
• Applications were simple; hardware was expensive.
• Main concern: Machine Efficiency
• Languages focused on low-level control and performance
(e.g., Assembly, early Fortran).
L4 28
Programming Methodologies Influences
🕰 Late 1960s: Human-Oriented Focus
• Programs grew larger and more complex.
• Concern shifted to Programmer Efficiency:
• Readability
• Structured control flow
• Influences:
• Structured Programming
• Top-down design
• Step-wise refinement
• Languages: ALGOL, Pascal, early C.
L4 29
Programming Methodologies Influences
🕰 Late 1970s: Shift from Process-Oriented to Data-
Oriented Design
• Emergence of data abstraction as a core concept.
• Emphasis on modular design and information hiding.
• Influences:
• Abstract Data Types (ADTs)
• Languages: Ada, Modula-2.
L4 30
Programming Methodologies Influences
🕰 Mid 1980s: Object-Oriented Programming (OOP)
• Extension of data abstraction with new features:
• Encapsulation
• Inheritance
• Polymorphism
• Promoted code reuse, modularity, and modeling of real-world
systems.
• Languages: C++, Smalltalk, later Java and Python.
L4 31
Language Categories
Programming languages can be grouped based on their computational model
and paradigm.
1. Imperative Languages
• Core Features:
• Use of variables, assignment statements, and iteration.
• Describe how a task is performed (step-by-step).
• Includes:
• Object-Oriented Languages: Java, C++, C#
• Scripting Languages: Python, JavaScript, Perl
• Visual Languages: Visual BASIC .NET
• 📌 Examples: C, Java, JavaScript, Perl, Visual BASIC .NET, C++
L4 32
Language Categories
🔹 2. Functional Languages
• Computation is based on function application.
• Focus on what to solve rather than how.
• Encourages immutability, recursion, and higher-order
functions.
• 📌 Examples: LISP, Scheme, ML, F#
L4 33
Language Categories
🔹 3. Logic Languages
• Rule-based: computation is performed by logical
inference from facts and rules.
• Rules are not ordered — declarative in nature.
• Used in AI, NLP, and knowledge-based systems.
• 📌 Example: Prolog
L4 34
Language Categories
🔹 4. Markup / Programming Hybrid Languages
• Primarily markup languages extended with
programming constructs.
• Common in web templating, data
transformation, and document processing.
• 📌 Examples: JSTL (JSP Standard Tag Library), XSLT
L4 35
Layered View of Computer
The operating
system and
language
implementation
are layered over
machine interface
of a computer
L4 36
Program Execution Models (Compilation vs.
Interpretation)
Program Execution Models (Compilation vs.
Interpretation)
There are two primary execution models for
programming languages:
• Compiled Languages:
• Examples: C, C++, Rust, Go
• A compiler translates the source code into machine code
before execution.
• Offers faster execution but requires a separate compilation
step.
L4 37
Program Execution Models (Compilation vs.
Interpretation)
• Interpreted Languages:
• Examples: Python, JavaScript, Ruby
• Code is executed line-by-line by an interpreter.
• Slower execution but allows for dynamic behavior and
easier debugging.
L4 38
Program Execution Models (Compilation vs.
Interpretation)
Compilation
Compilation is the process of translating a high-
level program (written in a source language) into
machine code (target language), which a computer
can execute directly.
• Slow Translation, but Fast Execution
• Compilation takes time upfront.
• Once compiled, the program runs efficiently.
L4 39
Phases of the Compilation Process
1. Lexical Analysis 3. Semantic Analysis
•Scans the source code. •Verifies semantic consistency:
•Converts a stream of characters into lexical
• Type checking
tokens (identifiers, keywords, symbols).
•Example: int x = 5; → tokens: int, x, =, 5, ; • Scope resolution
2. Syntax Analysis (Parsing)
• Declaration-before-use rules
•Produces intermediate representation (IR) of
• Takes the tokens from lexical analysis.
the program.
• Builds a parse tree (or abstract
4. Code Generation
syntax tree) to represent the
syntactic structure of the code.
•Converts intermediate code into machine
code or assembly.
• Checks if the code follows the
grammar rules of the language.
•Performs optimizations to enhance
performance.
L4 40
The Compilation Process
L4 41
Pure Interpretation
• A pure interpreter executes a program line-by-
line, directly from its source code, without
translating it into machine code beforehand.
L4 42
Pure Interpretation
•No Translation Step
•The program is executed directly using an interpreter.
•No intermediate machine code or compilation involved.
•Ease of Implementation
•Errors can be caught and reported immediately during execution.
•Ideal for debugging and educational environments.
•Slower Execution
•Typically 10 to 100 times slower than compiled programs.
•Every instruction must be parsed and executed repeatedly at runtime.
•Higher Memory Usage
•Interpreter and source code must be resident in memory during execution.
•Extra overhead for parsing and interpretation structures.
L4 43
Pure Interpretation
🔹 Modern Usage
• Rare for traditional compiled languages (e.g., C, C+
+).
• Comeback with Web scripting and dynamic
languages:
• 📌 Examples: JavaScript, PHP, Python (to an extent)
L4 44
Program Execution Models (Compilation vs.
Interpretation)
• Hybrid Approach:
• Example: Java (compiles to bytecode, then executed
by the JVM)
• Balances performance and portability.
L4 45
Language Standardization
Language standardization ensures consistency and
compatibility across different implementations of a
language. Organizations like ISO (International
Organization for Standardization) and IEEE
(Institute of Electrical and Electronics
Engineers) define standards for languages like C,
C++, and SQL.
L4 46
Language Standardization
Standardization benefits include:
• Ensuring compatibility across different platforms
and compilers.
• Facilitating language evolution while
maintaining backward compatibility.
• Encouraging best practices in software
development.
L4 47
Reasons for Studying Concepts of
Programming Languages
Increased ability to express ideas
Improved background for choosing appropriate
languages
Increased ability to learn new languages
Better understanding of significance of implementation
Better use of languages that are already known
Overall advancement of computing
48
