CMPT 383 Lecture Notes

1. Course Introduction [“Course Introduction” slides]
   1. This Course [This Course slides]
   2. Online Offering Strategy [Online 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. Quizzes [Quizzes slides]
   9. Project [Project slides]
   10. References [References slides]
   11. Expectations [Expectations slides]
   12. What is a program? [What is a program? slides]
   13. Imperative Programming [Imperative Programming slides]
   14. 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 Implementations [“Language Implementations” slides]
   1. Language Choice [Language Choice slides]
   2. Compilers & Interpreters [Compilers & Interpreters slides]
   3. Virtual Machines [Virtual Machines slides]
   4. Compiler Optimization [Compiler Optimization slides]
   5. Just-In-Time Compilation [Just-In-Time Compilation slides]
   6. Language Implementations [Language Implementations slides]
   7. A Silly Benchmark [A Silly Benchmark slides]
7. Languages: Types & Memory [“Languages: Types & Memory” slides]
   1. Static/Dynamic Typing [Static/Dynamic Typing slides]
   2. Static/Dynamic Binding [Static/Dynamic Binding slides]
   3. Type Inference [Type Inference slides]
   4. Duck Typing [Duck Typing slides]
   5. Type Checking [Type Checking slides]
   6. Mutable/Immutable Data [Mutable/Immutable Data slides]
   7. Memory Management [Memory Management slides]
   8. Managing Memory [Managing Memory slides]
   9. Manual Memory Mgmt. [Manual Memory Mgmt. slides]
   10. Garbage Collection [Garbage Collection slides]
   11. Tracking Ownership [Tracking Ownership slides]
   12. First-Class Functions [First-Class Functions slides]
   13. Closures [Closures slides]
   14. Callbacks [Callbacks slides]
   15. Coroutines [Coroutines slides]
8. 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. Concurrency Tools [Concurrency Tools slides]
9. 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]
10. 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]
11. Concurrent Programming & Go [“Concurrent Programming & Go” slides]
    1. Go [Go slides]
    2. Language Basics [Language Basics slides]
    3. Variables [Variables slides]
    4. Functions [Functions slides]
    5. Conditionals [Conditionals slides]
    6. Loops [Loops slides]
    7. Structs [Structs slides]
    8. Structs as Classes [Structs as Classes slides]
    9. Types [Types slides]
    10. Arrays and Slices [Arrays and Slices slides]
12. Goroutines & Channels [“Goroutines & Channels” slides]
    1. Goroutines [Goroutines slides]
    2. Channels [Channels slides]
    3. Channel Range [Channel Range slides]
    4. Buffered Channels [Buffered Channels slides]
    5. Channel Select [Channel Select slides]
    6. Concurrency Plan [Concurrency Plan slides]
13. Go Structs [“Go Structs” slides]
    1. Pointers [Pointers slides]
    2. Struct Pointers [Struct Pointers slides]
    3. Pass by Value [Pass by Value slides]
    4. References [References slides]
    5. Type Definitions [Type Definitions slides]
    6. Interfaces [Interfaces slides]
    7. Implementing Interfaces [Implementing Interfaces slides]
    8. Common Interfaces [Common Interfaces slides]
    9. The Empty Interface [The Empty Interface slides]
    10. Inheritance [Inheritance slides]
    11. Handling Errors [Handling Errors slides]
14. Go Concurrency Patterns [“Go Concurrency Patterns” slides]
    1. Goroutines as Coroutines [Goroutines as Coroutines slides]
    2. WaitGroups [WaitGroups slides]
    3. Parallel Mapping [Parallel Mapping slides]
    4. Divide and Conquer [Divide and Conquer slides]
    5. Concurrent Wrap-Up [Concurrent Wrap-Up slides]
15. Logic Programming & Prolog
16. Languages Matter

Course home page.

Schedule, Summer 2020

Week	Deliverables (*)	Lecture Hour	Date	First Slide	Video Link
1		1	May 12	Intro	1-1 (0:35)
		2	May 12	Functional Programming	1-2 (0:43)
		3	May 14	Pattern Matching	1-3 (0:43)
2	Exer 1	4	May 19	Repetition	2-1 (0:37)
		5	May 19	Isn't Recursion Slow?	2-2 (0:41)
		6	May 21	Parts of Lists	2-3 (0:48)
3	Exer 2	7	May 26	Haskell Types	3-1 (0:53)
		8	May 26	Curried Functions	3-2 (0:48)
		9	May 28	Lazy Evaluation	3-3 (0:41)
4	Exer 3	10	Jun 2	Concurrent Programming	4-1 (0:51)
		11	Jun 2	Monad: Maybe	4-2 (0:48)
		12	Jun 4	Functional + Imperative	4-3 (0:49)
5	Exer 4	13	Jun 9	Pipelines	5-1 (0:52)
		14	Jun 9	Compilers & Interpreters	5-2 (0:35)
		15	Jun 11	Just-In-Time Compilation	5-3 (0:47)
6	Exer 5	16	Jun 16	Static/​Dynamic Binding	6-1 (0:47)
		17	Jun 16	Duck Typing	6-2 (0:37)
		18	Jun 18	Mutable/​Immutable	6-3 (0:43)
7	Exer 6, Assign 1	19	Jun 23	First-Class Functions	7-1 (0:48)
		20	Jun 23	Coroutines	7-2 (0:48)
		21	Jun 25	Concurrency Tools	7-3 (0:46)
8	Quiz 1	22	Jun 30	Review/​Q&A	live stream
		23	Jun 30
		24	Jul 2	Quiz 1
9	Exer 7	25	Jul 7	Language Features Conclusion	9-1 (0:45)
		26	Jul 7	Go Functions	9-2 (0:45)
		27	Jul 9	Go Structs	9-3 (0:50)
10	Exer 8, Assign 2	28	Jul 14	Go Channels	10-1 (0:49)
		29	Jul 14	Struct Pointers	10-2 (0:45)
		30	Jul 16	Interfaces	10-3 (0:45)
11	Exer 9, Quiz 2	31	Jul 21
		32	Jul 21	Review/​Q&A	live stream
		33	Jul 23	Quiz 2
12	Exer 10, Assign 3	34	Jul 28
		35	Jul 28
		36	Jul 30
13	Exer 11, Quiz 3	37	Aug 4
		38	Aug 4
		39	Aug 6	Quiz 3
14	Project

* Check CourSys for the actual due dates and times.