CMPT 383 Lecture Notes

  1. Course Introduction [“Course Introduction” slides]
    1. This Course [This Course slides]
    2. Offering Strategy [Offering Strategy slides]
    3. Topics (1) [Topics (1) slides]
    4. Overall Goals [Overall Goals slides]
    5. Grades [Grades slides]
    6. Weekly Exercises [Weekly Exercises slides]
    7. Assignments [Assignments slides]
    8. Exams [Exams slides]
    9. References [References slides]
    10. Expectations [Expectations slides]
    11. What is a program? [What is a program? slides]
    12. Imperative Programming [Imperative Programming slides]
    13. 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. Haskell Tips [Haskell Tips slides]
    11. Functional Programming Context [Functional Programming Context slides]
    12. 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 [“Languages: Memory” slides]
    1. Managing Memory [Managing Memory slides]
    2. Manual Memory Mgmt. [Manual Memory Mgmt. slides]
    3. Garbage Collection [Garbage Collection slides]
    4. Tracking Ownership [Tracking Ownership slides]
  9. Languages & Concurrency [“Languages & Concurrency” slides]
    1. Concurrent Programming [Concurrent Programming slides]
    2. Threads & Processes [Threads & Processes slides]
    3. Kernel/User Threads [Kernel/User Threads slides]
    4. Thread Communication [Thread Communication slides]
    5. Language Concurrency [Language Concurrency slides]
    6. Async Programming [Async Programming slides]
    7. Concurrency Tools [Concurrency Tools slides]
  10. Languages: Functions [“Languages: Functions” slides]
    1. First-Class Functions [First-Class Functions slides]
    2. Closures [Closures slides]
    3. Callbacks [Callbacks slides]
    4. Coroutines [Coroutines slides]
    5. Undefined Behaviour [Undefined Behaviour slides]
  11. Language Productivity [“Language Productivity” slides]
    1. Programmer Efficiency [Programmer Efficiency slides]
    2. Library Availability [Library Availability slides]
    3. High- vs Low-Level [High- vs Low-Level slides]
    4. Programming Paradigm [Programming Paradigm slides]
    5. Language Features [Language Features slides]
  12. Languages: Mixing Languages [“Languages: Mixing Languages” slides]
    1. Foreign Function Calls [Foreign Function Calls slides]
    2. Remote Procedure Calls [Remote Procedure Calls slides]
    3. Summary [Summary slides]
  13. Rust & “Safe” Programming [“Rust & “Safe” Programming” slides]
    1. Ownership [Ownership slides]
    2. Rust [Rust slides]
    3. Variables & Types [Variables & Types slides]
    4. Compound Types [Compound Types slides]
    5. Mutability [Mutability slides]
    6. Control Flow [Control Flow slides]
    7. More Expressions [More Expressions slides]
    8. Functions [Functions slides]
    9. Vectors [Vectors slides]
    10. References [References slides]
    11. Borrowing [Borrowing slides]
    12. Ownership [Ownership slides]
    13. Ownership Rules [Ownership Rules slides]
    14. Moving and Copying [Moving and Copying slides]
    15. Cloning [Cloning slides]
    16. Structs [Structs slides]
    17. Traits [Traits slides]
    18. Generic Types [Generic Types slides]
    19. Core Traits [Core Traits slides]
    20. Errors [Errors slides]
  14. Rust: Concurrency [“Rust: Concurrency” slides]
    1. Threads [Threads slides]
    2. Messages [Messages slides]
    3. More Concurrency Tools [More Concurrency Tools slides]
  15. Rust: Memory Management [“Rust: Memory Management” slides]
    1. Static Binding [Static Binding slides]
    2. Data Structures [Data Structures slides]
    3. The Heap and Box [The Heap and Box slides]
    4. More Smart Pointers [More Smart Pointers slides]
    5. Shared Mutable State [Shared Mutable State slides]
    6. Dynamic Values [Dynamic Values slides]
  16. Rust: Epilogue [“Rust: Epilogue” slides]
    1. The Other Rusts [The Other Rusts slides]
    2. What Is Rust? [What Is Rust? slides]
  17. Logic Programming & Prolog [“Logic Programming & Prolog” slides]
    1. Predicates [Predicates slides]
    2. Rules [Rules slides]
    3. Searching [Searching slides]
    4. Search Limits [Search Limits slides]
    5. Conclusion [Conclusion slides]
  18. Languages Matter [“Languages Matter” slides]
    1. Domain-Specific Languages [Domain-Specific Languages slides]
    2. Domain-Specific Libraries [Domain-Specific Libraries slides]
    3. Languages Don't Matter [Languages Don't Matter slides]
    4. Conclusion [Conclusion slides]

Course home page.

Schedule, Summer 2023

Week Deliverables (*) Lecture Hour Lecture Date First Slide Video Link
1 1 May 8 Intro 1-1 (0:49)
2 May 8 Haskell Basics 1-2 (0:38)
3 May 10 Pattern Matching 1-3 (0:49)
2 Exer 1 4 May 15 Let and Where 2-1 (0:48)
5 May 15 Creating Tail Recursion 2-2 (0:50)
6 May 17 Haskell Types 2-3 (0:49)
3 Exer 2 7 May 22 Victoria Day holiday 👑
8 May 22
9 May 24 Manipulating Functions 3-1 (0:49)
4 Exer 3 10 May 29 Function Application 4-1 (0:48)
11 May 29 Monads 4-2 (0:44)
12 May 31 Monad: Random 4-3 (0:47)
5 Exer 4 13 Jun 5 Functional + Imperative 5-1 (0:47)
14 Jun 5 Multiple Cores 5-2 (0:48)
15 Jun 7 Compile & Interpret 5-3 (0:48)
6 Exer 5 16 Jun 12 Languages: Types 6-1 (0:48)
17 Jun 12 Static/​Dynamic Binding 6-2 (0:47)
18 Jun 14 Languages: Memory 6-3 (0:45)
7 Assign 1 19 Jun 19 Kernel/​User Threads 7-1 (0:48)
20 Jun 19 Closures 7-2 (0:49)
21 Jun 21 Progr Paradigm 7-3 (0:35)
8 Midterm, Exer 6 22 Jun 26 Midterm
23 Jun 26
24 Jun 28 Rust & “Safe” Progr 8-1 (0:48)
9 Assign 2, Exer 7 25 Jul 3 Canada Day holiday 🍁
26 Jul 3
27 Jul 5 References 9-1 (0:48)
10 Exer 8 28 Jul 10 Traits 10-1 (0:49)
29 Jul 10 Core Traits 10-2 (0:48)
30 Jul 12 Messages 10-3 (0:37)
11 Exer 9 31 Jul 17 Static Binding 11-1 (0:47)
32 Jul 17 Shared Mutable 11-2 (0:33)
33 Jul 19 Rust Epilogue 11-3 (0:42)
12 Exer 10 34 Jul 24 Logic Programming 12-1 (1:12)
35 Jul 24
36 Jul 26 no lecture
13 Assign 3 37 Jul 31
38 Jul 31
39 Aug 2
14+ Final Exam

* Check CourSys for the actual due dates and times.

Exam instruction slide.