NOC:Programming with Generative AI

Lecture 1 - What do Programmers Do ?

Lecture 2 - What is (and isn't) an algorithm ?

Lecture 3 - Algorithms for prime numbers

Lecture 4 - Key Programming Trends

Lecture 5 - Test Your Understanding

Lecture 6 - How effective is GenAI at coding ?

Lecture 7 - Refuting an Algorithm

Lecture 8 - Why is GenAI so effective at coding ?

Lecture 9 - Assumptions in AI-generated code

Lecture 10 - Test Your Understanding

Lecture 11 - Summary

Lecture 12 - Python resources

Lecture 13 - The REPL

Lecture 14 - Basic Arithmetic Operators

Lecture 15 - Test Your Understanding

Lecture 16 - Complex Expressions

Lecture 17 - Limits to arithmetic computation

Lecture 18 - Investigation sys.float_info

Lecture 19 - Binary digits (bits)

Lecture 20 - Naming Things

Lecture 21 - Introducing 'our friend'

Lecture 22 - Test Our Friend's Understanding

Lecture 23 - Limits to float computation

Lecture 24 - Python Objects

Lecture 25 - Textual data

Lecture 26 - Strings

Lecture 27 - Summary

Lecture 28 - Evaluating a complex expression

Lecture 29 - Assignment statements in Python

Lecture 30 - Assignment statements and a common misconception

Lecture 31 - Clarifying the misconception

Lecture 32 - Another misconception with assignments

Lecture 33 - A final misconception with assignments

Lecture 34 - Introduction to PythonTutor

Lecture 35 - Swapping two variables (incorrect)

Lecture 36 - Swapping two variables (correct)

Lecture 37 - Good, Poor, and Illegal Variable names

Lecture 38 - Summary

Lecture 39 - Representing complex programs abstractly as functions

Lecture 40 - Properties of mathematical functions

Lecture 41 - Other built-in functions

Lecture 42 - The input function

Lecture 43 - Celcius to Fahrenheit (buggy)

Lecture 44 - Reviewing our friend's critique of buggy code

Lecture 45 - Debugging the code

Lecture 46 - Nested function calls

Lecture 47 - AI-generated program - 1

Lecture 48 - AI-generated program - 1

Lecture 49 - Another example: Patient Data (buggy)

Lecture 50 - Using ChatGPT to debug

Lecture 51 - Fixing ChatGPT assumptions

Lecture 52 - Using GitHub Copilot to debug

Lecture 53 - Further model assumptions

Lecture 54 - Fixing GitHub Copilot assumptions

Lecture 55 - ChatGPT vs GitHub Copilot

Lecture 56 - Summary

Lecture 57 - Poorly designed and well designed functions

Lecture 58 - Principles of good function design

Lecture 59 - Improvement - 1

Lecture 60 - Improvement - 2

Lecture 61 - Example of a poorly designed function

Lecture 62 - Improvement - 2 (Continued...)

Lecture 63 - Improvement - 3

Lecture 64 - Simple conditional statements

Lecture 65 - Critiquing AI-generated code

Lecture 66 - Complex conditional statements

Lecture 67 - Introduction to Refute problems

Lecture 68 - Summary

Lecture 69 - Example 1 (is_multiple)

Lecture 70 - Visualizing Example 1

Lecture 71 - Visualizing a function call

Lecture 72 - The error in Example 1

Lecture 73 - Fixing the code

Lecture 74 - Key Observations

Lecture 75 - Example 2 (modified is_multiple)

Lecture 76 - Fixing the error, Simplification 1

Lecture 77 - Elements of a Refute Problem

Lecture 78 - Refuting the median function

Lecture 79 - Simplification 2

Lecture 80 - Feedback for Refute Problems

Lecture 81 - Attempting to refute

Lecture 82 - Refuting the num_days function

Lecture 83 - Critique our friend's function

Lecture 84 - Boolean/logical operators

Lecture 85 - Simplification 3

Lecture 86 - Identifying an unexpected behaviour

Lecture 87 - Understanding and fixing the error

Lecture 88 - Short-circuiting

Lecture 89 - Inequivalence due to short-circuiting

Lecture 90 - Summary

Lecture 91 - Solving a problem with a helper function

Lecture 92 - Calling a helper function

Lecture 93 - Tracing a call to the helper function

Lecture 94 - Definition of a leap year

Lecture 95 - Refuting our friend's code

Lecture 96 - Introduction to recursion

Lecture 97 - Infinite recursion

Lecture 98 - A correct recursive function

Lecture 99 - Using the default visualization

Lecture 100 - A non-recursive solution

Lecture 101 - Refuting the buggy code

Lecture 102 - Summary

Lecture 103 - 'Ask the Client' problems

Lecture 104 - Clarifying the task

Lecture 105 - Our friend's recursive function

Lecture 106 - Tracing our friend's code

Lecture 107 - Refuting our friend's code

Lecture 108 - Clarifying questions: num_vowels

Lecture 109 - Strings in Python

Lecture 110 - Testing our understanding

Lecture 111 - Testing out understanding further

Lecture 112 - String operations and methods

Lecture 113 - Testing your understanding

Lecture 114 - Our friend's code: num_vowels

Lecture 115 - Refuting our friend's code

Lecture 116 - Immutable objects

Lecture 117 - Summary

Lecture 118 - Modifying existing code

Lecture 119 - Poor code readability

Lecture 120 - Improving code readability

Lecture 121 - Asking clarifying questions

Lecture 122 - Clarifying the code's expected behaviour

Lecture 123 - Lists are mutable

Lecture 124 - Step 1: Suggested modification

Lecture 125 - Exceptions

Lecture 126 - Tuples

Lecture 127 - Sequence unpacking

Lecture 128 - Summary

Lecture 129 - A mystery (recursive) function

Lecture 130 - Visualizing the mystery function

Lecture 131 - A better (iterative) solution

Lecture 132 - Visualizing a for-loop

Lecture 133 - Pattern 1: Iterate until 'success'

Lecture 134 - Examples of Pattern 1

Lecture 135 - An error in AI-generated code

Lecture 136 - A buggy function using Pattern 1

Lecture 137 - Refuting the buggy function

Lecture 138 - Pattern 2: Accumulate

Lecture 139 - The is_prime function

Lecture 140 - Visualizing prime_product

Lecture 141 - Another version of prime_product

Lecture 142 - Visualizing the new version

Lecture 143 - An example of Pattern 2

Lecture 144 - Another example of Pattern 2

Lecture 145 - Visualizing appending to a list

Lecture 146 - Our friend's suggestion

Lecture 147 - List comprehension

Lecture 148 - A buggy function using Pattern 2

Lecture 149 - Refuting the buggy function

Lecture 150 - An interesting takeaway

Lecture 151 - Summary

Lecture 152 - A recursive mystery function

Lecture 153 - Iterative version

Lecture 154 - Replacing while with for : Example 1

Lecture 155 - Replacing while with for : Example 2

Lecture 156 - Searching in a sorted list

Lecture 157 - Implementing binary search

Lecture 158 - The num_unique function

Lecture 159 - Incorrect implementations of num_unique

Lecture 160 - A correct implementation of num_unique

Lecture 161 - Visualizing num_unique

Lecture 162 - An important case (nobreak with no iterations)

Lecture 163 - Pattern 3: All pairs

Lecture 164 - Example (Pattern 3): max_profit

Lecture 165 - Refuting the buggy function

Lecture 166 - Representing tabular data

Lecture 167 - Basic dict operations

Lecture 168 - Example: substring_count

Lecture 169 - Clarifying the task

Lecture 170 - Reviewing ChatGPT's solution

Lecture 171 - Test Driven Development

Lecture 172 - Writing doctests for is_prime

Lecture 173 - Summary

Lecture 174 - Clarifying the task: count_between

Lecture 175 - Understanding the interpretation of 'between'

Lecture 176 - Are ChatGPT suggestions 'good' ?

Lecture 177 - Generating the code after clarifying (using ChatGPT)

Lecture 178 - Additional ChatGPT inputs

Lecture 179 - Revised code after additional clarifications

Lecture 180 - Learning a new programming language

Lecture 181 - Python vs C: Similarities and differences

Lecture 182 - Python: Example 1

Lecture 183 - Translating Example 1 to C

Lecture 184 - Key syntactic differences: Python vs C

Lecture 185 - Visualizing Python and C code

Lecture 186 - C programming style

Lecture 187 - Python: Example 2

Lecture 188 - Example 2, Attempt 2

Lecture 189 - Semantics of integer division

Lecture 190 - Example 2, Attempt 3

Lecture 191 - Summary

Lecture 192 - Example 1 (is_upper)

Lecture 193 - Visualizing the incorrect is_upper function

Lecture 194 - Correcting the error

Lecture 195 - Basics of strings in C

Lecture 196 - Strings in C (char [])

Lecture 197 - Strings in C (char *)

Lecture 198 - Mutable and immutable strings

Lecture 199 - Example 2 (to_ind_lower)

Lecture 200 - Visualizing the modified to_ind_lower function

Lecture 201 - Our friend's translation

Lecture 202 - Visualizing our friend's translation

Lecture 203 - Preventing accidental mutation

Lecture 204 - Copying a string (Attempt 1)

Lecture 205 - Copying a string (Attempt 2)

Lecture 206 - Fixing one error, revealing another

Lecture 207 - Allocating memory on the heap

Lecture 208 - Visualizing the revised version (with malloc)

Lecture 209 - Summary

Lecture 210 - Algorithm-centric improvements (to_ind_lower)

Lecture 211 - Data-centric improvements (to_ind_lower)

Lecture 212 - Processing textual data: C or Python

Lecture 213 - Understanding (simplified) Python lists

Lecture 214 - A simple implementation of Python lists - Part 1

Lecture 215 - A simple implementation of Python lists - Part 2

Lecture 216 - A simple implementation of Python lists - Part 3

Lecture 217 - A simple implementation of Python lists - Part 4

Lecture 218 - Testing the list implementation

Lecture 219 - Summary