Programming Languages Course

Lesson 1 • History and Evolution of Languages

Traces language development from assembly through modern paradigms. Provides historical context for understanding current design decisions.

Lesson 2 • What Is a Programming Language

Defines programming languages as formal systems for expressing computation. Establishes vocabulary used throughout the course.

Lesson 3 • Language Classification and Paradigms

Categorizes languages by paradigm: imperative, functional, logic, and object-oriented. Prepares students to evaluate any language against a taxonomy.

Lesson 1 • Abstract Syntax Trees

Distinguishes abstract syntax trees from parse trees and explains their role in compilation. Prepares students for semantic analysis in later chapters.

Lesson 2 • Top-Down and Bottom-Up Parsing

Compares recursive-descent and shift-reduce parsing strategies. Equips students to choose and implement appropriate parsers.

Lesson 3 • Lexical Analysis and Tokenization

Covers the role of the lexer in converting source text into tokens before parsing. Bridges raw source code and grammar-level analysis.

Lesson 4 • Parse Trees and Ambiguity

Explains how parse trees represent syntactic structure and how ambiguity undermines deterministic parsing. Directly supports grammar design skills.

Lesson 1 • Approaches to Formal Semantics

Introduces operational, denotational, and axiomatic semantics as complementary frameworks. Establishes the basis for reasoning about program correctness.

Lesson 2 • Type Systems Fundamentals

Defines types, type checking, and the spectrum from static to dynamic typing. Connects type discipline to program reliability.

Lesson 3 • Type Inference and Polymorphism

Covers algorithm-based type inference and parametric polymorphism. Demonstrates how languages achieve generality without sacrificing safety.

Lesson 1 • Variables and Storage Models

Examines variable attributes—name, type, value, lifetime—and how storage is allocated. Grounds all subsequent scope and binding discussions.

Lesson 2 • Namespaces and Modules

Covers namespace mechanisms that partition the global scope and support large-scale programs. Bridges scope theory to practical software organization.

Lesson 3 • Scope Rules and Visibility

Contrasts static (lexical) and dynamic scoping and their effects on name resolution. Directly impacts how students read and write code in any language.

Lesson 1 • Concurrency and Coroutines

Introduces threads, async/await, and coroutines as advanced control-flow abstractions. Extends structured programming to concurrent execution models.

Lesson 2 • Subprograms and Parameter Passing

Examines function and procedure design, including all parameter-passing modes. Connects to scope and binding concepts from the previous chapter.

Lesson 3 • Conditional and Selection Statements

Covers if-else, switch, and pattern-matching constructs across paradigms. Establishes the baseline for all control-flow study.

Lesson 4 • Iteration and Loop Constructs

Analyzes counter-controlled, condition-controlled, and collection-based loops. Prepares students to reason about termination and efficiency.

Lesson 1 • OOP Design Patterns in Practice

Applies classic design patterns to reinforce OOP principles. Bridges language features to professional software architecture.

Lesson 2 • Imperative Language Core Concepts

Reviews assignment, sequencing, and state mutation as the foundation of imperative programming. Anchors OOP study in procedural roots.

Lesson 3 • Classes, Objects, and Encapsulation

Defines classes as templates and objects as instances, emphasizing encapsulation. Builds the structural vocabulary for OOP design.

Lesson 4 • Inheritance and Polymorphism

Covers single and multiple inheritance, method overriding, and dynamic dispatch. Connects type system concepts to OOP runtime behavior.

Lesson 1 • Higher-Order Functions and Closures

Covers map, filter, fold, and closure capture as fundamental functional tools. Builds on scope and binding knowledge from earlier chapters.

Lesson 2 • Algebraic Data Types and Pattern Matching

Uses sum and product types with pattern matching to model data precisely. Reinforces type system concepts in a functional context.

Lesson 3 • Core Functional Concepts

Introduces pure functions, immutability, and referential transparency as the pillars of functional programming. Contrasts with imperative state mutation.

Lesson 4 • Recursion and Tail-Call Optimization

Examines recursion as the primary iteration mechanism and tail-call optimization as a performance strategy. Connects to control-flow concepts.

Lesson 1 • Manual Memory Management

Covers explicit allocation and deallocation, including common errors like leaks and dangling pointers. Connects to variable lifetime concepts.

Lesson 2 • Runtime System Architecture

Explores the components of a language runtime: call stack, heap manager, and GC integration. Synthesizes all memory topics into a unified model.

Lesson 3 • Garbage Collection Algorithms

Surveys mark-and-sweep, reference counting, and generational GC strategies. Equips students to reason about GC overhead and pause times.

Lesson 4 • Memory Layout and Allocation

Describes stack, heap, and static memory regions and how languages allocate objects. Grounds all memory management discussions.