|
|||||
# | 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 |
|
||
![]() ![]() ![]() |
|
|||||
# | 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 |
![]() |
|
|
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 |
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] |
|
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] |
|
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] |
|
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) |
![]() |
![]() |
||
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] |
|
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] |
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] |
|
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 |