CMPT 383 Lecture Notes

  1. Course Introduction [“Course Introduction” slides]
    1. This Course [This Course slides]
    2. Overall Goals [Overall Goals slides]
    3. Topics (1) [Topics (1) slides]
    4. Grades [Grades slides]
    5. Weekly Exercises [Weekly Exercises slides]
    6. Assignments [Assignments slides]
    7. Exams [Exams slides]
    8. References [References slides]
    9. Expectations [Expectations slides]
    10. What is a program? [What is a program? slides]
    11. Imperative Programming [Imperative Programming slides]
    12. Declarative Programming [Declarative Programming slides]
  2. Functional Programming & Haskell [“Functional Programming & Haskell” slides]
    1. Haskell [Haskell slides]
    2. Haskell Basics [Haskell Basics slides]
    3. Haskell Functions [Haskell Functions slides]
    4. Pattern Matching [Pattern Matching slides]
    5. Conditionals [Conditionals slides]
    6. Repetition [Repetition slides]
    7. List Comprehensions [List Comprehensions slides]
    8. Let and Where [Let and Where slides]
    9. Recursion [Recursion slides]
    10. Isn't Recursion Slow? [Isn't Recursion Slow? slides]
    11. Tail Recursion [Tail Recursion slides]
    12. Creating Tail Recursion [Creating Tail Recursion slides]
    13. Aside: C and Tail Recursion [Aside: C and Tail Recursion slides]
  3. Haskell: Types & Functions [“Haskell: Types & Functions” slides]
    1. Functions and Operators [Functions and Operators slides]
    2. Parts of Lists [Parts of Lists slides]
    3. More List Processing [More List Processing slides]
    4. Haskell Types [Haskell Types slides]
    5. Type Classes [Type Classes slides]
    6. Partially-Applied Functions [Partially-Applied Functions slides]
    7. Curried Functions [Curried Functions slides]
    8. Manipulating Functions [Manipulating Functions slides]
    9. Lambda Expressions [Lambda Expressions slides]
  4. Haskell: Expression Evaluation [“Haskell: Expression Evaluation” slides]
    1. Assignment 1 [Assignment 1 slides]
    2. Lazy Evaluation [Lazy Evaluation slides]
    3. Controlling Laziness [Controlling Laziness slides]
    4. Function Application [Function Application slides]
    5. Pure Functions [Pure Functions slides]
    6. Concurrent Programming [Concurrent Programming slides]
    7. Monads [Monads slides]
    8. Monad: Maybe [Monad: Maybe slides]
    9. Monad: Random Numbers [Monad: Random Numbers slides]
    10. Records [Records slides]
    11. Haskell Tips [Haskell Tips slides]
    12. Functional Programming Context [Functional Programming Context slides]
    13. Functional + Imperative [Functional + Imperative slides]
  5. What Do Processors Do? [“What Do Processors Do?” slides]
    1. What Does A Programming Language Do? [What Does A Programming Language Do? slides]
    2. What Does A Compiler Do? [What Does A Compiler Do? slides]
    3. What Do Processors Do? [What Do Processors Do? slides]
    4. Pipelines [Pipelines slides]
    5. SIMD [SIMD slides]
    6. Multiple Cores [Multiple Cores slides]
    7. Memory Cache [Memory Cache slides]
    8. Summary [Summary slides]
  6. Language Design [“Language Design” slides]
    1. Language Choice [Language Choice slides]
    2. Language Paradigm [Language Paradigm slides]
    3. Code Organization [Code Organization slides]
    4. Compilers & Interpreters [Compilers & Interpreters slides]
    5. Virtual Machines [Virtual Machines slides]
    6. Compiler Optimization [Compiler Optimization slides]
    7. Just-In-Time Compilation [Just-In-Time Compilation slides]
    8. Language Implementations [Language Implementations slides]
    9. A Silly Benchmark [A Silly Benchmark slides]
  7. Languages: Types [“Languages: Types” slides]
    1. Static/Dynamic Typing [Static/Dynamic Typing slides]
    2. Gradual Typing [Gradual Typing slides]
    3. Static/Dynamic Binding [Static/Dynamic Binding slides]
    4. Generics & Polymorphism [Generics & Polymorphism slides]
    5. Type Inference [Type Inference slides]
    6. Type Checking [Type Checking slides]
    7. Mutable/Immutable Data [Mutable/Immutable Data slides]
  8. Languages: Memory
  9. Languages & Concurrency
  10. Languages: Expressing Logic
  11. Languages: Functions
  12. Language Productivity
  13. Languages: Mixing Languages
  14. Rust & “Safe” Programming
  15. Rust: Concurrency
  16. Rust: Memory Management
  17. Rust: Epilogue
  18. Languages Matter

Course home page; lecture audio recordings.

Schedule, Summer 2025

Week Deliverables (*) Lecture Hour Lecture Date First Slide
1 1, 2 May 12 Intro
3 May 14 Pattern Matching
2 Exer 1 4, 5 May 19 Victoria Day holiday 👑
6 May 21 List Comprehensions
3 Exer 2 7, 8 May 26 Creating Tail Recursion
9 May 28 Type Classes
4 Exer 3 10, 11 Jun 2 Lambda Expressions
12 Jun 4 Concurrent Programming
5 Exer 4 13, 14 Jun 9 Monads
15 Jun 11 Processors
6 Exer 5 16, 17 Jun 16 Memory Cache
18 Jun 18 Language Implementations
7 Assign 1 19, 20 Jun 23
21 Jun 25
8 Exer 6, Midterm 22, 23 Jun 30 no lecture?
24 Jul 2 Midterm Exam
9 Assign 2 25, 26 Jul 7
27 Jul 9
10 Exer 7 28, 29 Jul 14
30 Jul 16
11 Exer 8 31, 32 Jul 21
33 Jul 23
12 Exer 9 34, 35 Jul 28
36 Jul 30
13 Exer 10, Assign 3 37, 38 Aug 4 BC Day holiday 🌲
39 Aug 6
14+ Final Exam —

* Check CourSys for the actual due dates and times.

Exam instruction slide.