Mediaspace scheduled maintenance: Aug 25, 2026 07:00 - 12:00 AM. During this time, videos will be temporarily unavailable. Check status updates.

Course

CS-210: Functional programming

Lectures in this course (70)

Water Pouring Problem: Strategy and Code

Covers the Water Pouring Problem strategy and Scala code implementation.

Contextual abstraction: Functional Programming

Explores contextual abstraction in programming through function parameters and implicit parameters to reduce boilerplate code.

Type-Directed Programming: Using Clauses

Covers using clauses, context bounds, given instances, and implicit parameter resolution in Scala.

Type Classes: Basics and Implementation

Covers the basics of type classes in Scala, implementation examples, and advantages over class extension.

Abstract algebra and type classes

Covers abstract algebra concepts using type classes in Scala, including defining monoids, generalizing reduce functions, and typeclass laws.

Blocks and Lexical Scopes

Explores nested functions, blocks, visibility rules, and lexical scoping in Scala.

Context Passing: Execution Contexts

Covers context passing vs type classes, execution contexts, tamper-proofing, and the importance of specificity in Scala.

Implicit Function Types

Explores implicit function types and their application in a conference management system, discussing the trade-off between types and terms in implicit parameters.

Functions and state

Explores functions, state, rewriting, and stateful objects in programming.

Identity and Change

Explores how assignments affect the equivalence between expressions in programming.

Loops: Control Statements and Functions

Covers modeling control statements with functions in Scala, including while loops, repeat loops, and for-loops translation.

Discrete Event Simulation

Covers discrete event simulation using digital circuits, base components, complex components, and simulation implementation.

Imperative Event Handling: The Observer Pattern

Introduces the widely used Observer Pattern for views to react to model changes, with examples of Publisher, Subscriber, and a Consolidator.

Functional Reactive Programming

Covers the basics of Functional Reactive Programming, including signal aggregation, fundamental operations, constant and variable signals, and signal interpretation.

A Simple FRP Implementation

Covers the simple implementation of Signals and Vars in functional reactive programming, including dependency maintenance and implicit function types.

Functional Reactive Programming Basics

Covers the basics of functional reactive programming, including APIs, implementation details, creating signals, and evaluating signals.

Tail Recursion

Covers tail recursion, optimizing functions in Scala for iterative processes and providing examples like tail-recursive factorial.

Interpreter: Arithmetic Expressions

Covers a simple functional language, abstract syntax trees, interpreting expressions, and desugaring.

Recursive Functions: Substitution Interpreter

Covers the implementation of recursive functions using substitutions and environments, showcasing the ability to execute computable functions.

Environment instead of Substitutions

Presents an environment-based interpreter for recursive functions, optimizing evaluation through parameter bindings and eliminating the need for explicit substitutions.