Embedded Files
|| Students will need to log in with their Stony Brook University single sign-on (SSO) to access the slides and other material ||
Practice problems on Lambda calculus (prepared by Drushti Mewada)
Overview of the course, and introduction to programming paradigms [ slides ] [ chapter 2 ]
Syntax and semantics, and the untyped lambda calculus [ slides ] [ chapter 11 ]
Functional programming with OCaml [ slides ] [ chapter 11 ]
Introduction to types and type systems [ slides ] [ chapters 7 and 8 ]
More on data types: recursive and algebraic types [ slides ] [ chapters 7 and 8 ]
Namespaces and scopes [ slides ] [ video ] [ chapter 3]
Namespaces, scopes, and bindings by Sai Chandan Masipeddi
Static and dynamic view of scopes by Mayukh Bhattacharyya
Elements of functional programming with Java: lazy evaluations, streams, lambda expressions [ slides ] [ chapters 6, 10, and 11 ]
Subtype polymorphism and type systems [ slides ] [ chapter 10 ]
- Note: Apr 4 was a virtual lecture. The recording is available to registered students through Blackboard. Go to Zoom Meeting, and check the Cloud Recordings tab.
Concurrent programming [ slides ] [ chapter 13 ]
Object-oriented programming with dynamic typing [ slides ]
- The first half is mostly the same as the "self-study" slides posted earlier. The second half (slide no. 59 onwards) discusses parameter passing and OOP in Python.
Remaining
Lectures 1-2: Introduction to programming paradigms. Overview of imperative programming, procedural programming, declarative programming, etc, and juxtaposing them. Introduction to syntax and semantics. Introduction to formal grammar, metalanguage, and Backus-Naur form. [Ch. 2]
Lectures 3-6: Functional programming. Untyped Lambda Calculus. OCAML (recursive and lists). [Ch. 11]
Lectures 7-10: Names, Scopes and Bindings (namespaces, dynamic and static view of scope, global, local, and non-local scopes). Memory management: (stack allocation, dynamic memory allocation, memory blocks, fragmentation, garbage collection). [Ch. 3]
Lectures 11-14: Data types (incl. algebraic data types and recursive data types). Type systems: static vs. dynamic, compile-time vs. runtime, strong vs. weak. Type equivalence and type checking. Dynamic typing and annotations (with examples from Python). [Ch. 7 & 8]
Lectures 15-18: Control flow and control abstractions. Recursion, Continuations, coroutines. Iterators and generators in Java and Python, the iterator design pattern. Parameter passing. [Ch. 6 & 9]
Lecture 19: Subtype polymorphism, relation to type systems, type hierarchy, and inheritance. Relation to type conversion. The “diamond problem” (type hierarchy tree versus lattice). Interfaces in Java. Information hiding, Encapsulation. [Ch. 10]
Lectures 20-22: Magic methods. Operator overloading. Inheritance, instance and class attributes, class methods and static methods. Multiple inheritance. Parametric polymorphism. Reified types and erased types. Type erasure and bridge methods in Java. Overloading and overriding with type parameters. Bounds on parameters vis-a-vis type hierarchy. Variance of parametric types, return types, and argument types. [Ch. 10]
Lectures 23-24: Introduction to Concurrent programming (e.g. concurrency versus parallelism, processes and threads, synchronous versus asynchronous tasks, atomicity and critical regions, memory inconsistency errors, race conditions, deadlock, starvation, livelock: the dining philosopher’s problem, persistent data structures). Concurrent models (e.g. assembly-line model, producer-consumer model). Concurrency vs. coroutines. [Ch. 13]
OO Design: UML diagrams (class diagrams; use-case diagrams; sequence diagrams). Software design documents. Design patterns.
Page updated
Report abuse