Lecture

Safe Mutation in Practice

Related lectures (30)

Functional Programming: Concepts and Implementation

Covers the concepts and implementation of functional programming in Scala, emphasizing functions, immutable data, and data abstraction.

Lazy Evaluation: Lazy Lists

Explores lazy evaluation and lazy lists in Scala, emphasizing their benefits and implementation.

Verifying Programs with Stainless: Part 2

Focuses on using Stainless for program verification, demonstrating the process of verifying programs and ensuring correctness.

Stainless Verification System Tutorial

Introduces Stainless, an open-source tool for verifying Scala programs, covering language, modeling, verification tips, and inner workings.

Compiler Extension Lab

Covers the Compiler Extension Lab, focusing on adding new functionality to a simple functional language compiler.

Functional Programming Basics in Scala

Covers the basics of functional programming in Scala, including evaluation strategies, conditionals, and value definitions, with a focus on computing square roots with Newton's method.

Lazy Evaluation: Introduction and Examples

Covers lazy evaluation, memoization, interpreter implementation, code generation challenges, and potential extensions.

Recursive Functions: Substitution Interpreter

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

Optimal Stopping Problems: Theory and Applications

Covers optimal stopping problems in applied probability and stochastic processes, focusing on theory and practical applications.

Lazy Evaluation

Explores lazy evaluation in functional programming, focusing on Scala's implementation of lazy lists.

Programming Paradigms: Functional, OOP, Polymorphism

Explores programming paradigms like procedural, functional, and OOP, with examples in Python.

Cache Memory

Explores cache memory design, hits, misses, and eviction policies in computer systems, emphasizing spatial and temporal locality.

Big-step semantics: Defining arithmetic expressions and commands

Covers the definition of a simple programming language and its big-step semantics, including arithmetic expressions and imperative commands.

Designing Algorithms: Recursion and Dynamic Programming

Explores designing algorithms with recursion and dynamic programming, covering concepts like the Towers of Hanoi and efficient solutions.

Caches - Performance

Explores cache memory performance evaluation, covering benchmarks, Amdahl's law, CPU performance, memory hierarchy, cache optimizations, and multilevel caches.

Blocks and Lexical Scopes

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

Dynamic Programming: Introduction and Fibonacci Numbers

Introduces Dynamic Programming, focusing on saving computation by remembering previous calculations and applying it to solve optimization problems efficiently.

Lazy Lists: Delayed Evaluation and Efficient Computation

Covers Lazy Lists, delaying computation for efficiency in combinatorial search.

Functional Decomposition: Pattern Matching

Covers functional decomposition with pattern matching in Scala to access heterogeneous data in a class hierarchy.

Practical Engineering 1: Signal Processing

Explores advanced software engineering topics and signal processing using lazy lists to build a sound synthesizer from scratch.