This is the syllabus for Programming Languages (Unit I–V).

Here's a concise and exam-

oriented breakdown of each unit.

UNIT I – Syntax and Semantics (9 Hours)

1. Evolution of Programming Languages

 Machine Language
 Assembly Language
 High-Level Languages
 Object-Oriented Languages
 Scripting Languages
 Modern Multi-paradigm Languages

2. Describing Syntax

 Syntax
 Tokens
 Lexemes
 Parsing
 Grammar

3. Context-Free Grammars (CFG)

 BNF (Backus-Naur Form)

 Production Rules
 Derivation
 Parse Tree
 Ambiguity

4. Attribute Grammars

 Synthesized Attributes
 Inherited Attributes
 Semantic Rules

5. Describing Semantics

 Operational Semantics
 Denotational Semantics
 Axiomatic Semantics

6. Lexical Analysis

 Scanner
 Token Recognition
  Regular Expressions
 Finite Automata

7. Parsing

 Top-Down Parsing
 Bottom-Up Parsing

8. Recursive-Descent Parsing

 Predictive Parsing
 Recursive Functions
 LL Parser

9. Bottom-Up Parsing

 Shift-Reduce Parsing
 LR Parser
 Operator Precedence Parsing

UNIT II – Data, Data Types, and Basic

Statements (9 Hours)
1. Names and Variables

 Identifier
 Variable Declaration
 Constants

2. Binding

 Static Binding
 Dynamic Binding

3. Type Checking

 Static Type Checking

 Dynamic Type Checking

4. Scope

 Static Scope
 Dynamic Scope

5. Lifetime and Garbage Collection

  Variable Lifetime
 Heap Memory
 Garbage Collection

6. Primitive Data Types

 Integer
 Float
 Boolean
 Character

7. Strings

 Immutable Strings
 Mutable Strings

8. Array Types

 Static Arrays
 Dynamic Arrays
 Multidimensional Arrays

9. Associative Arrays

 Key-Value Pairs
 Hash Tables

10. Record Types

 Structures
 Records

11. Union Types

 Shared Memory
 Variant Records

12. Pointers and References

 Pointer Variables
 References
 Dangling Pointers

13. Arithmetic Expressions

 Operators
 Operator Precedence

14. Overloaded Operators

  Operator Overloading

15. Type Conversions

 Implicit Conversion
 Explicit Conversion (Casting)

16. Relational and Boolean Expressions

 Comparison Operators
 Logical Operators

17. Assignment Statements

 Simple Assignment
 Compound Assignment

18. Mixed Mode Assignments

 Automatic Type Conversion

19. Control Structures

 Sequence
 Selection
 Iteration

20. Selection Statements

 if
 if-else
 switch

21. Iteration

 for
 while
 do-while

22. Branching

 break
 continue
 goto

23. Guarded Statements

 Guarded Commands
 Non-deterministic Selection
UNIT III – Subprograms and
Implementations (9 Hours)
1. Subprograms

 Procedures
 Functions

2. Design Issues

 Parameter Passing
 Return Values
 Local Variables

3. Local Referencing Environment

 Local Scope
 Global Scope

4. Parameter Passing Methods

 Pass by Value
 Pass by Reference
 Pass by Result
 Pass by Value-Result
 Pass by Name

5. Overloaded Methods

 Same Function Name

 Different Parameters

6. Generic Methods

 Templates
 Generics

7. Design Issues for Functions

 Side Effects
 Return Types

8. Semantics of Call and Return

 Activation Record
  Call Stack

9. Implementing Simple Subprograms

 Stack Allocation
 Return Address

10. Stack and Dynamic Local Variables

 Stack Memory
 Heap Allocation

11. Nested Subprograms

 Inner Functions

12. Blocks

 Compound Statements

13. Dynamic Scoping

 Runtime Scope Resolution

UNIT IV – Object Orientation,

Concurrency, and Event Handling (9
Hours)
1. Object-Oriented Programming

 Class
 Object
 Encapsulation
 Inheritance
 Polymorphism
 Abstraction

2. Design Issues for OOP Languages

 Visibility
 Constructors
 Destructors
 Method Binding
3. Implementation of OOP Constructs

 Object Layout
 Virtual Functions
 Dynamic Dispatch

4. Concurrency

 Parallel Execution
 Synchronization

5. Semaphores

 Binary Semaphore
 Counting Semaphore

6. Monitors

 Mutual Exclusion
 Condition Variables

7. Message Passing

 Synchronous Communication
 Asynchronous Communication

8. Threads

 User Threads
 Kernel Threads

9. Statement-Level Concurrency

 Parallel Statements

10. Exception Handling

 try
 catch
 throw
 finally

11. Event Handling

 Event
 Event Listener
 Callback Functions
UNIT V – Functional and Logic
Programming Languages (9 Hours)
1. Introduction to Lambda Calculus

 Lambda Expressions
 Function Application
 Variables

2. Fundamentals of Functional Programming

 Pure Functions
 Recursion
 Higher-Order Functions
 Immutability

3. Programming with Scheme

 Lists
 Recursion
 Functions

4. Programming with ML

 Pattern Matching
 Type Inference
 Recursive Functions

5. Introduction to Logic Programming

 Facts
 Rules
 Queries

6. Programming with Prolog

 Predicates
 Unification
 Backtracking
 Recursion

7. Multi-Paradigm Languages

Languages supporting multiple programming paradigms, such as:

 Python
 Scala
  Kotlin
 JavaScript
 C++

Important Exam Topics (Frequently Asked)

Unit I

 Context-Free Grammar (CFG)

 Attribute Grammar
 Lexical Analysis
 Recursive Descent Parser
 Bottom-Up Parsing
 Types of Semantics

Unit II

 Scope vs Lifetime
 Type Checking
 Binding
 Garbage Collection
 Arrays vs Associative Arrays
 Pointer vs Reference
 Type Conversion
 Control Statements

Unit III

 Parameter Passing Methods

 Activation Record
 Stack Allocation
 Dynamic Scoping
 Generic Methods
 Overloading

Unit IV

 OOP Concepts
 Semaphores
 Monitors
 Threads
 Message Passing
 Exception Handling

Unit V

 Lambda Calculus
  Functional Programming Concepts
 Scheme Basics
 ML Basics
 Prolog (Facts, Rules, Queries)
 Multi-Paradigm Languages

This summary covers the major concepts from all five units and is suitable as a quick revision
guide before exams.