Programming Languages

Course plan presentation; reasons for studying languages; domains, criteria, and categories; evolution of major languages and programming paradigms (Sebesta, chs. 1-2)

Formal syntax description: BNF, EBNF, grammars, and parse trees (Sebesta, ch. 3.1-3.3)

Attribute grammars; static and dynamic semantics (Sebesta, ch. 3.4-3.5)

Lexical and syntax analysis; compilation stages and programming environments (Sebesta, ch. 4 and sections 1.7-1.8)

Names, variables, bindings, scope, and lifetime (Sebesta, ch. 5)

Data types, type checking, strong typing, and type equivalence (Sebesta, ch. 6)

Expressions, type conversions, and assignment statements (Sebesta, ch. 7)

Control structures: selection, iteration, and guarded commands (Sebesta, ch. 8)

Subprograms: local environments, parameter passing, functions, closures, and implementation (Sebesta, chs. 9-10)

Inheritance, composition, polymorphism, and exception handling (Sebesta, chs. 12 and 14.1-14.4)

Mathematical functions, lambda calculus, and functional paradigm fundamentals (Sebesta, ch. 15.1-15.3)

Lisp and introduction to Scheme (Sebesta, ch. 15.4-15.5)

Scheme practice: recursion and list processing (Sebesta, ch. 15.5)

Higher-order functions: map, filter, and reduce (Sebesta, ch. 15.5-15.6)

ML and pattern matching (Sebesta, ch. 15.7)

Haskell: type system and list comprehensions (Sebesta, ch. 15.8)

Haskell: higher-order functions and lazy evaluation; F# overview (Sebesta, ch. 15.8-15.9)

Science and Technology Week - guided, non-assessment activity: functional support in imperative languages (Sebesta, ch. 15.10)

Science and Technology Week - non-assessment comparative seminar: functional and imperative paradigms (Sebesta, ch. 15.11)

Integrated functional programming lab: higher-order functions, patterns, and lazy evaluation (Sebesta, ch. 15)

Logical statements, predicate calculus, theorem proving, and unification (Sebesta, ch. 16.1-16.4)

Prolog: origins, basic elements, limitations, and applications (Sebesta, ch. 16.5-16.8)

Event-driven programming: callbacks and event handling (Sebesta, ch. 14.5-14.7)

Promises and asynchronous programming (syllabus Unit 6; supplementary reading)

Concurrency fundamentals, parallelism, and subprogram-level concurrency (Sebesta, ch. 13.1-13.2)

Threads, semaphores, and monitors (Sebesta, ch. 13.3-13.4 and 13.7-13.8)

Coroutines and message passing (Sebesta, ch. 9.13 and 13.5)

Concurrency in functional languages, statement-level parallelism, and distributed computing (Sebesta, ch. 13.9-13.10; supplementary reading)

Integrative seminar: critical comparison of paradigms and languages using the criteria from ch. 1

Course synthesis, final review, activity feedback, and end-of-semester wrap-up