Jackie's Lectures
Jackie's Lectures
|
|
|||||
| # | Date | Section B | Section E | Study Materials (both sections) | |
| 1 | WED, Sep 9 |
• Syllabus, Open Letter • Professional Engineers: Code of Ethics • Foundations Matter in the Age of AI • OOP Review Exercise |
|
||
|
|
||||
| 2 | MON, Sep 14 |
• Software Development Process • Separation of Concerns: Model vs. Tests • OO: Observe-Model-Execute Process |
|
||
|
|
|
||||
| 3 | WED, Sep 16 |
• Java Data Types: Primitive vs. Reference • Parameters vs. Arguments • Variable Scopes |
|||
|
|
|
||||
| 4 | MON, Sep 21 |
• Variable Shadowing, Use of • Use of Methods: Accessors vs. Mutators • Value Copying: Primitive vs. Reference • Exercise: Reference Aliasing and Arrays |
|||
|
|
|
||||
| 5 | WED, Sep 23 |
• Copying Arrays • Use of Static vs. Non-Static Variables • Managing Account IDs: Manual vs. Automatic |
|||
|
|
|
||||
| 6 | MON, Sep 28 |
• Common Errors of Static Variables • Marriage Example: Use of • Caller vs. Callee |
|||
|
|
|
||||
| 7 | WED, Sep 30 |
• Tracing Chain of Method Calls via a Stack • Catch-or-Specify Requirement • To Handle or Not to Handle: Version 1 |
|
||
|
|
|
||||
| 8 | MON, Oct 5 |
• Execution Flows: Normal vs. Abnormal • Examples: Bank, Account • Examples: Multiple Catch Blocks |
|||
|
|
|
||||
| 9 | WED, Oct 7 |
• Design a JUnit Test • Example Test 1: VTLE Not Expected • Example Test 2: VTSE Expected |
|||
|
|
|
||||
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
| 1 | THU, Sep 10 |
• Syllabus, Open Letter, CLOs • Foundations Matter in the Age of AI • Formal Verification is Relevant |
|
|
|
| 2 | TUE, Sep 15 |
• FMs: Theorem Proving vs. Model Checking • Propositions: Commutativity vs. Short-Circuit Evaluation • Implications: Contracts, Theorems • Predicates: Universal vs. Existential Quantifiers |
|
|
|
| 3 | THU, Sep 17 |
• Implication: Alternative Expressions in English • Logical Quantifiers: Proof Strategies • Sets: Enumerations vs. Comprehensions |
|
|
|
| 4 | TUE, Sep 22 |
• Logical Quantifiers: Disproof Strategies • Converting ∀ and ∃: Equational Proofs • Sets: Enumeration vs. Comprehension • Understanding the Choose Operator |
|
|
|
| 5 | THU, Sep 24 |
• Power Sets • Constructing All Relations |
|
|
|
| 6 | TUE, Sep 29 |
• Domain, Range, Inverse • Image, Restrictions, Subtractions • Relational Overriding • Functional Property |
|
|
|
| 7 | THU, Oct 1 |
• Partial Functions vs. Total Functions • Rel Image vs. Func Application |
|
|
|
| 8 | TUE, Oct 6 |
• Rel Image vs. Func Application • Modelling: Rel vs. Partial vs. Total Func • Injection, Surjection, Bijection |
|
|
|
| 9 | THU, Oct 8 |
• Modelling Decision: Formulating Arrays • Correct by Construction • State Space of a Model • M0: Abstraction, Context, Machine |
|
|
|
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
| 1 | THU, Sep 10 |
• Syllabus, Open Letter • Course Learning Outcomes |
|
|
|
| 2 | TUE, Sep 15 |
• Semantic Domain • What is a Compiler? • Inferring Dynamic Behaviour • Modularity, Information Hiding |
|
|
|
| 3 | THU, Sep 17 |
• Intermediate Representations (IRs) |
|
|
|
| 4 | TUE, Sep 22 |
• Stages: Lexical, Syntactical, Semantic Analyses • Routines: Scanning vs. Parsing • Example Compiler: Program Optimizer |
|
|
|
| 5 | THU, Sep 24 |
• Assignment 1 • Alphabets and Strings • Formulating Strings |
|
|
|
| 6 | TUE, Sep 29 |
• Formulating Language, Problem • Specifying Regular Languages: RE, DFA, NFA |
|
|
|
| 7 | THU, Oct 1 |
• NFA Behaviour • epsilon-NFA: Motivation, Processing Strings • Converting Regular Expression to epsilon-NFA |
|
|
|
| 8 | TUE, Oct 6 |
• Converting epsilon-NFA to DFA • Motivating Problems: Recursive Systems • Static Types, Polymorphic Assignments • Composite Pattern: Attempts • Composite Pattern: Uniform Access |
|
|
|
| 9 | THU, Oct 8 |
• Tracing Composite • Visitor: Design Rationales • Visitor: Tracing Double Dispatch |
|
|
|
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlist of All Lecture Recordings
|
|||||
| 1 | TUE, May 5 |
• Syllabus, Open Letter • Professional Engineers: Code of Ethics • Software Development: Compile Time vs. Run Time • OOP Review Exercise |
|
|
|
| 2 | THU, May 7 |
• Separation of Concerns: Model vs. Tests • OO: Observe-Model-Execute Process • Java Data Types: Primitive vs. Reference |
|
|
|
| 3 | TUE, May 12 |
• Parameters vs. Arguments • Variable Scopes • Variable Shadowing, Use of • Use of Methods: Accessors vs. Mutators |
|
|
|
| 4 | THU, May 14 |
• Value Copying: Primitive vs. Reference • Exercise: Reference Aliasing & Arrays • Exercise: Copying Arrays |
|
|
|
| 5 | TUE, May 19 |
• Marriage Example: Use of • Use of Static vs. Non-Static Variables • Managing Account IDs: Manual vs. Automatic |
|
|
|
| 6 | THU, May 21 |
• Common Errors of Static Variables • Caller vs. Callee • Tracing Chain of Method Calls via a Stack |
|
|
|
| 7 | TUE, May 26 |
• Catch-or-Specify Requirement • To Handle or Not to Handle: V1, V2, V3 |
|
|
|
| 8 | THU, May 28 |
• Execution Flows: Normal vs. Abnormal • Examples: Bank, Account • Examples: Multiple Catch Blocks |
|
|
|
| 9 | TUE, Jun 2 |
• Generalizing Call Stack and Exception Handling • Test 1: VTLE Not Expected |
|
|
|
| 10 | THU, Jun 4 |
• Test 2: VTSE Expected • Test 3: Some Exceptions Expected, Some Not • Console Tester vs. JUnit Test • Using a Loop for Testing Many Values |
|
|
|
| 11 | TUE, Jun 9 |
• Regression Testing • Call by Value: Primitive vs. Reference • Equality: |
|
|
|
| 12 | THU, Jun 11 |
• Default • Version of • Implementing • Short-Circuit Evaluation |
|
|
|
| 13 | TUE, Jun 23 |
• Static vs. Dynamic Types, Type Casting • Implementing |
|
|
|
| 14 | THU, Jun 25 |
• Implementing • JUnit: |
|
|
|
| 15 | TUE, Jun 30 |
• Equality Property via Implication • • Design: Cohesion, Single-Choice Principle • SMS: Design Attempts 1 |
|
|
|
| 16 | THU, Jul 2 |
• SMS: Design Attempts 2, 3 • Modifiers in Java |
|
|
|
| 17 | TUE, Jul 7 |
• Static Types and Expectations • Polymorphism and Dynamic Binding: Intuition |
|
|
|
| 18 | THU, Jul 9 |
• Ancestors, Descendants, Expectations • Rules of Substitutions • Change of Dynamic Types • Polymorphism vs. Dynamic Binding • Type Casting: Motivation, Syntax |
|
|
|
| 19 | TUE, Jul 14 |
• Type Casts: Named vs. Anonymous • Compilable Casts: Upward vs. Downward • Casts at Runtime: |
|
|
|
| 20 | THU, Jul 16 |
• • • Call by Value and Inheritance |
|
|
|
| 21 | TUE, Jul 21 |
• Call by Value and Inheritance • Casting Method Arguments • Polymorphic Arrays and Return Types |
|
|
|
| 22 | THU, July 23 |
• Recursion Resources • Recursion: Base vs. Recursive Cases • Tracing Recursion: Stack vs. Tree • Examples: fac, fib |
|
|
|
| 23 | TUE, July 28 |
• Recursion on Strings: • Recursion on Arrays: Creating Sub-Arrays • Recursion on Arrays: Call by Value |
|
|
|
| 24 | THU, July 30 |
• Recursion on Arrays: • Assigned Exercises: Tower of Hanoi • Course Wrap-Up |
|
|
|
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlists of All Lecture Recordings
|
|||||
| 1 | TUE, May 5 |
• Syllabus, Open Letter • Professional Engineers: Code of Ethics • Sorting Algorithms: an Overview • Motivating Problem: Linear vs. Logarithmic Searching |
|
|
|
| 2 | THU, May 7 |
• Recursion: Resources • OOP Review: Call by Value • Problem on Recursion: |
|
|
|
| 3 | TUE, May 12 |
• • • |
|
|
|
| 4 | THU, May 14 |
• Limitations of Experiments • Primitive Operations (POs) • Counting Primitive Operations: |
|
|
|
| 5 | TUE, May 19 |
• From Absolute RT to Relative RT • Approximating RT Functions • Asymptotic Upper Bounds (Big-O): Definition • Proving A.U.B.: a Proven Strategy |
|
|
|
| 6 | THU, May 21 |
• Proving A.U.B.: Examples • Driving A.U.B. from Code: Examples • Tool: Size of an Interval |
|
|
|
| 7 | TUE, May 26 |
• Deriving U.B. from Code: More Examples • Tool: Sum of an Arithmetic Sequence • Big-O Properties |
|
|
|
| 8 | THU, May 28 |
• Inserting into an Array • Sorting Orders • Selection vs. Insertion Sorts • Mixing Insertion & Selection Sorts |
|
|
|
| 9 | TUE, Jun 2 |
• Insertion Sort: Running Time • Selection vs. Insertion Sorts: Exercises • SLL: Visual Intro and Operations |
|
|
|
| 10 | THU, Jun 4 |
• SLL in Java: • SLL in Java: Building a Chain of Nodes • SLL: List Constructions • SLL: |
|
|
|
| 11 | TUE, Jun 9 |
• SLL: • Trading Space for Time: • SLL: |
|
|
|
| 12 | THU, Jun 11 |
• SLL: • DLL: Visual Introduction • DLL in Java: • DLL: • RT Comparison: Arrays vs. SLLs |
|
|
|
| 13 | TUE, Jun 23 |
• Linear vs. Non-Linear Data Structures • Root, Ancestors, Descendants • Subtrees, Depth, Height |
|
|
|
| 14 | TUE, Jun 30 |
• Recursive Definitions of (Binary) Trees • Tress in Java: Construction, Depth • Tool: Sum of a Geometric Sequence |
|
|
|
| 15 | THU, Jul 2 |
• Binary Trees: Math Properties • Tree Traversals |
|
|
|
| 16 | TUE, Jul 7 |
• Bounding Number of Nodes vs. Height • Bounding Internal vs. External Nodes • Proper Binary Trees • Binary Search: Ideas, Java |
|
|
|
| 17 | THU, Jul 9 |
• Binary Search: Tracing, Running Time • MergeSort: Ideas, Java, Tracing |
|
|
|
| 18 | TUE, Jul 14 |
• MergeSort: Recurrence Relation • QuickSort: Ideas, Java, RT |
|
|
|
| 19 | TUE, Jul 21 |
• BST: Search Property • BST: Sorting Property • BST: Constructing BST Nodes |
|
|
|
| 20 | TUE, Jul 28 |
• BST Operations: Searching, Insertion • BST Searching: Running Time, Java • Hight Balance Property (HBP) |
|
|
|
| 21 | THU, Jul 30 |
• PQ: Intro, List Implementation • Heap: Structure, Relational Properties |
|
|
|
| Makeup Lecture (ProgTest1) |
• Abstract Data Types (ADTs), Interfaces • Stack ADT: Last In First Out (LIFO) • Array-Based Implementation of Stack |
|
|
||
| Makeup Lecture (WrittenTest) |
• Queue ADT: First In First Out (FIFO) • Array- vs. SLL-Based Imp. of Queue • Circular Arrays: Empty, Insertions |
|
|||
| Makeup Lecture (ProgTest2) |
|
||||
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlist of All Lecture Recordings
|
|||||
| 1 | TUE, May 5 |
• Syllabus, Open Letter • Professional Engineers: Code of Ethics • Review: Sorting Algorithms |
|
|
|
| 2 | THU, May 7 |
• Problems, Algorithms, Data Structures • From Absolute RT to Relative RT • Big-O: Formal Definitions |
|
|
|
| 3 | MON, May 11 |
• Big-O: Alternative Def. using Predicates • Theorem for Proving Asymptotic U.B. • Examples: Proving & Deriving Asymptotic U.B. |
|
|
|
| 4 | TUE, May 12 |
• Selection Sort vs. Insertion Sort • Deriving A.U.B. from Selection Sort • Properties of Big-O |
|
|
|
| 5 | TUE, May 19 |
• Linear vs. Non-Linear Data Structures • Tree Terminology: Depth vs. Height • BTs: Levels, Max Number of Nodes • BTs: Bounding |
|
|
|
| 6 | THU, May 21 |
• Tree Traversals • BSTs: Search and Sorting Properties • BSTs: Searching, Insertions |
|
|
|
| 7 | TUE, May 26 |
• Binary Search: BSTs vs. Sorted Array • Hight-Balance Property (HBP) • Fixing HBP after Insertion: L-Rotation |
|
|
|
| 8 | THU, May 28 |
• Basic Definitions: • Vertices, Edges, Directions, Degrees, Simple • Properties: Degree Sum, Number of Edges |
|
|
|
| 9 | TUE, Jun 2 |
• Mathematical Induction: Degree Sum • Paths, Cycles • Subgraphs |
|
|
|
| 10 | THU, Jun 4 |
• Spanning Subgraphs • Connected Subgraphs • Connected Components • Forest vs. Tree vs. Spanning Tree |
|
|
|
| 11 | TUE, Jun 9 |
• Proving vs. Disproving Graph Properties • DFS: Comparable to Pre-Order Traversal • DFS: Marking Edges, Tracing |
|
|
|
| 12 | THU, Jun 11 |
• DFS on Directed Graphs: Notations • DFS on Directed Graphs: Tracing |
|
|
|
| 13 | TUE, Jun 23 |
• DFS on Directed Graphs: Properties • Implementing Graphs: Edge List • Visualizing Edge List Strategy |
|
|
|
| 14 | THU, Jun 25 |
• Java Review: Testing for Exceptions • BFS: Marking Edges, Tracing • DFS vs. BFS: Time Complexities • DFS vs. BFS: CCs, STs, Back Edges |
|
|
|
| 15 | MON, Jun 29 |
• Java Review: Testing for Exceptions • BFS: Marking Edges, Tracing • DFS vs. BFS: Time Complexities • DFS vs. BFS: Connected Components |
|
|
|
| 16 | TUE, Jun 30 |
• Weighted Graphs • Dijkstra's S.P. Algorithm: Tracing |
|
|
|
| 17 | MON, Jul 6 |
• Contracts of Iterative Algo.: Visualization • Dijkstra's Algorithm: Pre- & Post-Cond., LI |
|
|
|
| 18 | TUE, Jul 7 |
• Priority Queue, Complete BTs • Heap: Structural vs. Relational Properties • Heap: Insertion vs. Deletion • Dijkstra's Algorithm: Time Complexity |
|
|
|
| 19 | TUE, Jul 14 |
• Directed Acyclic Graphs (DAGs): Intro • Topological Sort: Time Complexity • Topological Sort: Tracing |
|
|
|
| 20 | THU, Jul 16 |
• Topological Sort: Linearizing Updates • Kruskal's MST Algorithm: Tracing |
|
|
|
| 21 | TUE, Jul 21 |
• Topological Sort: BFS vs. DFS • Greedy Method: Dijkstra • Partition, Cluster, Cut |
|
|
|
| 22 | THU, Jul 23 |
• Partition, Cluster, Cut, Cut Property • Kruskal's Algorithm: Time Complexity • DFS vs. BFS: Back Edges, Cycles |
|
|
|
| 23 | MON, Jul 27 |
• Solving Problems Recursively • Fibonacci Problem: Recursive • Dynamic Programming: Definitions, Principles |
|
|
|
| 24 | TUE, Jul 28 |
• Fibonacci: Memoization vs. Tabulation • Factorial Problem: Recursive • Factorial: Memoization vs. Tabulation • Min Cost Climbing: Problem Specification |
|
|
|
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlists of All Lecture Recordings
|
|||||
| 1 | TUE, Jan 6 |
• Syllabus, Open Letter • Professional Engineers: Code of Ethics |
|
|
|
| 2 | TUE, Jan 8 |
• Motivating Problems: Searching, Compiler • Basic Recursion: Resources • Call by Value • |
|
|
|
| 3 | TUE, Jan 13 |
• • • |
|
|
|
| 4 | THU, Jan 15 |
• Limitations of Experiments • Primitive Operations (POs) • Counting Primitive Operations: |
|
|
|
| 5 | TUE, Jan 20 |
• Relative RT to Absolute RT • Highest vs. Lower Terms • Asymptotic Upper Bound (Big-O) |
|
|
|
| 6 | THU, Jan 22 |
• Proving Asymptotic Upper Bounds • Approximating A.U.B. from Algorithms |
|
|
|
| 7 | TUE, Jan 27 |
• Big-O Properties • Deriving U.B. from Code: More Examples • Inserting into an Array • Sorting Orders |
|
|
|
| 8 | THU, Jan 29 |
• Sel vs. Ins Sorts: Visualization • Sel vs. Ins Sorts: Asymptotic Upper Bounds • Sel vs. Ins Sorts: Java Implementations |
|
|
|
| 9 | TUE, Feb 3 |
• SLL: Visual Introduction • Visualizing SLL Operations: Ins vs. Del • SLLs in Java: List Constructions |
|
|
|
| 10 | THU, Feb 5 |
• SLLs: • Trading Space for Time: • SLLs: |
|
|
|
| 11 | TUE, Feb 10 |
• SLL: • SLLs vs. Arrays • DLLs: Introduction |
|
|
|
| 12 | THU, Feb 12 |
• DLL: Empty List, Relative Positioning • DLL: • Arrays vs. SLLs vs. DLLs |
|
|
|
| 13 | TUE, Feb 24 |
• Linear vs. Non-Linear Data Structures • Root, Ancestors, Descendants • Subtrees, Depth, Height |
|
|
|
| 14 | TUE, Mar 3 |
• Recursive Defs: General vs. Binary Trees • Implementing Generic General Trees • Tracing: Computing Depth Recursively |
|
|
|
| 15 | THU, Mar 5 |
• Geometric Sequence Sum • Binary Trees: Mathematical Properties • Complete BTs vs. Full BTs |
|
|
|
| 16 | TUE, Mar 10 |
• Mathematical Induction: Proper BTs • Tree Traversals: Pre-Order vs. Post-Order |
|
|
|
| 17 | THU, Mar 12 |
• Binary Search: Ideas • Binary Search: Implementation, Tracing • Binary Search: Time Complexity |
|
|
|
| 18 | TUE, Mar 17 |
• Merge Sort vs. Quick Sort: Ideas • Merge Sort vs. Quick Sort: Implementations • Merge Sort vs. Quick Sort: Time Complexities |
|
|
|
| 19 | TUE, Mar 24 |
• Binary Search Tree (BST): Search Property • Binary Search Tree (BST): Sorting Property • Implementing BST in Java |
|
|
|
| 20 | TUE, Mar 31 |
• BST Operations: Searching, Insertion • BST Searching: Running Time, Java • Height Balance Property |
|
|
|
| 21 | THU, Apr 2 |
• Priority Queue: Intro • Priority Queue: List-Based Implementations • Heap: Structural & Relational Properties • Heap: Insertion vs. Deletion |
|
|
|
| Makeup Lecture (ProgTest1) |
• Abstract Data Types (ADTs), Interfaces • Stack ADT: Last In First Out (LIFO) • Array-Based Implementation of Stack |
|
|
||
| Makeup Lecture (WrittenTest) |
• Queue ADT: First In First Out (FIFO) • Array- vs. SLL-Based Imp. of Queue • Circular Arrays: Empty, Insertions |
|
|||
| Makeup Lecture (ProgTest2) |
|
||||
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlist of All Lecture Recordings
|
|||||
| 1 | MON, Jan 5 |
• Syllabus, Open Letter |
|
|
|
| 2 | WED, Jan 6 |
• Professional Engineers: Code of Ethics • Motivating Problems • Problems, Algorithms, Data Structures • From Absolute RT to Relative RT |
|
|
|
| 3 | MON, Jan 12 |
Big-O: Formal Definitions Big-O: Alt. Def. using Predicates Theorem: Proving Asymptotic U.B. Examples: Proving Asymptotic U.B. |
|
|
|
| 4 | WED, Jan 14 |
• Properties of Big-O • Deriving Asymptotic U.B.: Triangular Sum |
|
|
|
| 5 | MON, Jan 19 |
• Asymptotic Analysis: Selection vs. Insertion Sorts • Linear vs. Non-Linear Data Structures • Tree Terminology: Depth vs. Height |
|
|
|
| 6 | WED, Jan 21 |
• BTs: Levels, Max Number of Nodes • BTs: Bounding n and h • BSTs: Search & Sorting Properties |
|
|
|
| 7 | MON, Jan 26 |
• RT Analysis: Binary Search on BSTs • BST Operations: Insertions, Deletions • Height Balance Property (HBP) • Restoring HBP after Insertion: L-Rotation |
|
|
|
| 8 | WED, Jan 28 |
• Basic Definitions: • Vertices, Edges, Directions, Degrees • Properties: Degrees, Number of Edges |
|
|
|
| 9 | MON, Feb 2 |
• Mathematical Induction: Degree Sums • Paths, Cycles, Subgraphs |
|
|
|
| 10 | WED, Feb 4 |
• Spanning vs. Connected Subgraphs • Connected Components • Forest vs. Tree vs. Spanning Tree |
|
|
|
| 11 | MON, Feb 9 |
• Proving vs. Disproving Graph Properties • DFS: Comparable to Pre-Order Traversal • DFS: Marking Edges, Tracing |
|
|
|
| 12 | WED, Feb 11 |
• DFS on Directed Graph: Notations • DFS on Directed Graph: Tracing |
|
|
|
| 13 | MON, Feb 23 |
• DFS on Directed Graphs: Properties • Implementing Graphs: Edge List |
|
|
|
| 14 | WED, Feb 25 |
• Visualizing Edge List Strategy • BFS: Marking Edges, Tracing • DFS vs. BFS: Time Complexities, CCs |
|
|
|
| 15 | MON, Mar 2 |
• DFS vs. BFS: Answering Graph Questions • Weighted Graphs |
|
|
|
| 16 | WED, Mar 4 |
• Dijkstra's Shortest Path Algorithm: Intuition • Dijkstra's Algorithm: Tracing |
|
|
|
| 17 | MON, Mar 9 |
• Contracts of Iterative Algorithm: Visualization • Dijkstra's Algorithm: Pre- and Post-Conditions • Dijkstra's Algorithm: Loop Invariant • Priority Queue, Complete BTs |
|
|
|
| 18 | WED, Mar 11 |
• Heap: Structural & Relational Properties • Heap: Insertion vs. Deletion • Dijkstra's Algorithm: Time Complexity |
|
|
|
| 19 | MON, Mar 16 |
• Directed Acyclic Graphs (DAGs): Intro • Topological Sort: Time Complexity • Topological Sort: Tracing |
|
|
|
| 20 | WED, Mar 18 |
• Topological Sort: Linearizing Transactional Updates • Topological Sort: BFS vs. DFS • Minimum Spanning Tree (MST) Problem, Greedy Method |
|
|
|
| 21 | MON, Mar 23 |
• Greedy Method: Revisiting Dijkstra's Algorithm • Kruskal's MST Algorithm: First Look • Kruskal's MST Algorithm: Tracing |
|
|
|
| 22 | MON, Mar 30 |
• Kruskal's Algorithm: Greedy Method • Partition, Cluster, Cut, Cut Property • Solving Problems Recursively |
|
|
|
| 23 | WED, Apr 1 |
• Fibonacci Problem: Recursive • Fibonacci: Memoization vs. Tabulation • Min Cost Climbing: Problem Specification |
|
|
|
|
|
|||||
| # | Date | Section B | Section G | Study Materials (both sections) | |
|
Playlists of All Lecture Recordings: Section B and Section G All iPad Notes: Section B and Section G
|
|||||
| 1 | WED/THU, Sep 3/4 |
• Syllabus • Professional Engineers: Code of Ethics • Software Development: Compile Time vs. Run Time |
|
||
|
|
|
||||
| 2 | MON/TUE, Sep 8/9 |
• Separation of Concerns: Model vs. Tests • Object Orientation: Observe, Model, Execute • Java Data Types: Primitive |
|
||
|
|
|
||||
| 3 | WED/THU, Sep 10/11 |
• Java Data Types: Reference • Parameters vs. Arguments • Variable Scopes • Tracing Object Creations (concrete version) |
|||
|
|
|
||||
| 4 | MON/TUE, Sep 15/16 |
• Tracing OOP: Object Creations and Method Calls • Variable Shadowing, Use of • Reference Aliasing |
|||
|
|
|
||||
| 5 | WED/THU, Sep 17/18 |
• Exercise: Reference Aliasing and Arrays • Manual Management of Account IDs • Use of Static vs. Non-Static Variables |
|||
|
|
|
||||
| 6 | MON/TUE, Sep 22/23 |
• Use and Misuse of Static Varaibles • Use of • Referene-Typed Return Values • Anonymous Objects |
|||
|
|
|
||||
| 7 | WED/THU, Sep 24/25 |
• Caller vs. Callee • Tracing Chain of Method Calls via a Stack • Catch-or-Specify Requirement • To Handle or Not to Handle: Version 1 |
|
||
|
|
|
||||
| 8 | MON/TUE, Sep 29/30 |
• To Handle or Not to Handle: Versions 2, 3 • Generalizing Exception Handling |
|||
|
|
|
||||
| 9 | WED/THU, Oct 1/2 |
• Execution Flows: Normal vs. Abnormal • Examples: Circle, Bank, ParseInt |
|||
|
|
|
||||
| 10 | MON/TUE, Oct 6/7 |
• Regression Testing • Example Test 1: • Example Test 2: |
|||
|
|
|
||||
| 11 | WED/THU, Oct 8/9 |
• Example Test 3: Some Exception Expected, Some Not • Console Tester vs. JUnit Test • Using a for-Loop in a Test Method • Call by Value: Principle, Circles |
|||
|
|
|
||||
| 12 | MON/TUE, Oct 20/21 |
• Call by Value: Primitive vs. Reference Types • Equality: == vs. • Default Version of |
|
||
|
|
|
||||
| 13 | WED/THU, Oct 22/23 |
• Call by Value: Array Indexing • Deciding the Version of equals Method • Short-Circuit Evaluation |
|||
|
|
|
||||
| 14 | MON/TUE, Oct 27/28 |
• Overridden • Static vs. Dynamic Types, Type Casting |
|||
|
|
|
||||
| 15 | WED/THU, Oct 29/30 |
• Overridden • Exercises: short-circuit, logical implication • JUnit: |
|||
|
|
|
||||
| 16 | MON/TUE, Nov 3/4 |
• Desing Principles: Cohesion, SCP • SMS: Design Attempt 1 • SMS: Design Attempt 2 • Implementing Inheritance in Java |
|
||
|
|
|
||||
| 17 | WED/THU, Nov 5/6 |
• Modifiers in Java • Static Types and Expectations • Intuitions: Polymorphism, Dynamic Binding |
|||
|
|
|
||||
| 18 | MON/TUE, Nov 10/11 |
• Ancestors, Descendants, Expectations • Rules of Substitutions • Polymorphism vs. Dynamic Binding |
|||
|
|
|
||||
| 19 | WED/THU, Nov 12/13 |
• Type Casts: Motivation, Syntax, Visual • Compilable Casts: Upward vs. Downward • Casts at Runtime: ClassCastException |
|||
|
|
|
||||
| 20 | MON/TUE, Nov 17/18 |
• • • Call by Value and Inheritance |
|||
|
|
|
||||
| 21 | WED/THU, Nov 19/20 |
• Casting Method Arguments • Polymorphic Arrays and Return Types • Recursion: Resources |
|||
|
|
|
||||
| 22 | MON/TUE, Nov 24/25 |
• Principles of Recursion: Base vs. Recursive Cases • Tracing Recursion: Stack vs. Tree • Examples: |
|
||
|
|
|
||||
| 23 | WED/THU, Nov 26/27 |
• Examples: reverseOf, occurrencesOf • Recursion on Arrays: Creating Sub-Arrays • Recursion on Arrays: Call by Value |
|||
|
|
|
||||
| 24 | WED/THU, Nov 26/27 |
• Examples: allPositive, isSorted • Course Wrap-Up • Assigned Readings: Tower of Honoi |
|||
|
|
|
||||
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlist of All Lecture Recordings
|
|||||
| 1 | WED, Sep 3 |
• Syllabus • Professional Engineers: Code of Ethics • Motivating Problems |
|
|
|
| 2 | MON, Sep 8 |
• Motivating Proboems • Design by Contracts (DbC) • Clients vs. Suppliers |
|
|
|
| 3 | WED, Sep 10 |
• DbC: Honouring the Contract • Modularity, ADTs • Asymptotic Upper Bound (Big-O) |
|
|
|
| 4 | MON, Sep 15 |
• Defining Big-O using Predicate Logic • Deriving Big-O: Triangular Sum • Dynamic Arrays: Constant Increments |
|
|
|
| 5 | WED, Sep 17 |
• Amortized RT: Constant Increments • Deriving Sum of Geometric Seq. • Height Balance Property |
|
|
|
| 6 | MON, Sep 22 |
• Implementing BST in Java • BST Operations: Search & Insert • Tree Rotation, In-Order Traversal |
|
|
|
| 7 | WED, Sep 24 |
• After Insertion: Left Rotation • After Insertion: Right-Left Rotations • BST Deletion: Cases 1 to 3 |
|
|
|
| 8 | MON, Sep 29 |
• Basic Definitions • Properties: Degrees, Number of Edges • Mathematical Induction on Vertices |
|
|
|
| 9 | WED, Oct 1 |
• Mathematical Induction: Degree Sum • Paths, Cycles, Reachability • (Spanning vs. Connected) Subgraphs |
|
|
|
| 10 | MON, Oct 6 |
• Forest vs. Tree vs. Spanning Tree • Graph Traversal: Depth-First Search (DFS) • DFS on a Tree vs. Pre-Order Traverlsal |
|
|
|
| 11 | WED, Oct 8 |
• Proof: Spanning Tree and |V| vs. |E| • Tracing DFS using a Stack • Graphs in Java: Edge List |
|
|
|
| 12 | MON, Oct 20 |
• Adapting DFS for Graph Questions • BFS: Marking Vertices and Edges • BFS: First Example on a Tree |
|
|
|
| 13 | WED, Oct 22 |
• Test 1 Review Q&A |
|
|
|
| 14 | MON, Nov 3 |
• Tracing BFS using a FIFO Queue • Back Edge (DFS) vs. Cross Edge (BFS) • Implementing Graphs: Adjacency Lists |
|
|
|
| 15 | WED, Nov 5 |
• Visualizing Adjacency Lists • Shortest Paths in Weighted Graphs • Dijkstra's Algorithm: Intro, Example 1 |
|
|
|
| 16 | MON, Nov 10 |
• Dijkstra's Algorithm: Tracing • Dijkstra's Algorithm: Pre- and Post-condition |
|
|
|
| 17 | WED, Nov 12 |
• Loop Invariant (LI): Execution Flow • Relating Exit Condition, LI, Postcondition • Dijkstra's Algorithm: LI, Assumption |
|
|
|
| 18 | MON, Nov 17 |
• Priority Queues ADT: Introduction • Heap: Structural Property • Heap: Relational Property |
|
|
|
| 19 | WED, Nov 19 |
• Heap Operations: Insertion vs. Deletion • Dijkstra's Algorithm: Time Complexity • Implementing Graphs: Adjacency Matrix |
|
|
|
| 20 | WED, Nov 26 |
• Directed Acyclic Graphs (DAGs) • Topological Ordering • Topological Sort: Time Complexity, Tracing • Topological Sort: Sequentializing Updates |
|
|
|
| 21 | MON, Dec 1 |
• Minimum Spanning Tree (MST) Problem • Greedy Method • Kruskal's Algorithm |
|
|
|
| 22 | WED, Dec 10 |
• Partition, Cluster, Cut • Cut Property for MST • Cut Property in Kruskal's Algorithm |
|
|
|
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlist of All Lecture Recordings
|
|||||
| 1 | THU, Sep 4 |
• Syllabus |
|
|
|
| 3 | THU, Sep 11 |
• Propositions: Commutativity vs. Short-Circuit Evaluation • Implications: Contracts, Theorems • Predicates: Universal vs. Existential Quantifiers |
|
|
|
| 4 | TUE, Sep 16 |
• Implication: Alternative Expressions in English • Logical Quantifiers: Proof Strategies • Sets: Enumerations vs. Comprehension |
|
|
|
| 5 | THU, Sep 18 |
• Converting ∀ and ∃: Equational Style of Proofs • Understanding the Choose Operator • Power Sets |
|
|
|
| 6 | TUE, Sep 23 |
• Constructing All Relations • Domain, Range, Inverse • Image, Restrictions, Subtractions |
|
|
|
| 7 | THU, Sep 25 |
• Relational Overriding • Functional Property • Partial Functions vs. Total Functions |
|
|
|
| 8 | TUE, Sep 30 |
• Rel Image vs. Func Application • Modelling: Rev vs. Partial vs. Total Func • Injection, Surjection, Bijection |
|
|
|
| 10 | TUE, Oct 7 |
• Modelling Decision: Formulating Arrays • Correct by Construction • State Space of a Model • M0: Abstraction, Context, Machine |
|
|
|
| 11 | THU, Oct 9 |
• Before-After Predicates • Sequents: Syntax and Semantics • Invariant Preservation: PO/VC as as Sequent |
|
|
|
| 12 | TUE, Oct 21 |
• Before-After Predicate & Invariant Preservation • Formal Model Components • WrittenTest1 Review Q&A |
|
|
|
| 13 | THU, Oct 23 |
• Proof Obligation Rule: Invariant Preservation • Inference Rule: Syntax and Semantics • Sequent Proofs via Inference Rules |
|
|
|
| 14 | TUE, Oct 28 |
• Justifying the • Interpreting Unprovable Sequents |
|
|
|
| 15 | THU, Oct 30 |
• Revising M0: Adding Event Guards • Initializing System, Establishing Invariant • Deadlock Freedom: Intuition, PO, 1st Attempt |
|
|
|
| 16 | TUE, Nov 4 |
• DLF: Alternative Unprovable Sequent • 1st Refinement: Abstraction • 1st Refinement: State Space |
|
|
|
| 17 | THU, Nov 6 |
• Concrete Guards: • Guard Strengthening: Intuition, PO |
|
|
|
| 18 | TUE, Nov 11 |
• Guard Strengthening: Review • INV Preservation: POs • INV Preservation: Commuting Diagram |
|
|
|
| 19 | THU, Nov 13 |
• New Events: • Simulation of New Events: • Livelock/Divergence: Example |
|
|
|
| 20 | TUE, Nov 18 |
• Invariant vs. Variant • Observing Patterns of Variant Values • POs of Variants: NAT vs. VAR |
|
|
|
| 21 | THU, Nov 20 |
• Relative Deadlock Freedom • 2nd Refinement: abstraction, superposition, invariant |
|
|
|
| 22 | TUE, Nov 25 |
• 2nd Refinement: Splitting Guards • 2nd Refinement: Unprovable Sequent for INV • Adding an Invariant |
|
|
|
| 23 | THU, Nov 27 |
• Adding Actions, Splitting Events • Preventing Livelock/Divergence • Proving Livelock/Divergence Freedom |
|
|
|
| 24 | TUE, Nov 28 |
• Safety-Critical vs. Mission-Critical • Professional Engineers: Code of Ethics • Verification vs. Validation |
|
|
|
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
| 1 | TUE, May 6 |
• Syllabus • Professional Engineers: Code of Ethics • OOP Review Question: Attribute Types |
|
|
|
| 2 | THU, May 8 |
• Separation of Concerns: • OO: Observe-Model-Execute Process • Java Data Types: Primitive vs. Reference |
|
|
|
| 3 | TUE, May 13 |
• • Parameters vs. Arguments • Scope of Variables • Constructors: Default vs. Customized • Variable Shadowing, Use of |
|
|
|
| 4 | THU, May 15 |
• Tracing OOP: Creations, Method Calls • Reference Aliasing • Anonymous Objects |
|
|
|
| 5 | TUE, May 20 |
• Tracing Arrays and Aliasing • Static Variables |
|
|
|
| 6 | THU, May 22 |
• Misuse of Static Variables • Reference-Typed Return Values • More Advanced Use of • Caller vs. Callee |
|
|
|
| 7 | TUE, May 27 |
• Tracing Chain of Method Calls via a Stack • Cath-or-Specify Requirement • To Handle or Not to Handle: Version 1 |
|
|
|
| 8 | THU, May 29 |
• Catch-or-Specify Req.: Execution Flows • Catch-or-Specify Req.: Call Stack • To Handle or Not to Handle: Version 2, 3 |
|
|
|
| 9 | TUE, June 3 |
• Example: Exceptions, Loops, Boolean Variable • Example: Converting Strings to Integers • Bounded Counter: Deriving Test Cases |
|
|
|
| 10 | THU, June 5 |
• JUnit Test Method vs. Method Under Test • TDD & Regression Testing • JUnit Test: An Exception Expected or Not |
|
|
|
| 11 | TUE, June 10 |
• Console Errors vs. • Two vs. Single • Patternizing Assertions using Loops • Call by Value |
|
|
|
| 12 | THU, June 12 |
• Use of ==: Primitive vs. Reference • • |
|
|
|
| 13 | TUE, June 24 |
• Static Type, Dynamic Type, Type Casting • • Short-Circuit Evaluation |
|
|
|
| 14 | THU, June 26 |
• Short Circuit Evaluation in • JUnit: |
|
|
|
| 15 | THU, July 3 |
• • Design: Cohesion, Single-Choice Principle • SMS: 1st Design Attempt |
|
|
|
| 16 | TUE, July 8 |
• SMS: 2nd Design Attempt • SMS: Use of Inheritance ( • Static Types, Expectations, Polymorphism |
|
|
|
| 17 | TUE, July 15 |
• Dynamic Binding: Intuition • Visbility: Classes, Attributes/Methods • Multo-Level Inheritance Hierarchy |
|
|
|
| 18 | THU, July 17 |
• Ancestors vs. Descendants • Rules of Substitutions • Polymorphism and Dynamic Binding |
|
|
|
| 19 | TUE, July 22 |
• Motivation of Type Cast • Compilable Casts • |
|
|
|
| 20 | THU, July 24 |
• • Safe Type Casts • Polymorphic Method Calls |
|
|
|
| 21 | TUE, July 29 |
• Polymorphic Arrays • Polymorphic Return Values • Dynamic Binding and |
|
|
|
| 22 | THU, July 31 |
• Solving Problems Recursively • Factorial & Fibonacci: Ideas, Java, Tracing • Recursion on Strings: Palindrome |
|
|
|
| 23 | TUE, August 5 |
• Recursion on Strings: Examples • Recursion on Arrays: Call by Value • Recursion on Arrays: Examples |
|
|
|
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
| 1 | TUE, May 6 |
• Syllabus & Administratives • Semantic Domain |
|
|
|
| 2 | THU, May 8 |
• What is a Compiler? • Inferring Dynamic Behaviour • Design Principles • Intermediate Representations (IRs) |
|
|
|
| 3 | TUE, May 13 |
• Front-End, Optimizer, Back-End • Lexical, Syntactical, Semantic Analyses • Scanning vs. Parsing |
|
|
|
| 4 | THU, May 15 |
• Example Compiler: Obj-Rel Bridge • Alphabets and Strings |
|
|
|
| 5 | TUE, May 20 |
• Formulating String, Language, Problem • Regular Language Ops: Union, Concat, Kleene Star |
|
|
|
| 6 | THU, May 22 |
• RE Operators: Formal Meanings, Precedence • Exercises: RE Constructions and Specification • DFA: Introduction |
|
|
|
| 7 | TUE, May 27 |
• DFA: Formulation • DFA δ: Recursive vs. Non-Recursive • NFA: Motivation |
|
|
|
| 8 | THU, May 29 |
• NFA: Processing Strings • NFA Formulation: δ & Language • NFA to DFA: Subset Construction (Lazy Evaluation) |
|
|
|
| 9 | TUE, June 3 |
• Subset construction: Algorithm • ε-NFA: Motivation, Example, δ Function • Regular Expression to ε-NFA |
|
|
|
| 10 | THU, June 5 |
• ε-NFA: Formulation, Processing • ε-NFA to DFA: Extended Subset Const. • Minimizing DFA: Introduction |
|
|
|
| 11 | TUE, June 10 |
• Formulation: Extended Subset Construction • Minimizing DFA |
|
|
|
| 12 | THU, June 12 |
• Regular Expression to Minimized DFA • Implementing a Scanner • Parser in Context • Context Free Grammar (CFG): Intro |
|
|
|
| 13 | TUE, June 24 |
• Project Specification • CFG Derivations: LMD vs. Parse Trees • Static Types, Polymorphic Assignments |
|
|
|
| 14 | THU, June 26 |
• Static vs. Dynamic Types, Dynamic Binding • Design Attempts for Recursive System • Composite Design Pattern |
|
|
|
| 15 | THU, July 3 |
• Tracing Composite • Visitor: Design Rationales • Visitor: Tracing Double Dispatch |
|
|
|
| 16 | TUE, July 8 |
• Comparing Two Versions of CFGs • Witness String of CFG Ambiguity • RE to CFG, DFA to CFG |
|
|
|
| 17 | THU, July 10 |
• CFG: Formal Definition, Case Study (V3) • CFG Derivations: LMD vs. RMD • Ambiguity of CFG |
|
|
|
| 18 | TUE, July 22 |
• Discovering Derivations: Top-Down vs. Bottom-Up • Top-Down Parsing (TDP) Algorithm: Left-Recursive Grammar • TDP Algorithm: Tracing Exercise |
|
|
|
| 19 | TUE, July 29 |
• Removing Left Recursions: Algorithm • Tracing: Removing Direct LRs |
|
|
|
| 20 | THU, July 31 |
• Removing LRs: Indirect LRs • Building AST Recursively: Variable Args • |
|
|
21 | TUE, August 5 |
• Backtrack-Free Parsing: Motivation • • Recursive-Descent, LL(1) Parsers |
|
|
22-24 | Makeup & Exam Lecture |
• Bottom-Up Parsing (BUP) |
|
|
|
|
|||||
| # | Date | Section X | Section Z | Study Materials (both sections) | |
|
Playlists of All Lecture Recordings: Section X and Section Z All iPad Notes: Section X and Section Z
|
|||||
| 1 | TUE, Jan 7 |
• Course Syllabus • Data Structures, Algorithms, Analysis • Profession Engineering: Code of Ethics |
|
||
|
|
|
||||
| 2 | THU, Jan 9 |
• Data Structures: Motivating Problems • References to Recursion Bascis • Advanced Recursion Example: |
|||
|
|
|
||||
| 3 | TUE, Jan 14 |
• • • |
|||
|
|
|
||||
| 4 | THU, Jan 16 |
• Limitations of Experiments • Primitive Operations (POs) • Counting Primitive Operations: |
|
||
|
|
|
||||
| 5 | TUE, Jan 21 |
• From Absolute RT to Relative RT • Approximating RT Functions • Asymptotic Upper Bound (Big-O): Formal Definition |
|||
|
|
|
||||
| 6 | THU, Jan 23 |
• Big-O: Predicate Definition, Properties, Examples • Correct vs. Accurate Asymptotic Upper Bounds • Deriving U.B. from Code: Basic Examples (Sec. Z) |
|||
|
|
|
||||
| 7 | TUE, Jan 28 |
• Deriving U.B. from Code: More Advanced Examples • Inserting into an Array • Sorting Orders |
|
||
|
|
|
||||
| 8 | THU, Jan 30 |
• Sorting Orders and Exercise • Selection Sort vs. Insertion Sort |
|||
|
|
|
||||
| 9 | TUE, Feb 4 |
• Exercise: Mixing Insertion & Selection Sorts • SLL: Visual Introduction and Operations • SLL in Java: |
|||
|
|
|
||||
| 10 | THU, Feb 6 |
• SLL: List Constructions • SLL: • Trading Space for Time: |
|||
|
|
|
||||
| 11 | TUE, Feb 11 |
• SLL: • SLL: |
|||
|
|
|
||||
| 12 | THU, Feb 13 |
• SLL vs. Arrays • DLLs: Extensions • DLLs: |
|||
|
|
|
||||
| 13 | TUE, Feb 25 |
• Linear vs. Non-Linear Data Structures • General Trees: Terminology |
|
||
|
|
|
||||
| 14 | TUE, Mar 4 |
• Recursive Definitions: General vs. Binary Trees • Initializing a Generic Array • Trees in Java: Constructions, Depth, Tracing |
|||
|
|
|
||||
| 15 | THU, Mar 6 |
• Binary Trees: Math Properties • Tree Traversals |
|||
|
|
|
||||
| 16 | TUE, Mar 11 |
• Bounding Internal vs. External Nodes • Proper Binary Trees • Binary Search: Idea, Java |
|||
|
|
|
||||
| 17 | TUE, Mar 18 |
• Binary Search: Tracing, Recurrence Relation • MergeSort: Ideas, Java, Tracing |
|||
|
|
|
||||
| 18 | THU, Mar 20 |
• MergeSort: Recurrence Relation • QuickSort: Ideas, Java, RT |
|||
|
|
|
||||
| 19 | TUE/THU, Mar 25/27 |
• BST: Search Property • BST: Sorting Property • BST in Java: BSTNode Construction |
|||
|
|
|
||||
| 20 | TUE, Apr 1 |
• BST: Searching, Insertions • Height Balance Property • Priority Queues: Introduction |
|||
|
|
|
||||
| 21 | THU, Apr 3 |
• Priority Queues: List Implementations • Heaps: Structural, Relational Properties • Heaps: Insertions, Deletions • Heap Sort |
|||
|
|
|
||||
| Makeup Lecture (ProgTest1) |
• Abstract Data Types (ADTs), Interfaces • Stack ADT: Last In First Out (LIFO) • Array-Based Implementation of Stack |
|
|||
|
|
|||||
| Makeup Lecture (WrittenTest) |
• Queue ADT: First In First Out (FIFO) • Array- vs. SLL-Based Imp. of Queue • Circular Arrays: Empty, Insertions |
||||
|
|
|||||
| Makeup Lecture (ProgTest2) | |||||
|
|
|||||
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
|
|||||
| 1 | MON, Jan 6 |
• Syllabus • Safety-Critical Systems: Examples |
|
|
|
| 2 | WED, Jan 8 |
• Lab1 Guidance • Verification vs. Validation • Safety- vs. Mission-Critical |
|
|
|
| 3 | MON, Jan 13 |
• Software Development Process, Assurance Cases • Correct by Construction, State Space • Counter Problem: Theorem Proving (model) |
|
|
|
| 4 | WED, Jan 15 |
• Counter Problem: Theorem Proving (POs, proofs) • Reachability Graph • Commutativity vs. Short-Circuit Evaluation |
|
|
|
| 5 | MON, Jan 20 |
• Formulating the Model Checking Problem • Alternative Ways for Describing an Implication • Theorems: Propositional Logic |
|
|
|
| 6 | WED, Jan 22 |
• ∀ vs. ∃: Syntax, Meaning, Examples • ∀ vs. ∃: Proof Strategies • Switching between ∀ and ∃ |
|
|
|
| 7 | MON, Jan 27 |
• Finite Reachability Graph with Cycles • Atomic Updates with a Single Label • Algorithm Contracts: Precondition, Postcondition |
|
|
|
| 8 | WED, Jan 29 |
• Identifying (Non-)Atomicity in State Graph • Recall: System Variant (from EECS3342) • Encoding and Checking Variant in TLA+ |
|
|
|
| 9 | MON, Feb 3 |
• Implementation Correctness • Completeness of Contracts (Pre- vs. Post-condition) |
|
|
|
| 10 | WED, Feb 5 |
• Nested Quantification • Verification Methods: Proof- vs. Check-Based • State Graph vs. (Computation) Paths |
|
|
|
| 11 | MON, Feb 10 |
• Lab2 Solution Walkthrough • LTL Grammar: Top-Down Derivation |
|
|
|
| 12 | MON, Feb 24 |
• LTL Operator Precedence • Parse Trees, LMDs, RMDs |
|
|
|
| 13 | WED, Feb 26 |
• Subformula • Labeled Transition System (LTS) • Paths, Path Suffixes |
|
|
|
| 14 | MON, Mar 3 |
• Unfolding/Unwinding Paths • Satisfaction Relations: Path vs. Model • Formulations: X, G, F |
|
|
|
| 15 | WED, Mar 5 |
• Model Satisfaction • Path vs. Model Satisfactions: X, G, F |
|
|
|
| 16 | MON, Mar 10 |
• Nesting Temporal Operators: FGφ • Exercise: Gφ vs. FGφ |
|
|
|
| 17 | MON, Mar 17 |
• Parsing Property • Exercise: Fφ ⇒ FGφ • Nesting: GFφ |
|
|
|
| 18 | WED, Mar 19 |
• Exercise: Gφ vs. GFφ • Exercise: FGφ ⇒ GFφ |
|
|
|
| 19 | MON, Mar 24 |
• Temporal Operators: U, W, R • Formulating English Sentences in LTL |
|
|
|
| 20 | WED, Mar 26 |
• Exercises: U, W, R • Stronger vs. Weaker Assertions |
|
|
|
| 21 | MON, Mar 31 |
• Weakest Precondition: Predicate Transformer • wp rules: Assignments, Conditionals |
|
|
|
| 22 | WED, Apr 2 |
• wp Rule: Sequential Composition • Loop Invariant vs. Loop Variant • Correctness Conditions of Loops |
|
|
|
|
|
|||||
| # | Date | Section E | Section F | Study Materials (both sections) | |
|
Playlists of All Lecture Recordings: Section E and Section F All iPad Notes: Section E and Section F
|
|||||
| 1 | THU, Sep 5 |
• Syllabus • Professional Engineers: Code of Ethics • OOP Review Question: Attribute Types |
|
||
|
|
|
||||
| 2 | TUE, Sep 10 |
• OO: Observe-Model-Execute Proces • Java Data Types (Primitive vs. Reference) • NullPointerException • Parameters vs. Arguments • Scope of Variables |
|
||
|
|
|
||||
| 3 | THU, Sep 12 |
• Use of this for Attribute Access • Tracing OO Code • Use of Mutators vs. Accessors • Design of Method Parameters (Sec. F) • Reference Aliasing (Sec. F) |
|||
|
|
|
||||
| 4 | TUE, Sep 17 |
• Use of Mutators vs. Accessors (Section E) • Design of Method Parameters (Sec. E) • Arrays and Reference Aliasing • Reference-Typed Return Values (Sec. F) |
|||
|
|
|
||||
| 5 | TUE, Sep 17 |
• Reference-Typed Return Values (Sec. E) • Anonymous Objects • Use of this: Marriage Example • Static Variables (Sec. F) |
|||
|
|
|
||||
| 6 | TUE, Sep 24 |
• static vs. non-static variables (Sec. E) • Using Static Variables for Managing IDs • What if the `id` Variable is static? • What if the `numberOfAccounts` is static? • Referencing non-static variable in a static context • Caller vs. Callee • Tracing a Method Call Chain via a Stack |
|
||
|
|
|
||||
| 7 | THU, Sep 26 |
• Observations of a Call Stack • Exceptions: Disrupting Normal Execution Flow • What to Do When an Exception is Thrown • Demo: To Handle or Not to Handle (Version 1) |
|||
|
|
|
||||
| 8 | TUE, Oct 1 |
• Catch-or-Specify Req.: Exec. Flows vs. Call Stack • To Handle or Not to Handle - V2, V3 • Error Handling via Exceptions: Circles, Banks • Multiple catch blocks • Parsing Integers (Sec. F) • Console Messages vs. Exceptions (Sec. F) |
|||
|
|
|
||||
| 9 | TUE, Oct 1 |
• Parsing Integers (Sec. E) • Error Handling: Console vs. Exceptions (Sec. E) • Deriving Test Cases • JUnit Test Method vs. Method Under Test • Regressing Testing • JUnit Test: An Exception Not Expected |
|
||
|
|
|
||||
| 10 | TUE, Oct 8 |
• Exceptions Expected vs. Not Expected • Exercise: Console Errors vs. Assertion Errors • Exercise: Reducing the Number of try-catch Blocks • Using Loops in JUnit Tests • Default equals method in OBject Class (Sec. F) |
|||
|
|
|
||||
| 11 | THU, Oct 10 |
• equals Method: Default vs. Overridden • Overriding equals Method: Phases 1 - 3 • Static Type, Dynamic Type, Type Casting |
|||
|
|
|
||||
| 12 | TUE, Oct 22 |
• Overriding equals Method: Phase 4 • JUnit: assertSame vs. assertEquals • Short-Circuit Evaluation: && vs. || (Sec. F) |
|||
|
|
|
||||
| 13 | THU, Oct 24 |
• Applying Short-Circuit Evaluation to equals • equals: Person vs. PersonCollector |
|||
|
|
|
||||
| 14 | TUE, Oct 29 |
• equals: PersonCollector • Call by Value |
|
||
|
|
|
||||
| 15 | THU, Oct 31 |
• Modelling: Aggregation vs. Composition • Dot Notation Exercise • Copy Constructor, Shallow Copy |
|||
|
|
|
||||
| 16 | TUE, Nov 5 |
• Composition: Deep Copy • Design Attempts without Inheritance • Programming with Inheritance: Use of extends, super |
|
||
|
|
|
||||
| 17 | THU, Nov 7 |
• Implementing a Child Class: Principles • Visibility: Class, Attribute/Method • Static Types: Expectations • Polymorphism: Intuition |
|||
|
|
|
||||
| 18 | TUE, Nov 12 |
• Dynamic Binding: Intuition • Ancestors vs. Descendants, Expectations • Variable Substitutions |
|||
|
|
|
||||
| 19 | THU, Nov 14 |
• Polymorphism vs. Dynamic Binding • Type Casts: Named vs. Anonymous • Type Casts: Compilable vs. ClassCastException Free |
|||
|
|
|
||||
| 20 | TUE, Nov 19 |
• Type Casts: Exercise • instanceof operator • Polymorphic Method Parameters |
|||
|
|
|
||||
| 21 | THU, Nov 21 |
• Polymorphic Arrays • Polymorphic Return Values • Type-Checking Rules • Solving Problems Recursively |
|||
|
|
|
||||
| 22 | TUE, Nov 26 |
• Tracing: Factorial, Fibonacci Sequence • Recursion on Strings: Palindrome, Reversal • Exam Info |
|
||
|
|
|
||||
| 23 | THU, Nov 28 |
• Recursion on Strings: occurrencesOf • Recursion on Arrays: Call by Value • Recursion on Arrays: allPositive, isSorted |
|||
|
|
|
||||
| 24 | TUE, Dec 3 |
• Tower of Hanoi: Specification, Legend • Tower of Hanoi: Java, Tracing • Tower of Hanoi: Running Time • Course Wrap-Up |
|||
|
|
|
||||
| 25 | 3pm, FRI, Dec 6 |
• Console Tester vs. JUnit Test • Expectation: Ancestor vs. Descendent • Recursion: strDist • Polymorphism, Dynamic Binding, Type Casts |
|
||
strDist: Hint
 strDist: Solution
|
|||||
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlist of All Lecture Recordings
|
|||||
| 1 | THU, Sep 5 |
• Syllabus • Formal Methods: Theorem Proving vs. Model Checking |
|
|
|
| 2 | TUE, Sep 10 |
• Safety-Critical vs. Mission-Critical • Professional Engineers: Code of Ethics • Safety Property/Invariant • Verification vs. Validation |
|
|
|
| 3 | THU, Sep 12 |
• Model-Based Development • Propositional Logic • Implications: Contract Analogy • Implications: Alternative Expressions • Predicate Logic: Quantifiers |
Part 1: Part 2: |
|
|
| 4 | TUE, Sep 17 |
• Logical vs. Programming Operators • Empty Range vs. Empty Array • Proof Strategies of Quantifiers • Logical Quantifiers: Conversions |
|
|
|
| 5 | THU, Sep 19 |
• Set Comprehension • Relating Sets vs. Postconditions • Power Set: Cardinality • Power Set: Enumeration |
|
|
|
| 6 | TUE, Sep 24 |
• Incompleteness of Postcondition • Interpreting the choose operator • Cross Product • Relation |
|
|
|
| 7 | THU, Sep 26 |
• Constructing the Set of All Possible Relations • Domain, Range, Inverse • Relational Image • Domain/Range Restrictions/Subtractions • Relational Overriding: Formal Definition |
|
|
|
| 8 | TUE, Oct 1 |
• Algebraic Properties of Relational Ops. • Lab2: Celebrity_0 • Functional Properties |
|
|
|
| 9 | THU, Oct 3 |
• Partial Functions vs. Total Functions • Relational Image vs. Function Application • Well-Definedness of Function Application • Modelling Decision: Rel vs. Pfun vs. Tfun |
|
|
|
| 10 | TUE, Oct 8 |
• Injective Properties • Surjective Properties • Bijective Properties • Exercise: Injection vs. Surjection vs. Bijection |
|
|
|
| 11 | THU, Oct 10 |
• Modelling Decision on Formalizing Arrays • Correct by Construction • State Space of a Model • Bridge Controller: Requirements Document • Abstraction of the Initial Model • Showing Invariant Violation via Event Traces |
|
|
|
| 12 | TUE, Oct 22 |
• Event Action vs. Before-After Predicate • Invariant Preservation: Before- vs. After-States • Sequents: Syntax and Semantics |
|
|
|
| 13 | THU, Oct 24 |
• PO of Invariant Preservation: Sketch • PO of Invariant Preservation: Sequents • Inference Rules: Syntax and Semantics |
|
|
|
| 14 | TUE, Oct 29 |
• Inference Rules: Proof Steps • Interpreting Unprovable Sequents |
|
|
|
| 15 | THU, Oct 31 |
• Revising M0: Adding Event Guards • Re-Generating/Re-Proving PO Sequents |
|
|
|
| 16 | TUE, Nov 5 |
• Invariant Establishment • Deadlock Freedom |
|
|
|
| 17 | THU, Nov 7 |
• Interpreting Unprovable Sequent from DLF • First Refinement: Added Concreteness, State Space |
|
|
|
| 18 | TUE, Nov 12 |
• Abstract vs. Concrete Transitions • Stronger vs. Weaker Predicates • Guard Strengthening |
|
|
|
| 19 | THU, Nov 14 |
• Discharging Guard Strengthening POs • Invariant Preservation: Concrete Events • Commuting Diagram: Simulation • New Events: IL_in, IL_out |
|
|
|
| 20 | TUE, Nov 19 |
• skip event • Livelock, Divergence • Variant vs. Invariant |
|
|
|
| 21 | THU, Nov 21 |
• Proof Obligations of System Variant (Recording Failed. Please see three W'22 recordings.) |
|
|
|
| 22 | TUE, Nov 26 |
• Relative Deadlock Freedom • 2nd Refinement: Variables & Invariants • Exam Info |
|
|
|
| 23 | THU, Nov 28 |
• 2nd Refinement: Splitting Guards • Adding Invariant to Prove INV |
|
|
|
| 24 | TUE, Dec 3 |
• Adding Actions • Splitting Events • Preventing Livelock/Divergence • Proving Livelock/Divergence Freedom |
|
|
|
| 25 | 9am, FRI, Dec 13 |
• Sequent Proof Strategy • Applying NOT_L Inference Rule • Proving/Disproving System Variant • Impacting Deadlock Freedom Condition |
|
|
|
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlist of All Lecture Recordings
|
|||||
| 1 | MON, Jan 9 |
• Syllabus & Administratives • Using Data Strutures: Searching |
|
|
|
| 2 | WED, Jan 11 |
• Introduction: Searching and More • Recursion Basics: Resources, Call by Value |
|
|
|
| 3 | MON, Jan 16 |
• Tracing Recursion on an Array • Problems, Algorithms, Data Structures • Measuring Efficiency of an Algorithm • Measuring Running Time via an Experiment |
|
|
|
| 4 | WED, Jan 18 |
• Experimental Analysis: Pros and Cons • Counting Primitive Operations • Running Time: Absolute vs. Relative |
|
|
|
| 5 | MON, Jan 23 |
• Asymptotic Upper Bounds: Definitions • Guessing and Proving for Big-O • Visualizing Proofs of Big-O |
|
|
|
| 6 | WED, Jan 25 |
• Big-O: Justifying Proof Strategies, Properties • Big-O: More Examples • Big-O: Applications to Java Solutions |
|
|
|
| 7 | MON, Jan 30 |
• Deriving Big-O: Nested Loops • Deriving Big-O: Inserting into Arrays • Sorting Problem, Sorting Orders |
|
|
|
| 8 | WED, Feb 1 |
• Selection vs. Insertion Sort: Sketch • Deriving Big-O: Sketch vs. Code • Linked Lists: Introduction |
|
|
|
| WrittenTest1 Review | FRI, Feb 3 |
• Counting Primitive Operations • Approximating Running Time • Loop with LogN Iterations |
|
|
|
| 9 | WED, Feb 8 |
• Absolute Indexing vs. Relative Positioning • SLL in Java: • SLL in Java: List Construction, getSize, getTail |
|
|
|
| 10 | MON, Feb 13 |
• SLL operations: add/remove First/Last • SLL operations: accessing/inserting into Middle |
|
|
|
| 11 | WED, Feb 15 |
• SLL operations: insertBefore vs. insertAfter • Performance: Arrays vs. SLLs • Doubly-Linked Lists: Introduction, addBewteen |
|
|
|
| 12 (Makeup Lecture for WrittenTest1; ≈ 90 minutes) To be Completed by: March 20 (WrittenTest2) |
SUN, Feb 26 |
|
|
||
| 13 | MON, Feb 27 |
• Abstract Data Types (ADTs) • LIFO Stack • Stack Interface, ArrayStack, LinkedStack |
|
|
|
| 14 | WED, Mar 1 |
• Polymorphism vs. Dynamic Binding • Polymorphic Stack • Reversing, Matching, Postfix Notation • FIFO Queue • Queue Interface, ArrayQueue |
|
|
|
| 15 (Makeup Lecture for ProgTest1; ≈ 90 minutes) To be Completed by: March 20 (WrittenTest2) |
TUE, Mar 7 |
• Resources, Learning Outcomes • Binary Search: Implementation in Java • Binary Search: Tracing Recursions |
|
|
|
| 16 | WED, Mar 8 |
• Implementing a Queue via Two Stacks • Linear vs. Non-Linear Data Structures • General Trees: Terminology |
|
|
|
| 17 | MON, Mar 13 |
• Edge, Path, Depth, Height • Generic Trees in Java • Computing Depth and Height Recursively |
|
|
|
| 18 | WED, Mar 15 |
• Binary Trees (BTs) • Complete vs. Full vs. Proper BTs • Mathematical Properties of BTs |
|
|
|
| 19 (Makeup Lecture for WrittenTest2; ≈ 90 minutes) To be Completed by: Exam Day |
TUE, Mar 22 |
• MergeSort: Java Implementation • MergeSort: Tracing Recursive Calls • MergeSort RT - Recursion Tree • MergeSort RT - Recurrence Relation |
|
|
|
| 20 | WED, Mar 22 |
• Proper BTs, Mathematical Induction • Tree Traverals: Pre-Order, Post-Order, In-Order • Binary Search Trees (BSTs): Introduction |
|
|
|
| 21 | MON, Mar 27 |
• Binary Search Tree (BST) • BST: Search vs. Sorting Properties • BST: Generic Implementation in Java |
|
|
|
| 22 | WED, Mar 29 |
• BST: Searching • BST: Insertions • BST: Deletions (Cases 1 & 2) |
|
|
|
| 23 | WED, Apr 5 |
• BST: Deletions (Cases 3 & 4) • Height-Balance Property • Priority Queues, List-Based Implementation |
|
|
|
| 24 (Makeup Lecture for ProgTest2; ≈ 90 minutes) To be Completed by: Exam Day |
WED, Apr 5 |
• Heaps: Properties and Examples • Insertions and Up-Heap Bubbling |
|
||
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlist of All Lecture Recordings
|
|||||
| 1 | TUE, Jan 10 |
• Syllabus & Administratives • Introduction: SCS, Code of Ethics |
|
|
|
| 2 | THU, Jan 12 |
• Safety- vs. Mission-Critical • Industrial Standards • Building Right Product vs. Building Product Right • Model-Based Development |
|
|
|
| 3 | TUE, Jan 17 |
• Logical vs. Programming Operators • Implications: Alternative Expressions • Propositional Axioms and Theorems • Logical Quantifiers: Syntax |
|
|
|
| 4 | THU, Jan 19 |
• Logical Quantifications: Proof Strategies • Sets: Basic Operations, Power Sets |
|
|
|
| 5 | TUE, Jan 24 |
• Bi-Directional Subset Relations • Cardinality of Power Set • Constructing a Relation |
|
|
|
| 6 | TUR, Jan 26 |
• Relational Operations • Algebraic Properties of Relations • Functional Property |
|
|
|
| 7 | TUE, Jan 31 |
• Algebraic Properties of Relations • Functions: Partial vs. Total • Making Modelling Decisions |
|
|
|
| 8 | THU, Feb 2 |
• Injection vs. Surjection vs. Bijection • Modelling Decisions on Arrays • Lab1 Solution Highlights |
|
|
|
| 9 | TUE, Feb 7 |
• Correct by Construction • State Space: Axiom vs. Invariant • Bridge Controller: Requirements Doc. • Initial Model: State Space |
|
|
|
| 10 | THU, Feb 9 |
• Invariant: Establishment and Preservation • Finding Witness Traces for Invariant Violation • Before-After Predicates • Sequents: Syntax, Semantics, Sketching Invariant PO |
|
|
|
| 11 | TUE, Feb 14 |
• Invariant Preservation: Sequent • Inference Rules • Conducting Sequent Proofs |
|
|
|
| WrittenTest1 Review | WED, Feb 15 |
• Example Test Questions • Partial vs. Total Functions • Set Operations |
|
|
|
| 12 | TUE, Feb 28 |
• Proving Invariant Preservation • Fixing Model: Adding Guards • Deadlock Freedom |
|
|
|
| 13 | THU, Mar 2 |
• Iterative Process of Proving Model Correctness • Formulating Deadlock Freedom (DLF) PO • Proving Sequent Formulating DLF Rule |
|
|
|
| 14 | TUE, Mar 7 |
• 1st Refinement: Abstraction • 1st Refinement: State Space, Invariants • 1st Refinement: Events, Guards, Actions |
|
|
|
| 15 | TUE, Mar 14 |
• 1st Refinement: Guard Strengthening • Guard Strengthening: Intuition, Formulation, Proofs |
|
|
|
| 16 | THU, Mar 16 |
• 1st Refinement: Invariant Preservation • Relating Concrete and Abstract Transitions |
|
|
|
| 17 | TUE, Mar 21 |
• 1st Refinement: Concrete, New Events • Relating New Events to the |
|
|
|
| WrittenTest2 Review | WED, Mar 22 |
• Example Test Questions • |
|
|
|
| 18 | TUE, Mar 28 |
• 1st Refinement: New Events, Divergence/Livelock • System Variant (vs. Invariant), Proof Obligations |
|
|
|
| 19 | THU, Mar 30 |
• 1st Refinement: Relative Deadlock Freedom • 2nd Refinement: Abstraction • 2nd Refinement: State Space, Invariants |
|
|
|
| 20 | TUE, Apr 4 |
• 2nd Refinement: Abstract vs. Concrete Guards • 2nd Refinement: Example Inference Rules • 2nd Refinement: Invariant Preservation |
|
|
|
| Exam Review | THU, Apr 13 |
• Abstract vs. Concrete Transitions • Divergence/Livelock, Variants • Exam Info |
|
|
|
| Makeup Lectures for WT1, WT2, ProgTest1, ProgTest2 (≈ 2 hours) To be Covered in the Final Exam |
TUE, Apr 4 |
|
|||
| Makeup Lectures for WT1, WT2, ProgTest1, ProgTest2 (≈ 2.5 hours) To be Covered in the Final Exam |
TUE, Mar 7 |
|
|
||
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlist of All Lecture Recordings
|
|||||
| 1 | TUE, Jan 10 |
• Syllabus & Administratives • Theorem Proving vs. Model Checking |
|
|
|
| 2 | THU, Jan 12 |
• Safety- vs. Mission-Critical • Code of Ethics for Profession Engineers • Industrial Standards • Building Right Product vs. Building Product Right |
|
|
|
| 3 | TUE, Jan 17 |
• Catching Defects at the Design Phase • Model-Based Development: 3342 vs. 4315 • TLA+ Resources • Propositional vs. Programming Operators |
|
|
|
| 4 | THU, Jan 19 |
• Implications: Analogy, Alternative Expressions • Propositional Theorems • Logical Quantifications: Analogy, Exercises |
|
|
|
| 5 | TUE, Jan 24 |
• Proving/Disproving Logical Quantifiers • Using Model Checking to Solve Puzzles • Conversions between Quantifiers • Equational Style Proofs |
|
|
|
| 6 | THU, Jan 26 |
• Model Checking: Introduction • Linear-time Temporal Logic (LTL): Syntax • Operator Precedence, Symbols |
|
|
|
| 7 | TUE, Jan 31 |
• Practical Knowledge about Parsing • Drawing Parse Trees • Left-Most Derivations (LMD) |
|
|
|
| 8 | THU, Feb 2 |
• Parse Trees vs. LMDs vs. RMDs • Deriving Subformulas • (Optional) The Dangling Else Problem • Labelled Transition System (LTS) |
|
|
|
| 9 | TUE, Feb 7 |
• Examples: LTS Formulation • Paths, Unwinding Paths • Path Satisfaction: X, G, F |
|
|
|
| 10 | THU, Feb 9 |
• Path vs. Model Satisfactions • Proving vs. Disproving Strategies • Unary Temporal Operators: X, G, F |
|
|
|
| WrittenTest1 Review | SUN, Feb 12 |
• Proving vs. Disproving the Unary Temporal Operator (F, G) • Parsing LTL Formula Strings |
|
|
|
| 11 | TUE, Feb 28 |
• Model Satisfaction: Nested LTL Operators • FGϕ • Fϕ ⇒ FGϕ |
|
|
|
| 12 | THU, Mar 2 |
• Fϕ ⇒ FGϕ • Formulation, Proving vs. Disproving Strategies, Exercises • |
|
|
|
| 13 | TUE, Mar 14 |
• GFϕ • GFϕ ⇒ GFϕ • LTL Operators: Until, Weak Until, Release |
|
|
|
| 14 | THU, Mar 16 |
• Exercises: Model Satisfaction (U, W, R) • Exercises: Formulating Natural Language in LTL |
|
|
|
| WrittenTest2 Review | SUN, Mar 19 |
• Showing Postcondition being Inappropriate • Clarifying U vs. W vs. R Operators |
|
|
|
| 15 | TUE, Mar 28 |
• Stronger vs. Weaker Assertions • Relative, Partial vs. Total Correctness • Hoare Triple: Syntax and Interpretation |
|
|
|
| 16 | THU, Mar 30 |
• Hoare Triple: Predicate Transformer • Weakest Precondition (WP) • WP Rules: Assignments, Conditionals, Seq. Comp. |
|
|
|
| 17 | THU, Apr 6 |
• Contracts for Loops: Invariant vs. Variant • Proving Loop Correctness |
|
|
|
| Exam Review | WED, Apr 12 |
• ProgTest2 solution sketch • G(p U r) vs. p U r • Proving Maintenance of Loop Invariant |
|
|
|
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlist of All Lecture Recordings
|
|||||
| 1 | WED, Sep 7 |
• Syllabus & Administratives • Classes vs. Objects • Object Aliasing |
|
|
|
| 2 | MON, Sep 12 |
• Separation of Concerns: Model, Console, JUnit • OO: Observe-Model-Execute • Default Constructors: Implicit vs. Explicit • Object Creations: Low-Level Memory View • JUnit Assertions: assertTrue/False, assertNotSame/Same |
|
|
|
| 3 | WED, Sep 14 |
• Parameters vs. Arguments • Primitive Types vs. Reference Types • Variable Shadowing • Visualizing Objects • Instantiating `this` in Constructor • Instantiating `this` in Accessor • Variable Assignments: Primitive vs. Reference • Exercise (Arrays & Aliasing): Part 1 |
|
|
|
| 4 | MON, Sep 19 |
• Exercise (Arrays & Aliasing): Part 2 • Tracing Accessor vs. Mutator Calls • Use of Accessors vs. Mutators • Design of Method Parameters • Attribute/Parameter/Return Type Declarations • Anonymous Objects |
|
|
|
| 5 | WED, Sep 21 |
• More advanced use of `this` • Static Variables: Global Variables • Common Error: Static Counter |
|
|
|
| 6 | MON, Sep 26 |
• Using Non-Static Variable in a Static Context • Call Stack: Caller vs. Callee • Error Handling via Console: Circles & Banks • Practice Test 1 Question: Arrays & Aliasing |
|
|
|
| 7 | WED, Sep 28 |
• What is an Exception? • What to Do When an Exception is Thrown? • Catch-or-Specify Requirement • Example: To Handle or Not to Handle |
|
|
|
| 8 | MON, Oct 3 |
• Using Exceptions: Circles & Banks • Multiple Catch Blocks • More Advanced Example of Exceptions |
|
|
|
| 9 | WED, Oct 5 |
• Testing: Expected vs. Unexpected Exceptions • Nested try-catch Blocks • Console Testers vs. JUnit Tests |
|
|
|
| 10 | MON, Oct 17 |
• Consoler Testers vs. JUnit Tests • Regressing Testing and TDD |
|
|
|
| 11 | WED, Oct 19 |
• == Operator: Primitive vs. Reference • equals method from Object • PointV1: No Overriding • Overriding equals: 4 Phases |
|
|
|
| 12 | MON, Oct 24 |
• Overriding equals: Type Casting • JUnit Assertions for Equality • Short-Circuit Evaluation |
|
|
|
| 13 | WED, Oct 26 |
• Object Equality: Array-Typed Attributes • Call by Value |
|
|
|
| 14 | MON, Oct 31 |
• Call by Value: Primitive vs. Reference • Aggregations • WrittenTest2 Practice Questions |
|
|
|
| 15 | WED, Nov 2 |
• Dot Notation vs. Private Attributes • Compositions • Inheritance: SMS Problem |
|
|
|
| 16 | MON, Nov 7 |
• SMS: Two Design Attempts • SMS: Use of extends and super • Visibility: private vs. none vs. protected vs. public |
|
|
|
| 17 | WED, Nov 9 |
• Code Reuse, Static Types, Expectations • Intuition: Polymorphism • Intuition: Dynamic Binding • Multi-Level Inheritance |
|
|
|
| 18 | MON, Nov 14 |
• Rules of Substitutions • Static Types vs. Dynamic Types • Motivation of Type Casting |
|
|
|
| 19 | WED, Nov 16 |
• Anatomy of a Type Cast • Compilale Casts: Upwards vs. Downwards • Compilable Casts May Fail at Runtime |
|
|
|
| 20 | MON, Nov 21 |
• Type Casts: Compilable vs. Exception-Free • Checking Dynamic Types via instanceof • Polymorphic Method Parameters |
|
|
|
| 21 | WED, Nov 23 |
• Polymorphic Array • Polymorphic Return Types • Dynamic Binding of equals Method |
|
|
|
| 22 | MON, Nov 28 |
• Inheritance: Type Checking Rules • Recursion: Introduction • Examples: Factorial, Fibonacci, Palindrome |
|
|
|
| 23 | WED, Nov 30 |
• Recursion on Strings: Reverse • Recursion on Strings: Occurrences • Recursions on Arrays: Specifying Sub-Ranges |
|
||
| 24 | MON, Dec 5 |
• Recap of Recursion • Wrap-Up of the Course • Exam Info |
|
|
|
| 25 | THU, Dec 8 |
• Exam Review Q&A • Type Casts • Polymorphic Method Parameters • Short-Circuit Evaluation |
|
|
|
|
|
|||||
| # | Date | Topics | Recording | iPad Notes | Study Materials |
|
Playlist of All Lecture Recordings
|
|||||
| 1 | THU, Sep 8 |
• Syllabus & Administratives • Semantic Domain • Limitation of Eclipse Compiler (A+ challenge) |
|
|
|
| 2 | TUE, Sep 13 |
• Compiler Infrastructure • Intermediate Representation (IR) • Analysis: Lexical, Syntactic, Semantic • Example Optimizer |
|
|
|
| 3 | THU, Sep 15 |
• Example Object-to-Relational Compiler • Scanner in Context • Alphabets • Strings (Σk) |
|
|
|
| 4 | TUE, Sep 20 |
• Langauges, Problems • Regular Language Operations • Constructing Regular Expressions |
|
|
|
| 5 | THU, Sep 22 |
• Review Exercises: Strings & Languages • Exercises: RE Constructions & Specification • RE Operator Precedence • DFA: Basics • Review Exercise: Drawing DFA |
|
|
|
| 6 | TUE, Sep 27 |
• DFA Formulation • NFA: Non-Deterministic State Transitions |
|
|
|
| 7 | THU, Sep 29 |
• NFA: "Alternative Realities" • Subset Construction with Lazy Evaluation • epsilon-NFA: Motivating Examples |
|
|
|
| 8 | TUE, Oct 4 |
• ε-closures • Conversion: ε-NFA to DFA • Conversion: Regular Expressions to ε-NFA |
|
|
|
| 9 | THU, Oct 6 |
• Minimizing DFA • Implementing a Scanner • Context-Free Grammar: Terminology |
|
|
|
| 10 | TUE, Oct 18 |
• Comparing Two CFGs • Semantic Analysis • Finding Witnesses of Ambiguity |
|
|
|
| 11 | THU, Oct 20 |
• CFG: Formulation • RE/DFA to CFG • Ambiguity: Dangling else |
|
|
|
| 12 | TUE, Oct 25 |
• Derivations vs. Parse Trees • Dangling else Problem • Composite Pattern: Problem, Attempts |
|
|
|
| 13 | THU, Oct 27 |
• Composite Pattern: Architecture & Tests • Visitor Pattern: Problem, Architecture & Tests |
|
|
|
| 14 | TUE, Nov 1 |
• Visitor Pattern: Double Dispatch • Visitor Pattern: Open-Closed Principle • Visitor Pattern: Single-Choice Principle |
|
|
|
| 15 | THU, Nov 3 |
• Identifying Derivations • Top-Down Parsing Algorithm • Left- vs. Right-Recursive CFG |
|
|
|
| 16 | THU, Nov 10 |
• Removing Left Recursions from CFG • Removing epsilon-Productions • Backtrack-Free Parsing: Motivation |
|
|
|
| 17 | TUE, Nov 15 |
• Computing the FIRST Set: Algorithm |
|
|
|
| 18 | THU, Nov 17 |
• FOLLOW Set, START Set • Backtrack-Free Top-Down Parsing |
|
|
|
| 19 | TUE, Nov 22 |
• Left Factoring • LL(1) vs. LR(1) Parsers • Bottom-Up Parsing, Discovering RMDs |
|
|
|
| 20 | THU, Nov 24 |
• Bottom-Up Parsing: Shift vs. Reduce • Exercise: LL(1) Parser |
|
|
|
| 21 | TUE, Nov 29 |
• Bottom-Up Parsing: Handles • Bottom-Up Parsing: Right Most Derivations • LR(1) Items: Definition & Exercises |
|
|
|
| 22 | THU, Dec 1 |
• Canonical Collection ≈ Subset States • Computing closure • Computing goto |
|
|
|
| 23 | TUE, Dec 6 |
• Building CC and Transition Function • Building Action and Goto Tables • Shift-Reduce vs. Reduce-Reduce Conflicts |
|
|
|
| 24 | THU, Dec 8 |
• Exam Review Q&A • FOLLOW Set • epsilon-NFA to DFA |
|
|
|
| # | Date | Topics | Recording | iPad Notes | Source Code | Slides/Notes |
|
Playlist of All Lecture Recordings
|
||||||
| 1 | MON, Jan 6 |
• What is a Compiler? • Infrastructure of a compiler • Analysis: Lexical, Syntactic, Semantic |
|
|
• 01 Overview of Compilation [Jan 8] |
|
| 2 | WED, Jan 8 |
• Scanner vs. Parser • Example Compiler: Object-to-SQL |
|
|
||
| 3 | MON, Jan 13 |
• Alphabet, Strings, Language, Problem • Regular Expression • Deterministic Finite Automata (DFA) • Nondeterministic Finite Automata (NFA) |
|
|
||
| 4 | WED, Jan 15 |
• Formulating Language of DFA • epsilon-NFA • Subset Construction: NFA to DFA • Subset Construction: epsilon-NFA to DFA • Regular Expression to epsilon-NFA |
|
|
||
| 5 | MON, Jan 20 |
• Minimizing the State Space of DFA • Implementing DFA as Scanner (Table-Driven) |
|
|
||
| 6 | WED, Jan 22 |
• Context-Free Grammar (CFG) • Production, Derivation, Parse Trees, Ambiguity • Context-Free Language (CFL) |
|
|
PVS Demo: Specification File and Proof File (Thanks to Shangru) |
• 03 Syntactic Analysis [Mar 11] • 03 Syntactic Analysis (4-up) [Mar 11] • Project Problem: Compiler for Program Verification [Feb 24] • Exercise on Predictive, Top-Down Parser (Question ; Solution) [Feb 24] |
| 7 | MON, Jan 27 |
• Tracing Scanner's Implementation • Regular Expressions to CFGs • DFAs to CFGs • Leftmost Derivations vs. Rightmost Derivations • Ambiguity of CFG |
|
|
||
| 8 | WED, Jan 29 |
• Dangling else Problem • Top-Down Parsing • Left-Recursive CFG |
|
|
||
| 9 | MON, Feb 3 |
• Top-Down Parsing (Tracing) • Left Recursions: Direct vs. Indirect • Eliminating Left Recursions • Eliminating epsilon-Productions |
|
|
||
| 10 | WED, Feb 5 |
• Eliminating Left Recursions (Tracing) • Top-Down Parsing with One Symbol Lookahread • FIRST set for terminals and non-terminals • Backtrack-Free Grammar for Top-Down Parsing |
|
|
||
| 11 | MON, Feb 10 |
• Backtrack-Free Top-Down Parsing • FIRST Set Computations (Algorithm and Tracing) • FOLLOW Set Computations (Examples) |
|
|
||
| 12 | WED, Feb 12 |
• FOLLOW Set Computations (Algorithm and Tracing) • Backtrack-Free Grammar (First+ Sets, Formulation) |
|
|
||
| 13 | MON, Feb 13 |
• Project (Problem, Milestones, ANTLR Parser Generator) • Verification Paradigms: Model Checking vs. Theorem Proving vs. Constraint Solving • LL(1) Parser and Recursive-Descent Parser |
|
|
||
| 14 | MON, Feb 13 |
• Project: Example Verification Tool (PVS Proof Assistant) by Shangru Li • Bottom Up Parsing (BUP): Reverse Rightmost Derivation |
|
|
||
| 15 | WED, Mar 2 |
• Project: Verification Tool Example (PAT model checker) • Bottom Up Parsing (BUP): Table-Driven LR(1) Parser • Use of Action and Goto Tables • LR(1) Items for Potential Handles |
|
|
||
| 16 | MON, Mar 9 |
• LR(1) items: possibility, partial completion, completion • Canonical Collection (CC) of sets of LR(1) items • Constructing CC: the closure procedure • Constructing CC: the goto procedure |
|
|
||
| 17 | WED, Mar 11 |
• Constructing CC: the goto Procedure • Constructing CC: the Algorithm (Subset Construction) • Constructing the Action and Goto Tables • Discovering Ambiguities while Building a LR(1) Parser • Shift-Reduce Conflict vs. Reduce-Reduce Conflict |
|
|
||
| # | Date | Topics | Recording | iPad Notes | Source Code | Slides/Notes |
|
Playlist of All Lecture Recordings
|
||||||
| 1 | MON, Jan 6 |
• Client, Supplier, Contract • Design by Contract (DbC) • DbC in Java (Version 1) • Precondition vs. Exception |
|
|
• 01-Design by Contract [Jan 6] • 01-Design by Contract (4-up) [Jan 6] • Runtime Assertion Checking for Contracts - ACCOUNT Class • Runtime Assertion Checking for Contracts - General Case • 02.1 Eiffel Overview: Common Syntax • 02.1 Eiffel Overview: Common Syntax (4-up) • 02.2 Eiffel Overview: Common Errors • 02.2 Eiffel Overview: Common Errors (4-up) • 02.3 Drawing Design Diagrams in BON |
|
| 2 | WED, Jan 8 |
• DbC in Java (Version 2 to Version 5) • Class Invariant • Post-Condition |
|
|
||
| 3 | MON, Jan 13 |
• Basic Eiffel Syntax • Commands vs. Constructors • Runtime Monitoring of Contracts • Exercise: Precondition & Postcondition |
|
|
||
| 4 | WED, Jan 15 |
• Exercise: Postcondition & across • Why DbC Is Useful (V1 to V3) • Copying Objects: Reference vs. Shallow vs. Deep |
|
|
• Why DbC Is Useful (e.g., binary search) |
• 03 Writing Complete Postconditions • 03 Writing Complete Postconditions (4-up) • |
| 5 | MON, Jan 20 |
• Copying Arrays: Reference vs. Shallow vs. Deep • Checking Contracts at Runtime (caching old expressions) |
|
|
||
| 6 | WED, Jan 22 |
• caching old expressions • Bank Account Example (Versions 1 to 2) |
|
|
||
| 7 | MON, Jan 27 |
• Bank Account Example (Versions 3 to 5) • Writing Complete Postconditions for Stack (3 strategies of implementation) |
|
|
• Specifying a FIFO stack using the MATHMODELS library • Specifying a Birthday Book using the MATHMODELS library (and exercises) • Examples of Iterator Pattern (Starter) ; (Completed Version with Exercises) [In-Lab Demo, Feb 6] |
• Using Genericity, Iterator Pattern, Singleton Pattern [Feb 12] • Using Genericity, Iterator Pattern, Singleton Pattern (4-up) [Feb 12] • BON Design Diagram of Iterator Pattern • Exercise: Use of Generics in Iterator Pattern (Question; Hints; Solution) • |
| 8 | WED, Jan 29 |
• Using MATHMODELS to Implement Abstraction Functions • Using Abstraction Functions to Write Complete Postconditions • Information Hiding • Single-Choice Principle |
|
|
||
| 9 | MON, Feb 3 |
• Relational Overriding • Postcondition Exercise (all_pos_val) • BirthdayBook: Architecture (Client-Supplier Relations) |
|
|
||
| 10 | WED, Feb 5 |
• BirthdayBook: Specification (overriding, range restriction) • Use of Generics • Iterator Pattern: Problem and Architecture |
|
|
||
| 11 | MON, Feb 10 |
• Architecture of Iterator Pattern • Use of Iterator Pattern (Code to Interface) • Exercise: Generics and Iterator • Expanded Classes |
|
|
||
| 12 | WED, Feb 12 |
• Programming with Expanded Classes • Design Problem: Shared Data • First Design Attempt: Sharing via Inheritance • Design Principles: Cohesion and Single Choice • Programming with once routines |
|
|
||
| Labtest 1 Review | THU, Feb 13 |
• Making BIRTHDAY_BOOK class iterable • HASH_TABLE.new_cursor cannot be used directly • A new ITERATION_CURSOR class is needed |
|
|
• Making a Birthday Book (implemented using HASH_TABLE) ITERABLE |
• Practice Written Questions ; Solutions |
| 13 | MON, Feb 24 |
• Singleton Design Pattern (Design and Implementation) • Eiffel Testing Framework (Separating UI and Model, Acceptance Tests, Regression Testing) |
|
|
Setting Up Regression Testing Remotely on Prism |
• Eiffel Testing Framework (for Acceptance Testing) [Feb 24] |
| 14 | WED, Feb 26 |
• Student Management System Problem • Cohesion, Single Choice Principle, Collection of Students • Design 1: Two Unrelated Classes RESIDENT_STUDENT and NON_RESIDENT_STUDENT • Design 2: Single Class STUDENT with attribute kind • Design 3: Common Parent Class STUDENT and Two Child Classes |
|
|
• Bad Design without Inheritance |
• Student Management System: Problem, Static Type, Expectations [Feb 26] • Student Management System: 3 Designs [Feb 26] • Inheritance Hierarchy of Smartphone Classes [Mar 2] • Architecture for Testing Violation of Postcondition [Mar 2] |
| 15 | MON, Mar 2 |
• Student Management System Problem • Design 2.5: Single Class STUDENT with attribute kind and global arrays • Static Types, Expectations, Dynamic Types • Intuition: Polymorphism vs. Dynamic Binding |
|
|
||
| 16 | WED, Mar 4 |
• Multi-Level Inheritance Hierarchy • Polymorphism and Dynamic Binding • Casting: Motivation and Syntax |
|
|
||
| 17 | MON, Mar 9 |
• Type Casts: Upwards vs. Downwards • Cast Violation at Runtime • Polymorphic Feature Arguments • Polymorphic Return Values • State Design Pattern: Motivating Problem (Interactive Systems) |
|
|
||
| 18 | WED, Mar 11 |
• Motivating Problem: Interactive Systems • 1st Design: Labels and Goto Statements • 2nd Design: Non-OO, Top-Down Approach • 3rd Design: OO, State and Template Design Patterns • Polymorphic Collection of States, Dynamic Binding |
|
|
• State Design Pattern [Mar 9] |
|
| 19 | MON, Mar 16 |
• State Pattern: Client App, Polymorphism, Dynamic Binding • Motivation Problem: Computer Manufacture System • Multiple Inheritance: Windows and Renaming • Design 1: children feature declared in common ancestor of base and composite (violating the cohesion principle) |
|
|
• Tutorial: The Composite and Visitor Design Patterns • Using the ANTLR4 Parser Generator to Develop a Compiler (Practical Application of the Composite/Visitor Design Patterns in Java) ; iPad notes |
• Composite Design Pattern [Mar 16] • Composite Design Pattern (4-up) [Mar 16] • BON Diagram of Composite Design Pattern [Mar 16] • Multiple Instantiations of Composite Design Pattern [Mar 16] • Visitor Design Pattern [Mar 25] |
| 20 | WED, Mar 18 |
• Motivating Problem: Computer Manufacture System • Design 1: Violating Cohesion (children and add_child in EQUIPMENT) • Design 2: Satisfying Cohesion but Violating Single Choice (children and add_child in non-generic class COMPOSITE) • Design 3: Composite Design Pattern (children and add_child in generic class COMPOSITE[T]) • CDP: Multiple instantiations by reusing COMPOSITE[EQUIPMENT] and COMPOSITE[FURNITURE] • CDP: Mixing with Template Design Pattern • CDP: Tracing Runtime Behaviour |
|
|
||
| 21 | MON, Mar 23 |
• Composite Pattern: Constraining Self-Loops • Motivating Problem: Operations for an Expression Language • Design 1: Defining all operations in root of inheritance hierarchy • Design 1: Violation Single Choice Principle and Cohesion • Open/Closed Principle: open/closed struct/op. vs. closed/open struct./op • Visitor Pattern: Architecture and Test Case |
|
|
||
| 22 | WED, Mar 25 |
• Visitor Pattern: Double Dispatch • Visitor Pattern: Open/Closed Principle & Single Choice Principle • Visitor Pattern: Adding a new structure vs. Adding a new operation |
|
|
||
| 23 | FRI, Mar 27 |
• Motivating Problem: Weather Station • Design 1: Uni-Directional Link from App to Data • Design 2: Observer Pattern (OP) • OP: Architecture and Instantiation • OP: Bi-Directional Links at Runtime • OP: {SUBJECT}.notify vs. {OBSERVER}.update |
|
|
• Weather Station without the Observer Pattern • Weather Station with the Observer Pattern • Generalizing the Observer Pattern using Event-Driven Design in Java • Generalizing the Observer Pattern using Event-Driven Design in Eiffel |
• Observer Design Pattern and Event-Driven Design [Mar 27] • Observer Design Pattern and Event-Driven Design (4-up) [Mar 27] • First Design for Weather Station [Mar 25] • BON Design Diagram of Observer Pattern [Mar 25] • Applying the Observer Pattern to Weather Station [Mar 25] • Applying the Event-Driven Design to Weather Station [Mar 27] |
| 24 | MON, Mar 30 |
• Correctness is Relative (w.r.t. Specification) • Assertions: Precondition, Postcondition, Class Invariant • Correctness Predicate (Hoare Triple): {Q} S {R} • Weakest Precondition: wp(S, R) • Program Correctness: Q No Weaker than wp(S, R) • wp Calculation Rule: Variable Assignments |
|
|
||
| 25 | WED, Apr 1 |
• wp Calculation Rules: Conditionals & Sequential Composition • Contracts for Loops: Loop Invariants and Loop Variants • Runtime Monitoring of Loop Contracts • Correctness Conditions for Loops |
|
|
||
| # | Date | Topics | Recording | iPad Notes | Source Code | Slides/Notes |
|
Playlist of All Lecture Recordings
|
||||||
| 1 | WED, Sep 4 |
• OO: Observer, Model, Execute • Default vs. Customized Constructors • Default Values • Input Parameters vs. Actual Arguments • Breakpoints and Debugger in Eclipse |
|
|
• Counter (static vs. non-static attributes, and MyClass to illustrate a common error) [Sep 20] |
• 00-Administrative (4-up) [Sep 4] • 01-Classes and Objects [Sep 20] • 01-Classes and Objects-4up [Sep 20] • The Observe-Model-Execute Process [Sep 4] • Required Reading: Point, PointCollector, and PointCollectorTester [Sep 10] |
| 2 | MON, Sep 9 |
• Shadowing: Clashing Names of Parameter and Attribute • Constructor Using this Keyword • Visualizing Objects at Runtime • Aliasing |
|
|
||
| 3 | WED, Sep 11 |
• Alias paths • Tracing: object creation and (accessor and mutator) method calls • Programming Pattern: Array-Referenced Attributes and integer counter |
|
|
||
| 4 | MON, Sep 16 |
• Programming Pattern (Point[] points, int nop, void addPoint, Point[] getQ1Points) • Short-Circuit Evaluation • Anonymous Objects • Method Overloading • Static vs. Non-Static Variables |
|
|
||
| 5 | WED, Sep 18 |
• Use of static variables (for auto-generated id) • Misuse of static variables (for integer counter) • Common Error: Use of non-static variable in a static context • Error handling via console messages • Exceptions: Specify or Catch |
|
|
• Exceptions (Circle and Bank) [Sep 16] |
• 03-TDD-with-JUnit (4-up) [Sep 25] • Guide to Written Lab Test 1 [Sep 20] • Guide to Programming Lab Test 1 [Sep 20] • Expectation and Strategy for a Programming Lab Test (Starter Project here) |
| 6 | MON, Sep 23 |
• Where to Handle an Exception (3 Versions) • Normal Flow vs. Exceptional Flow of Execution • More Examples (Multiple Catch Blocks, Parsing Integers) • Testing for Normal vs. Abnormal Scenarios |
|
|
||
| 7 | WED, Sep 25 |
• Console vs. JUnit tests where some exception is expected • Console vs. JUnit tests where some exception is not expected • JUnit assertions (assertNull, assertEquals, assertTrue, assertFalse) |
|
|
||
| Written Test 1 Review | MON, Sep 30 |
• Anonymous Objects • Exception (catch-specify requirements) • Aliasing (single-referenced vs. array-referenced) |
|
|
||
| 8 | MON, Sep 30 |
• Default Version of the equals method in Object • Overridden Version of the equals method • JUnit assertions: assertSame vs. assertEquals |
|
|
• Overriding/Redefining the equals method [Sep 30] • Practice Starter Project [Oct 3] |
|
| 9 | WED, Oct 2 |
• Testing the equals method in JUnit • Defining the equals method in Persona and PersonCollector |
|
|
||
| Programming Test 1 Review | FRI, Oct 4 |
• Review of Programming Test Format • Reading JUnit test methods and assertions • Inferring classes, constructors, accessors, and mutators • Implementation Pattern: array attributes and loops |
|
|
||
| 10 | MON, Oct 7 |
• Overriding of compareTo method for Employee • Testing compareTo and Arrays.sort in JUnit • Map: Naive, Inefficient Implementation • Map: Hashing Keys and Bucket Arrays |
|
|
||
| 11 | WED, Oct 9 |
• Magic Card Challenge here • Examples on HashCode and HashTable • Call by Value (Primitive Type) |
|
|
||
| 12 | MON, Oct 21 |
• Call by Value (Primitive Type vs. Reference Type) • Java Collections API • Use of Generic Parameters • ArrayList vs. Hashtable • Solving a Problem Recursively |
|
|
• Call by Value (Primitive vs. Reference Types) [Oct 21] • Java Collections: ArrayList and Hashtable [Oct 21] • Recursion
|
• 05-Java-Collections.pdf [Oct 21] • 05-Java-Collections.pdf (4-up) [Oct 21] • 06-Recursion.pdf (4-up) [Dec 2] • Required Reading: Solving Problems Recursively |
| 13 | WED, Oct 23 |
• Recursive Solution Pattern • Common Error: Missing Base Cases • Common Error: Recursive Calls on Problems Not Strictly Smaller • Examples: Factorial, Fibonacci, isPalindrome, reverseOf, occurrencesOf |
|
|
||
| 14 | MON, Oct 28 |
• Recursive Calls on an Array • Call by Value, Range of Indices (in context of recursive calls) • allPositive, isSorted • Container vs. Containee |
|
|
||
| 15 | WED, Oct 30 |
• Aggregation vs. Composition • Use of Dot Notation to Navigate between Classes • Copy Constructor (Shallow Copy vs. Deep Copy) |
|
|
||
| 16 | MON, Nov 4 |
• Inheritance: Two Designs without Inheritance • Design Criteria: Cohesion and Single-Choice Principle • Inheritance: extends and super • Static Type: Exception • Polymorphic Assignment: Intuition |
|
|
• Student Management System (with and without inheritance) • Type Casts (Compilable vs. Non-Compilable and Exception-Free vs. ClassCastException) |
• 08-Inheritance (4-up) [Nov 13] • Inheritance Hierarchy of Smartphone Classes • Required Reading: Static Types, Dynamic Types, Type Casts • Guide to Programming Lab Test 2 [Nov 10] • Guide to Written Lab Test 2 [Nov 10] • Expectation and Strategy for a Programming Lab Test (Starter Project here) |
| 17 | WED, Nov 6 |
• Multi-Level Inheritance • Static Type: Expectation • Polymorphism and Dynamic Binding: Intuition • Rules of Substitution |
|
|
||
| 18 | MON, Nov 11 |
• Polymorphism and Dynamic Binding • Type Casts: Upward vs. Downward • ClassCastException |
|
|
||
| 19 | WED, Nov 13 |
• Compilable Type Casts: Upward vs. Downward • Compilable Type Casts but ClassCastException • instanceof operator • Static Type of Array Elements |
|
|
||
| 20 | FRI, Nov 15 |
• Polymorphic Method Arguments • Polymorphic Method Return Values • Dynamic Binding of Overridden Methods |
|
|
||
| Programming Test 2 Review | FRI, Nov 15 |
• Inferring super and sub classes from assignments • Aggregation vs. Composition • Copy Constructors (PersonCollector, Person) |
|
|
||
| 21 | FRI, Nov 22 |
• Abstract Classes (Polygon, Rectangle, Triangle) • Interfaces (Point, CartesianPoint, PolarPoint) |
|
|
||
| Written Test 2 Review 1 | FRI, Nov 22 |
• Inheritance (Type Casts, instanceof, ClassCastException) • Aggregation vs. Composition • Hashing |
|
|
• Review of Compilable vs. Non-Compilable Casts, ClassCastException |
|
| Written Test 2 Review 2 | MON, Nov 25 |
• Hasing (Efficiency, Bucket Array) • Call by Value (Primitive vs. Reference) • Inheritance (Type Casts, instanceof, ClassCastException) • Collection (Use of Generic Parameters) |
|
|
||
| 22 | MON, Nov 25 |
• Primitive Operations • Asymptotic Upper Bound (Big-O) • Tightest Asymptotic Upper Bound |
|
|
• Recursion
• Implementing and Testing Selection Sort and Insertion Sort |
• 10-Asymptotic Analysis of Algoritms [Nov 25] |
| 23 | WED, Nov 27 |
• Proving tightest Asymptotic Upper Bounds • Deriving Upper Bounds on Code • Selection Sort vs. Insertion Sort |
|
|
||
| 24 | MON, Dec 2 |
• Running Time of Inserting into an Array • Selection Sort vs. Insertion Sort in Java • Running Time of Recursive Methods: isAllPositive, binarySearch • Correctness of Recursive Methods: isAllPositive |
|
|
||
| Exam Review 1 | MON, Dec 9 |
• Merge Sort • Asymptotic Upper Bounds • Type Cast and ClassCastException • Correctness Proofs of Recursion |
|
|
||
| Exam Review 2 | TUE, Dec 10 |
• Deriving Asymptotic Upper Bounds • Javadocs • Unit Testing • Correctness Proofs of Recursion • Polymorphism and Dynamic Binding |
|
|
||
| Exam Review 3 | THU, Dec 12 |
• Unit Testing (Boundary Cases) • Deriving Asymptotic Upper Bounds • Recursive Methods (Fibonacci Sequence) • Polymorphism • Type Cast and instanceof checks |
|
|
||
| # | Date | Topics | Recording | iPad Notes | Source Code | Slides/Notes |
|
Playlist of All Lecture Recordings
|
||||||
| 1 | THU, Sep 5 |
• Client vs. Supplier • Contracts, Design by Contract |
|
|
• 00-Administrative (4-up) [Sep 5] • 01-Design by Contract [Sep 12] • 01-Design by Contract (4-up) [Sep 12] • Runtime Assertion Checking for Contracts - ACCOUNT Class • Runtime Assertion Checking for Contracts - General Case • Eiffel Overview: Common Syntax [Sep 10] • Eiffel Overview: Common Syntax (4-up) [Sep 10] • Eiffel Overview: Common Errors [Sep 10] • Eiffel Overview: Common Errors (4-up) [Sep 10] • Drawing Design Diagrams in BON [Sep 15] • All example BON diagrams (PDFs) from the slides [Sep 15] • Drawing Design Diagrams in BON (4-up) [Sep 15] • • |
|
| 2 | TUE, Sep 10 |
• Why DbC Is Useful in Guiding Development? (Binary Search Example) • DbC in Java: 5 Versions (Precondition, Class Invariant, Postcondition) |
|
|
||
| 3 | THU, Sep 12 |
• DbC: Eiffel vs. Java • Runtime Monitoring of Contracts • Postcondition of change_at • Reference vs. Shallow vs. Deep Copies |
|
|
• Writing Complete Postconditions [Sep 17] • Writing Complete Postconditions (4-up) [Sep 17] • |
|
| 4 | TUE, Sep 17 |
• Anchor Type: like • Copying arrays: reference vs. shallow vs. deep copies • Use of old expressions • BON diagram: client-supplier relations |
|
|
||
| 5 | THU, Sep 19 |
• Complete Postcondition for Composite Attributes • Example: 5 Versions of BANK.deposit_on • Postcondition Exercises |
|
|
||
| 6 | TUE, Sep 24 |
• Postcondition Exercises • Information Hiding • Iterator Pattern at Runtime • Implementing the Iterator Pattern (Easy Case) |
|
|
• Genericity, Iterator, and Singleton [Sep 23] • Genericity, Iterator, and Singleton (4-up) [Sep 23] • BON Design Diagram of Iterator Pattern • |
|
| 7 | THU, Sep 26 |
• Design Architecture of the Iterator Pattern • Use of the Iterator Pattern (across loop vs. from-until loop) • Exercise: Iterator and Generics • Reference Type (Aggregation) vs. Expanded Type (Composition) |
|
|
||
| 8 | TUE, Oct 1 |
• Shared data problem • Inheritance solution • Requirements: Single Choice Principle and Cohesion • Once Routines • Singleton Pattern |
|
|
||
| 9 | THU, Oct 3 |
• Export Status • Inheritance (for code reuse) • Design Case Study (manual encoding of object type vs. dynamic binding) |
|
|
• Inheritance Hierarchy of Smartphone Classes • |
|
| 10 | TUE, Oct 8 |
• Static Type vs. Dynamic Type • Polymorphism • Dynamic Binding • Testing of Postconditions |
|
|
||
| 11 | THU, Oct 10 |
• Expectations, Static Types, Substitutions • Versions of features, Dynamic Types, Dynamic Binding • Type Casting (Upwards vs. Downwards) |
|
|
||
| 12 | TUE, Oct 22 |
• Type Casting (Runtime Violation or Not?) • Polymorphic Collection • Polymorphic Feature Parameter • Polymorphic Return Type • Generics: Motivating Example |
|
|
||
| 13 | THU, Oct 24 |
• General Book: Casts and Single Choice Principle • Generic Book: Parameterization of Types • Inheritance vs. Genericity • Composite Pattern: Motivating Problem • Multiple Inheritance • Composite Pattern: Design Attempts |
|
|
• Composite Design Pattern [Oct 24] • Composite Design Pattern (4-up) [Oct 24] • BON Design Diagram of Composite Pattern • BON Design Diagram of Composite Pattern (Multiple Instantiations) • Visitor Design Pattern [Oct 27] |
|
| 14 | TUE, Oct 29 |
• Composite Pattern: Problem, Architecture, Implementation • Composite Pattern: Polymorphism and Dynamic Binding • Open-Closed Principle • Visitor Pattern: Architecture |
|
|
||
| 15 | THU, Oct 31 |
• Visitor Pattern: Usage versus Implementation • Visitor at Runtime: Double Dispatch • Visitor Pattern: Open-Closed vs. Single-Choice Principles |
|
|
||
| 16 | TUE, Nov 5 |
• Using MATHMODELS to write stable contracts for multiple implementation strategies • Commands vs. Queries in MATHMODELS • Abstraction Function • Case Study: Birthday Book |
|
|
• Implementation, Model, and Abstraction Function (Strategy 2) [Nov 3] • Exercise I for Programming Lab Test 2 • 10-State-Pattern (4-up) [Nov 7] • BON Design Diagram of State Pattern [Nov 12] • |
|
| 17 | THU, Nov 7 |
• Case Study: Birthday Book Contracts • State Pattern: Problem • First Design Attempt |
|
|
||
| 18 | TUE, Nov 12 |
• Interactive Systems: Non-OO vs. OO Solutions • Template Pattern • State Design Pattern: Architecture • State Pattern: Transition Table vs. Polymorphic State Array |
|
|
||
| 19 | THU, Nov 14 |
• Substitutibility and Design by Contract • Preconditions (require less in descendant classes) • Postconditions (ensure more in descendant classes) • Contract Re-Declaration |
|
|
• Weather Station without the Observer Pattern • Weather Station with the Observer Pattern • Generalizing the Observer Pattern using Event-Driven Design in Java • Generalizing the Observer Pattern using Event-Driven Design in Eiffel |
• 11-Subcontracting (4-up) [Nov 12] • Subcontracting: Architectural View [Nov 12] • 12-Observer-Pattern [Nov 15] • 12-Observer-Pattern (4-up) [Nov 15] • First Design for Weather Station [Nov 15] • BON Design Diagram of Observer Pattern [Nov 15] • Applying the Observer Pattern to Weather Station [Nov 15] • • |
| 20 | FRI, Nov 15 |
• Contract Re-Declaration • Invariant Accumulation • Weather Station Problem: 1st Design • Observer Pattern |
|
|
||
| 21 | FRI, Nov 22 |
• Observer Pattern • Event-Driven Design • Implementing Event-Driven Design in Java |
|
|
||
| 22 | TUE, Nov 26 |
• Implementing Event-Driven Design in Eiffel • Strong vs. Weak Predicates • Hoare Triples |
|
|
• 13-Program Correctness [Nov 26] • 13-Program Correctness (4-up) [Nov 26] • |
|
| 23 | THU, Nov 28 |
• Proving Hoare Triples • Weakest Precondition (WP) • WP Rules: Assignments, Conditionals, Sequential Composition |
|
|
||
| 24 | TUE, Dec 3 |
• Correctness of Loops • Loop Invariant vs. Loop Variant • Wrap-Up |
|
|
||
| Exam Review 1 | MON, Dec 9 |
• Polymorphic Collection and Dynamic Binding • Drawing BON Diagrams • Visitor Pattern and Double Dispatch • Proof of Loop Correctness |
|
|
||
| Exam Review 2 | WED, Dec 11 |
• Proof of Program Correctness • Loop Invariant and Loop Variant • State Design Pattern • Why Inheritance • Cohesion and Single Choice Principle |
|
|
||
| Exam Review 3 | THU, Dec 12 |
• Proof of Program Correctness • Loop Invariant and Loop Variant • Complete Postcondition • Event-Driven Design • Uniform Access Principle |
|
|
||
| # | Date | Topics | Recording | iPad Notes | Source Code | Slides/Notes |
|
Playlist of All Lecture Recordings
|
||||||
| 1 | MON, Jan 7 |
• Administrative Issues |
|
|
||
| 2 | WED, Jan 9 |
• Development Process • Compile-Time (Syntax or Type) Errors • Run-Time (Exception or Logical) Errors • Literals • Operations, Operators, Operands |
|
|
• 01-Elementary Programming [Jan. 16] • 01-Elementary Programming (4-up) [Jan. 16] |
|
| 3 | MON, Jan 14 |
• Data Types • Expressions • Assignments • Constants vs. Variables |
|
|
||
| 4 | WED, Jan 16 |
• Coercion vs. Cast • Escape Sequence • print vs. println |
|
|
||
| 5 | MON, Jan 21 |
• If-Statements Syntax and Semantics • Invalid vs. Valid Input Conditions |
|
|
• 02-Selections (4-up) [Jan. 28] • Semantics of a Single If-Statement [Jan. 16] • Lab Test 1 Preparation (Guide ; Tutorial Video ; LabTest1Demo and solution ; ExampleTest1 and solution) |
|
| 6 | WED, Jan 23 |
• Variable Scopes • Single If-Statement vs. Multiple If-Statements • Overlapping vs. Non-Overlapping Conditions |
|
|
||
| 7 | MON, Jan 28 |
• Laws of Logical Operators • Short-Circuit Evaluation |
|
|
||
| 8 | WED, Jan 30 |
• Short-Circuit Evaluation • Selections (General vs. Specific) • Common Errors and Pitfall |
|
|
||
| 9 | MON, Feb 4 |
• for-loop vs. while-loop • counting the number of iterations |
|
|
• Lab Test 2 Preparation [Feb 20] (Guide ; Tutorial Video (same as for Lab Test 1) ; ExampleTest2 and solution videos) |
|
| 10 | WED, Feb 6 |
• Equivalent ways to writing stay condition • Array Basics |
|
|
||
| 11 | MON, Feb 11 |
• Initializing an Arithmetic Sequence • Calculating the Average • Printing in the Reverse Order |
|
|
||
| 12 | WED, Feb 13 |
• Printing a comma-separated list • Printing positive numbers only • Finding the maximum value • Determining if all numbers are positive |
|
|
||
| 13 | MON, Feb 25 |
• Short-Circuit Evaluation and Array Indexing • Nested Loops • Determining if array contains duplicates |
|
|
||
| 14 | WED, Feb 27 |
• Nested Loops: Determining if an array contains duplicates • Common Errors of Loops • Object Orientation: Observe-Model-Execute |
|
|
• 04-Classes-and-Objects [Mar 13] • 04-Classes-and-Objects (4-up) [Mar 13] • The Observe-Model-Execute Process [Feb 27] • Lab Test 3 Preparation (Guide ; ExampleTest3 and solution) |
|
| 15 | MON, Mar 4 |
• Classes as Templates • Attributes and Constructors • Calling Constructor to Create Objects |
|
|
||
| 16 | WED, Mar 6 |
• use of this keyword • accessors vs. mutators • method calls and context objects |
|
|
||
| 17 | MON, Mar 11 |
• Primitive Type vs. Reference Type • Aliasing |
|
|
||
| 18 | WED, Mar 13 |
• Aliasing and Arrays • Data Types (Primitive vs. Reference) and Default Values • Method Parameters vs. Arguments • Use of Accessors vs. Mutators |
|
|
||
| 19 | MON, Mar 18 |
• Programming Pattern: Array-Typed Attributes and Integer Counter • Programming Pattern: Static vs. Non-Static Variables |
|
|
||
| 20 | WED, Mar 20 |
• Use of Static Variables as Object ID's • Misuse of Static Variables as Array Counters • Misuse of Non-Static Variables in Static Methods |
|
|
||
| 21 | MON, Mar 25 |
• Fixes to Misuse of Non-Static Variables in Static Methods • Accessor Method: getPointsInQuodrantI • Accessor Method (Point movedUpBy) vs. Mutator Method (void moveUpBy) |
|
|
||
| 22 | WED, Mar 27 |
• Java API (Application Programming Interface) • Method Headers, Parameters vs. Arguments • Math Class, static methods • ArrayList Class, non-static methods |
|
|
• Lab 7 Exercise (Lab7 Starter ; Lab7 Solution) |
|
| 23 | MON, Apr 1 |
• Use of ArrayList (size, overloaded add, remove, get, indexOf, contains) • Visualizing a Hashtable |
|
|
||
| 24 | WED, Apr 3 |
• Use of Hashtable (size, containsKey, containsValue, put, get, remove) • Wrap-Up of Covered Topics |
|
|
||
| Exam Review | FRI, Apr 5 |
• Hashtable • aliasing • short-circuit evaluation • NullPointerException vs. ArrayIndexOutOfBoundsException |
|
|
||
| # | Date | Topics | Recording | iPad Notes | Source Code | Slides/Notes |
|
Playlist of All Lecture Recordings
|
||||||
| 1 | MON, Jan 7 |
• Course Syllabus • Design: Architecture and Specification • Design by Contract (DbC): Client vs. Supplier • DbC in Java (Version 1) |
|
|
• Administratives (4-up) [Jan. 7] • Design by Contract in Java and Eiffel [Jan. 14] • Design by Contract in Java and Eiffel (4-up) [Jan. 14] • Runtime Assertion Checking for Contracts - ACCOUNT Class • Runtime Assertion Checking for Contracts - General Case • Eiffel Overview: Common Syntax [Jan. 14] • Eiffel Overview: Common Syntax (4-up) [Jan. 14] |
|
| 2 | WED, Jan 9 |
• DbC in Java (Version 2 to Version 5) • Preconditions, Class Invariant |
|
|
||
| 3 | MON, Jan 14 |
• DbC in Java (Version 5) Postcondtion • Runtime Assertion Checking of Contracts • Eiffel Survival Guide |
|
|
||
| 4 | WED, Jan 16 |
• Short-Circuit vs. Logical Operators • Expanded Types vs. Reference Types • Reference vs. Shallow vs. Deep Copies |
|
|
||
| 5 | MON, Jan 21 |
• Copies of Arrays • Complete Postconditions (V1 to V3) |
|
|
||
| 6 | WED, Jan 23 |
• Complete Postconditions (V3 to V5) • Postcondition Exercises |
|
|
||
| 7 | MON, Jan 28 |
• Postcondition Exercise • Use of Generic Parameters • Information Hiding Principle • Iterator Pattern |
|
|
• Genericity, Iterator, and Singleton [Feb 4] • Genericity, Iterator, and Singleton (4-up) [Feb 4] |
|
| 8 | WED, Jan 30 |
• Iterator Pattern • Once Routines |
|
|
||
| 9 | MON, Feb 4 |
• Singleton Pattern (Java vs. Eiffel) • Inheritance (code reuse, testing of postcondition) |
|
|
• Bad Design without Inheritance |
• Notes on Static Types, Dynamic Types, and Casts • Architecture for Testing Violation of Postcondition [Feb 4] |
| 10 | MON, Feb 11 |
• Implementation Contracts • Mathematical Model • Single Choice Principle |
|
|
||
| 11 | WED, Feb 13 |
• Use of REL • Birthday Book: Design and Implementation • Testing of Postconditions |
|
|
||
| 12 | MON, Feb 25 |
• Static Types vs. Expectations • Dynamic Types • Upward vs. Downward Casts |
|
|
||
| 13 | WED, Feb 27 |
• Inheritance: Type-Checking Rules • Inheritance: Feature Arguments • Inheritance: Feature Return Values • Inheritance: Polymorphic Collections • Generics |
|
|
• Composite Design Pattern [Mar 4] • Composite Design Pattern (4-up) [Mar 4] • Visitor Design Pattern [Mar 7] |
|
| 14 | MON, Mar 4 |
• Generics (Design) • Multiple Inheritance • Composite Design Pattern |
|
|
||
| 15 | WED, Mar 6 |
• Composite Design Pattern (Polymorphism and Dynamic Binding) • Visitor Design Pattern (Motivating Problem) |
|
|
||
| 16 | MON, Mar 11 |
• Open-Closed Principle • Visitor Design Pattern: Architecture • Visitor Design Pattern: Double Dispatch at Runtime |
|
|
||
| 17 | WED, Mar 13 |
• Interactive Systems Problem • State Transition Diagram • Non-OO, Hierarchical Solution • OO Solution: State Design Pattern (Architecture) |
|
|
||
| 18 | MON, Mar 18 |
• Non-OO Solution vs. State Design Pattern • State Design Pattern at Runtime • Subcontracting: Require Less vs. Ensure More |
|
|
||
| 19 | WED, Mar 20 |
• Substitutability • Inheritance of preconditions, postconditions, and invariants • Contract Re-Declaration and Runtime Assertion Checks |
|
|
||
| 20 | MON, Mar 25 |
• First Design Attempt: Possible Redundant Remote Procedure Calls • Observer Design Pattern: Architecture, Polymorphism, Dynamic Binding |
|
|
• Weather Station without the Observer Pattern • Weather Station with the Observer Pattern • Generalizing the Observer Pattern using Event-Driven Design in Java • Generalizing the Observer Pattern using Event-Driven Design in Eiffel |
• 12-Observer-Pattern [Mar 20] |
| 21 | WED, Mar 27 |
• Observer Design Pattern vs. Event-Driven Design • Event-Driven Design: Java (MethodHandler) vs. Eiffel (agents) |
|
|
||
| 22 | MON, Apr 1 |
• Event-Driven Design: Java (MethodHandler) vs. Eiffel (agents) • Program Verification (Strong vs. Weak Predicates, Weakest Precondition, Correctness Predicates, Hoare Triples) |
|
|
• 13-Program-Correctness [Mar 27] |
|
| 23 | WED, Apr 3 |
• Program Verification • wp rule: assignment • wp rule: alternation |
|
|
||
| 24 | FRI, Apr 5 |
• Program Verification • wp rule: loops • Loop Contract: invariant vs. variant • agent, partial application, counting quantifier |
|
|
||
| Exam Review 1 | WED, Apr 10 |
• Loop Correctness • agent and counting quantifier • Observer Pattern • Visitor Pattern |
|
|
||
| Exam Review 2 | THU, Apr 11 |
• Program Correctness • Subcontracting • Observer Pattern • Event-Driven Design • State Pattern |
|
|
||
| # | Date | Topics | Recording | iPad Notes | Source Code | Slides/Notes |
|
Playlist of All Lecture Recordings
|
||||||
| 1 | WED, Sep 5 |
• Administrative Issues • Review on Classes and Objects • Basic use of Eclipse |
|
|
• 01-Classes and Objects (Dec. 3) • 01-Classes and Objects-4up (Dec. 3) |
|
| 2 | MON, Sep 10 |
• Methods, Method Calls, Context Objects • Aliasing |
|
|
||
| 3 | WED, Sep 12 |
• Review on Classes and Objects (aliasing and arrays, short-circuit) • Anonymous Objects • Motivating Examples for Exceptions |
|
|
||
| 4 | MON, Sep 17 |
• Exceptions (Circle, Bank, To Handle or Not To Handle) • Catch-or-Specify Requirement |
|
|
||
| 5 | WED, Sep 19 |
• Manual Console Tester Classes • State Diagram for Inferring Test Cases • JUnit tests (for cases of unexpected and expected exceptions) |
|
|
• Preparation Guide for Lab Test 1 • Expectation and Strategy on Lab Test (Starter Project here) |
|
| 6 | MON, Sep 24 |
• JUnit tests (using loops to cover multiple input values) • Test-Driven Development (TDD) process • The equals method (default vs. overridden versions) |
|
|
• 04-Advanced Classes and Objects [Oct 3] • 04-Advanced Classes and Objects (4-up) [Oct 3] |
|
| 7 | WED, Sep 26 |
• The equals method (JUnit Examples) • Motivating Example for compareTo |
|
|
||
| 8 | MON, Oct 1 |
• Implementing Comparable interface • Implementing compareTo method • Map, Table, Dictionary • (Inefficient) One-Array Implementation of Map • Hashing |
|
|
||
| 9 | WED, Oct 3 |
• Hashing and Sample Codes • Introducing time complexity of algorithms (experiments) |
|
|
||
| 10 | MON, Oct 15 |
• Counting Primitive Operations • Asymptotic Upper Bound (Big-O) |
|
|
||
| 11 | WED, Oct 17 |
• Asymptotic Upper Bounds of more code examples • Selection sort vs. Insertion sort |
|
|
• Implementing and Testing Selection Sort and Insertion Sort |
|
| 12 | MON , Oct 22 |
• Tracing Selection sort vs. Insertion sort • Call by Value (Primitive vs. Reference) |
|
|
• 06-Aggregation and Composition [Oct 29] • 06-Aggregation and Composition (4-up) [Oct 29] • Preparation Guide for Lab Test 2 • Solutions to Lab Test 2 Exercises |
|
| 13 | WED, Oct 24 |
• Tracing Insertion sort • Call by Value (Primitive vs. Reference) • Aggregation (single containee vs. multiple containees) |
|
|
||
| 14 | MON, Oct 29 |
• Aggregation and Dot Notation • Composition • Copy Constructor (Shallow Copy vs. Deep Copy) |
|
|
||
| 15 | WED, Oct 31 |
• Copy Constructor (Deep Copy) • Inheritance: Code Reuse • Static Type: Expectations |
|
|
• Student Management System (with and without inheritance) • Type Casts (Compilable vs. Non-Compilable and Exception-Free vs. ClassCastException) |
• 07-Inheritance (4-up) [Nov 12] • Required Reading: Intuitions on Polymorphism and Dynamic Binding • Required Reading: Static Types, Dynamic Types, Type Casts • Preparation Guide for Lab Test 3 • Solutions to Lab Test 3 Exercises |
| 16 | MON, Nov 5 |
• Static Types: Expectations, Substitutions • Dynamic Types |
|
|
||
| 17 | WED, Nov 7 |
• Compilable Cast vs. Non-Compilable Cast • ClassCastException vs. Exception-Free Cast |
|
|
||
| 18 | MON, Nov 12 |
• Compilable Cast vs. Non-Compilable Cast • ClassCastException vs. Exception-Free Cast • Polymorphic Method Parameters • Polymorphic Array |
|
|
||
| 19 | WED, Nov 14 |
• Polymorphic Method Parameters • Polymorphic Method Return Types • Overriding the equals method |
|
|
||
| 20 | MON, Nov 19 |
• Abstract Class (Polygon, Rectangle, Triangle) • Interface (Point, CartisianPoint, PolarPoint) |
|
|
||
| 21 | WED, Nov 21 |
• General Pattern of a Recursive Solution • factorial, fibonacci number, isPalindrome, reverseOf |
|
|
• 10-Generics (Optional) [Dec 3] • 10-Generics (4-up) (Optional) [Dec 3] |
|
| 22 | MON, Nov 26 |
• occurrencesOf • General Pattern of Recursion on an Array • isAllPositive |
|
|
||
| 23 | WED, Nov 28 |
• isSorted • Binary Search • Tower of Hanoi |
|
|
||
| 24 | MON, Dec 3 |
• Tower of Hanoi • Running Time of Recursion (Tower of Hanoi, Binary Search) • Proving Correctness of Recursion (allPositive) • Merge Sort |
|
|
||
| Exam Review 1 | MON, Dec 10 |
• Exceptions • JUnit tests (exceptions expected vs. unexpected) • Recursive programming (fibArray, gcd) • Running Time (Tower of Hanoi, Merge Sort) • Proof of Correctness (pattern, sum) |
|
|
||
| Exam Review 2 | WED, Dec 12 |
• Recursion (programming, running time, correctness proof) • Static attributes • Testing (equivalence classes) |
|
|
||
| # | Date | Topics | Recording | iPad Notes | Source Code | Slides/Notes |
|
Playlist of All Lecture Recordings
|
||||||
| 1 | THU, Sep 6 |
• Course Syllabus • Contract, Client, Supplier • Design by Contract (DbC) • DbC in Java (Version 1) |
|
|
• Design by Contract in Java and Eiffel • Design by Contract in Java and Eiffel (4-up) • Runtime Assertion Checking for Contracts - ACCOUNT Class • Runtime Assertion Checking for Contracts - General Case • Eiffel Overview: Common Syntax [Sep. 18] • Eiffel Overview: Common Syntax (4-up) [Sep. 18] |
|
| 2 | TUE, Sep 11 |
• Contracts: Preconditions, Postconditions, Invariants • DbC in Java (Version 2 to Version 5) • Runtime Assertion Checking for Contracts |
|
|
||
| 3 | THU, Sep 13 |
• Runtime Assertion Checking for Contracts • Review of Eiffel Syntax (:= vs. =, and vs. and then, create, across, loop) |
|
|
||
| 4 | TUE, Sep 18 |
• Equality (is_equal vs. ~) • Expanded vs. Reference Types • Reference vs. Shallow vs. Deep Copies |
|
|
• Writing Complete Postconditions [Sep. 20] • Writing Complete Postconditions (4-up) [Sep. 20] • Test-Driven Development (TDD) [Sep. 20] • Test-Driven Development (TDD) (4-up) [Sep. 20] • Genericity, Iterator, and Singleton [Oct. 2] • Genericity, Iterator, and Singleton (4-up) [Oct. 2] • BON Diagram of Iterator Pattern • BON Diagram of Singleton Pattern • Inheritance (4-up) [Oct. 16] |
|
| 5 | THU, Sep 20 |
• Reference vs. Shallow vs. Deep Copies • Caching Old Values for Postconditions • Testing of Contracts |
|
|
||
| 6 | TUE, Sep 25 |
• Test-Driven Development (TDD) and Regression Testing • Writing Complete Postconditions • Use of Generic Parameter • Iterator Design Pattern |
|
|
||
| 7 | THU, Sep 27 |
• Iterator Design Pattern (runtime behaviour) • Motivating Example for Singleton Pattern • "once" queries |
|
|
||
| 8 | TUE, Oct 2 |
• Inferring Types of Generics (Lab 2) • Singleton Pattern • Inheritance (Reuse of Code, Single Choice Principle) |
|
|
||
| 9 | THU, Oct 4 |
• Polymorphism • Dynamic Binding |
|
|
||
| 10 | TUE, Oct 16 |
• Type Casting • Polymorphic Collection • Types of Feature Parameters and Return Values |
|
|
||
| 11 | THU, Oct 18 |
• Type Checking Rules for Inheritance/Polymorphism • Generics |
|
|
||
| Midterm Review | FRI, Oct 19 |
• Postconditions • Generics • Information Hiding • Iterator Pattern |
|
|
||
| 12 | TUE, Oct 23 |
• Uniform Access Principle • State Pattern (Motivating Problem, Two Bad Initial Designs) |
|
|
• 08-Uniform-Access-Principle [Oct. 23] |
|
| 13 | THU, Oct 25 |
• State Pattern (Hierarchical Solution vs. OO Solution) • Template Pattern |
|
|
||
| 14 | TUE, Oct 30 |
• State Pattern Review (Hierarchical Solution vs. OO Solution) • Multiple Inheritance • Composite Design Pattern |
|
|
||
| 15 | THU, Nov 1 |
• Composite Design Pattern Review • Visitor Pattern (Motivating Problem) • Open-Closed Principle |
|
|
Tutorial: Implementing the Composite and Visitor Design Patterns |
|
| 16 | TUE, Nov 6 |
• Visitor Pattern (Architecture) • Double Dispatches • Void Safety |
|
|
||
| 17 | THU, Nov 8 |
• Void Safety • Math Models Library |
|
|
||
| 18 | TUE, Nov 13 |
• Math Models Library (abstraction function, use of relations) • Subcontracting (require less vs. ensure more) |
|
|
||
| 19 | THU, Nov 15 |
• Subcontracting (require else vs. ensure then) • Observer Pattern (Motivating problem, First Design) |
|
|
||
| 20 | TUE, Nov 20 |
• Observer Pattern • Event-Driven Design in Java |
|
|
• Weather Station with the Observer Pattern • Generalizing the Observer Pattern using Event-Driven Design in Java • Generalizing the Observer Pattern using Event-Driven Design in Eiffel |
• 15-Observer-Pattern [Nov 22] • 15-Observer-Pattern (4-up) [Nov 22] • BON Diagram of Observer Pattern
|
| 21 | THU, Nov 22 |
• Event-Driven Design in Eiffel • Program Correctness (Stronger vs. Weaker Predicates) |
|
|
• 16-Program-Correctness [Dec 4] |
|
| 22 | TUE, Nov 27 |
• Weakest Precondition • wp rules of assignment, alternation, sequential composition |
|
|
||
| 23 | THU, Nov 29 |
• Loop Invariant • Loop Variant |
|
|
||
| 24 | TUE, Dec 4 |
• Proof of Loop Correctness |
|
|
||
| Exam Review 1 | THU, Dec 6 |
• wp calculation (b vs. b0) • inheritance • visitor pattern • observer pattern vs. event-driven design • subcontracting |
|
|
||
| Exam Review 2 | FRI, Dec 7 |
• Complete Postconditions • old expressions for ref vs. shallow vs. deep copies • Proof of Program Correctness • Template Design Pattern |
|
|
||
| # | Date | Topics | Recording | iPad Notes | Source Code | Slides/Notes |
|
Playlist of All Lecture Recordings
|
||||||
| 1 | MON, Jan 8 |
• Administrative Issues • Elementary Programming |
|
|
• Tutorial Series on Building a BMI app |
|
| 2 | MON, Jan 15 |
• Elementary Programming • Selections (no slides) |
|
|
||
| 3 | MON, Jan 22 |
• Selections (logical operators) • Classes and Objects (attributes, constructor) |
|
|
• CircleCalculator2 (with conditional inputs) • LogicalOperatorTester (negation, conjunction, and disjunction) |
• 03-Classes and Objects (4-up) • Preparation Guide for Lab Test 1 ; Example Test 1 • 04-Loops • Preparation Guide for Lab Test 2 ; Example Test 2 • 05-Two-Dimensional Arrays (4-up) |
| 4 | MON, Jan 29 |
• Classes and Objects (object orientation, variable scopes, constructors) |
|
|
• Point |
|
| 5 | MON, Feb 5 |
• Classes and Objects (visualization) • Loops (for-loops) |
|
|
• Person which Calls gainWeightBy (no error) |
|
| 6 | MON, Feb 12 |
• Selections (more if-statement examples) • for-loops and while-loops • Basic syntax of arrays |
|
|
||
| 7 | MON, Feb 26 |
• Short-Circuit Effects of Logical Operations • loops and arrays examples (e.g., allPos) |
|
|
||
| 8 | MON, Mar 5 |
• loops and arrays examples (e.g., read and print numbers [4 versions]) |
|
|
• Read and Print Numbers: Version 1 (inflexible) • Read and Print Numbers: Version 2 (flexible, incorrect) • Read and Print Numbers: Version 3 (flexible, correct) • Read and Print Numbers: Version 4 (flexible, correct, alternative) |
|
| 9 | MON, Mar 12 |
• loops and arrays examples (e.g., hasDup) • Two-Dimensional Arrays (calculate distances) |
|
|
• Calculate Mileages of Itinerary: Version 1 (using multiple 1-D arrays) • Calculate Mileages of Itinerary: Version 2 (using single 2-D array) |
|
| 10 | MON, Mar 19 |
• Two-Dimensional Arrays (calculate distances, printAll, averageOf, maxOf, maxSumRowOf) |
|
|
||
| 11 | MON, Mar 26 |
• Two-Dimensional Arrays (isRectangle, isSquare, printTriangular) • Selections (overlapping conditions) • Classes and Objects (aliasing) |
|
|
• Challenging Exercises on 2D Arrays • Solution |
|
| 12 | MON, Apr 2 |
• Aliasing example • Static variables • Java API (Math, ArrayList, HashTable) |
|
|
||
| Exam Review 1 | FRI, Jul 20 |
• Review • Solution to Example Lab Test 3 |
|
|||
| Exam Review 2 | THU, Aug 23 |
• 2D Array - Maximum Sum, Matrix operations • Java Collection • Short-Circuit Evaluation • Aliasing, dot notation • NullPointerException vs. ArrayIndexOutOfBoundsExcpetion • 2D Array - |
|
|
||
| # | Date | Topics | Recording | iPad Notes | Source Code | Slides/Notes |
|
Playlist of All Lecture Recordings
|
||||||
| 1 | THU, Sep 7 |
• Administrative Issues • Introduction to Utility Classes |
|
|||
| 2 | TUE, Sep 12 |
• Visibility of Classes/Attributes/Methods • Utility Classes (Studying CircleUtilities) |
|
|
||
| 3 | THU, Sep 14 |
• Using and Documenting Utility Classes • Design by Contract, Preconditions • Introduction to JUnit |
|
|
||
| 4 | TUE, Sep 19 |
• Introduction to JUnit • Use of breakpoints and debugger |
|
|
• Solution to Exercise: Counter |
|
| 5 | THU, Sep 21 |
• Object Orientation • Constructors |
|
|
• Preparation Exercises for Lab Test 1 • 03-Classes-and-Objects (4-up) • Required Reading: Point and PointCollector • Preparation Exercises for Lab Test 2 |
|
| 6 | TUE, Sep 26 |
• Mutators • Accessors |
|
|
7 | THU, Sep 28 |
• Reference-Typed Variables • List-Typed Variables • Equals Method |
|
|
| 8 | TUE, Oct 3 |
• Equals Method, Type Casting • Short-Circuit Effect • Call-by-Val vs. Call-by-Ref |
|
|
9 | THU, Oct 5 |
• Call-by-Val vs. Call-by-Ref • Map, Hash Table, Hash Code |
|
|
| 10 | TUE, Oct 10 |
• Hash Code • Aggregations vs. Compositions |
|
|
||
| 11 | THU, Oct 12 |
• Compositions • compareTo method • Mixing static and non-static |
|
|
||
| 12 | TUE, Oct 17 |
• Asymptotic Analysis |
|
|
||
| 13 | THU, Oct 19 |
• Asymptotic Analysis • ADTs, Arrays, Singly-Linked Lists |
|
|
||
| 14 | TUE, Oct 24 |
• Singly-Linked Lists |
|
|
||
| 15 | TUE, Oct 31 |
• Singly-Linked Lists • Stacks and Queues |
|
|
||
| 16 | THU, Nov 2 |
• Recursion (factorial, fibonacci, palindrome, reverse) |
|
|
• Required Reading: Solving Problems Recursively • Preparation Guide for Lab Test 3 • Solutions to Lab Test 3 Exercises |
|
| 17 | TUE, Nov 7 |
• Recursion (occurrences, allPositive, isSorted) |
|
|
||
| 18 | THU, Nov 9 |
• Recursion (selectionSort, binarySearch, towerOfHanoi) |
|
|
||
| 19 | TUE, Nov 14 |
• Recursion (towerOfHanoi, proof of correctness) • Binary Trees (concepts) |
|
|
||
| 20 | THU, Nov 16 |
• Binary Trees (Java implementations) • Inheritance for Code Reuse |
|
|
• Student Management System (with and without inheritance) • Visibility: private, no modifier, protected, public • Cast: Compilable vs. Runtime-Error-Free • Abstract Classes: Polygon, Rectangle, Triangle • Interfaces: Point, CartesianPoint, PolarPoint |
• Inheritance Hierarchy of Smartphone Classes • Required Reading: Intuitions on Polymorphism and Dynamic Binding • Required Reading: Static Types, Dynamic Types, Type Casts • Preparation Guide for Lab Test 4 • 10-Abstract Classes and Interfaces • 10-Abstract Classes and Interfaces-4up
|
| 21 | TUE, Nov 21 |
• Inheritance: Polymorphism and Dynamic Binding |
|
|
||
| 22 | THU, Nov 23 |
• Inheritance: Type Casts • Inheritance: Method Arguments |
|
|
||
| 23 | TUE, Nov 28 |
• Inheritance: Method Return Values • Inheritance: Dynamic Binding and Overriding • Abstract Classes |
|
|
||
| 24 | THU, Nov 30 |
• Interfaces • Generics |
|
|
||
| # | Date | Topics | Recording | iPad Notes | Source Code | Slides/Notes |
|
Playlist of All Lecture Recordings
|
||||||
| 1 | MON, Sep 11 |
• Design by Contract (DbC) • DbC in Java (V1 to V3) |
|
|
||
| 2 | WED, Sep 13 |
• Design by Contract (DbC) • DbC in Java (V3 to V5) • Overview of Eiffel Syntax |
|
|
||
| 3 | MON, Sep 18 |
• Structures of Classes and Features • Overview of Eiffel Syntax • Writing ESpec Tests |
|
|
||
| 4 | WED, Sep 20 |
• Writing Boolean and Violation Tests in ESpec • Abstract Data Type (ADT) |
|
|
||
| 5 | MON, Sep 25 |
• Writing Violation Tests for Postconditions • Abstract Data Type (ADT) • Uniform Access Principle |
|
|
• 02-Classes-and-Objects (4-up) • 03-Singleton-and-Iterator (4-up) |
|
| 6 | WED, Sep 27 |
• Generic Parameters • Singleton Pattern |
|
|
||
| 7 | MON, Oct 2 |
• Expanded Classes • Once Queries • Singleton Pattern |
|
|
||
| 8 | WED, Oct 4 |
• Ref vs. Shallow vs. Deep Copies • Writing Complete Postconditions |
|
|
||
| 9 | WED, Oct 11 |
• Iterator Pattern • across over iterable objects |
|
|
||
| 10 | MON, Oct 16 |
• Inheritance • Polymorphism |
|
|
||
| 11 | WED, Oct 18 |
• Polymorphism • Dynamic Binding |
|
|
||
| 12 | MON, Oct 23 |
• Type Casts • Polymorphism: arguments, return values |
|
|
||
| 13 | WED, Oct 25 |
• Generics • Inheritance and Contracts |
|
|
||
| 14 | MON, Oct 30 |
• Inheritance and Contracts • The State Design Pattern |
|
|
• BON Diagram of State Pattern • BON Diagram of Composite Pattern • BON Diagram of Visitor Pattern • Required Reading: Tutorial on the Eiffel Testing Framework (ETF) |
|
| 15 | WED, Nov 1 |
• The State Design Pattern • The Composite Design Pattern |
|
|
||
| 16 | MON, Nov 6 |
• The Composite Design Pattern • The Visitor Design Pattern |
|
|
||
| 17 | WED, Nov 8 |
• The Visitor Design Pattern |
|
|
||
| 18 | MON, Nov 13 |
• Void Safety • The Observer Design Pattern |
|
|
• 11-Observer-Pattern-Event-Driven-Design |
|
| 19 | WED, Nov 15 |
• Event-Driven Design |
|
|
• Generalizing the Observer Pattern using Event-Driven Design in Java • Generalizing the Observer Pattern using Event-Driven Design in Eiffel |
|
| 20 | MON, Nov 20 |
• Abstractions via Mathematical Models |
|
|
||
| 21 | MON, Nov 27 |
• Eiffel Testing Framework (ETF) • Hoare Triples • wp for Assignments |
|
|
• 13-Eiffel Testing Work (ETF) |
|
| 22 | WED, Nov 29 |
• wp for Alternations • wp for Sequential Compositions • Loop Invariants and Loop Variants |
|
|
||
| 23 | MON, Dec 4 |
• Loop Invariants and Loop Variants • Correctness of Loops |
|
|
||
| Date | Course | Topics | Recording | iPad Notes | Source Code | Slides/Notes |
| MON, Sep 18, 2017 | EECS2030B |
• Visibility of Classes/Attributes/Methods • Introduction to JUnit |
|
|
||
| WED, Sep 20, 2017 |
• Testing Exceptions in JUnit • Intro. to Object Orientation |
|
|
|||
| WED, Feb 28, 2018 | EECS3311 |
• The State Design Pattern • The Template Design Pattern |
|
|
||
| WED, Sep 5, 2018 | EECS3311E |
• Course Syllabus • Design by Contract (DbC) in Java |
|
|
||
| TUE, Oct 22, 2019 | EECS4312E |
• Certification of Safety-Critical, Software-Intensive Systems • Function Tables • Programmable Logic Controllers (PLCs) • Verifying IEC61131-3 Annex F (Function Block Library) |
|
|
• Reference: Formal Verification of Function Blocks Applied to IEC 61131-3
• Reference: Precise Documentation and Validation of Requirements
|
• Certification of Safety-Critical, Software-Intensive Systems • Certification of Safety-Critical, Software-Intensive Systems (4-up) |
| MON, Mar 9, 2020 | EECS3311Z |
• Non-OO Design vs. OO Design • The State Design Pattern • The Template Design Pattern • Polymorphism and Dynamic Binding |
|
|
• The State and Template Design Patterns |