Jackie's Lectures

• Course Syllabus (last updated: September 3; subject to revision until September 16)
• iClicker Class Attendance Rules
• Slides on Administrative Issues
• Weekly Schedule (Labs, Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Labs, Tests, Exam) [Last Update: Sep 3]

• Syllabus

• Professional Engineers: Code of Ethics

• Software Development: Compile Time vs. Run Time

• Lab Instructions
  • Lab 0 Part 1
  • Lab 0 Part 2
• Review Tutorials on OOP in Java
  •  Tutorial Videos Playlist
  •  iPad notes
• Required Written Notes
  • Inferring Classes/Methods from JUnit Tests ( ; )
  • Declaring and Manipulating Reference-Typed, Multi-Valued Attributes
• Diagrams
  • Software Development Process

• Separation of Concerns: Model vs. Tests

• Object Orientation: Observe, Model, Execute

• Java Data Types: Primitive

• Slides
  • Classes and Objects
  • Classes and Objects [4-up]
• Exercises
  • Tracing OO Program with Arrays and Reference Aliasing
  • PracticeTest0 Instructions (with links to starter and submission)
• Codes
  • In-Lab Demo (Sep 10): Helper Methods (PersonCollector)
  • Static vs. Non-Static Variables
• Diagrams
  • The Observe-Model-Execute Process
• Test Guides
  • Guide: Programming Test 0   [Last Updated: Sep 14]
  • Guide: Programming Test 1   [Last Updated: Sep 28]
• Lab1 Solution Walk-Through

     

• ProgTest1 Review Session (by Tiantian):  

• Java Data Types: Reference

• Parameters vs. Arguments

• Variable Scopes

• Tracing Object Creations (concrete version)

• Tracing OOP: Object Creations and Method Calls

• Variable Shadowing, Use of this

• Reference Aliasing

• Exercise: Reference Aliasing and Arrays

• Manual Management of Account IDs

• Use of Static vs. Non-Static Variables

• Use and Misuse of Static Varaibles

• Use of this: Marriage Example

• Referene-Typed Return Values

• Anonymous Objects

• Caller vs. Callee

• Tracing Chain of Method Calls via a Stack

• Catch-or-Specify Requirement

• To Handle or Not to Handle: Version 1

• Slides
  • Exceptions
  • Exceptions [4-up]
  • TDD with JUnit
  • TDD with JUnit [4-up]
• Codes
  • Error Handling: Circles & Banks (without exceptions)
  • Exceptions: To Handle or Not to Handle
  • Error Handling: Circles & Banks (with exceptions)
  • Testing of Counter
• Diagrams
  • Call Stack and Exceptions Handling: General
  • Call Stack and Exceptions Handling: Version 1
  • Call Stack and Exceptions Handling: Version 2
  • Call Stack and Exceptions Handling: Version 3
  • Workflow: Test-Driven Development (TDD) via Regression Testing
• Lab2 Solution Walk-Through

     

• To Handle or Not to Handle: Versions 2, 3

• Generalizing Exception Handling

• Execution Flows: Normal vs. Abnormal

• Examples: Circle, Bank, ParseInt

• Regression Testing

• Example Test 1: ValueTooLargeException Not Expected

• Example Test 2: ValueTooSmallException Expected

• 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

• Call by Value: Primitive vs. Reference Types

• Equality: == vs. equals

• Default Version of equals in Object

• Slides
  • Object Equality
  • Object Equality [4-up]
• Codes
  • Equality: Points and Persons
• Written Test 1
  • Guide: Written Test 1   [Last Updated: Oct 19]
  • WrittenTest1 Review Session:  
• Lab3 Solution Walk-Through

     

• Programming Test 2
  • Guide: Programming Test 2   [Last Updated: Oct 29]

• Call by Value: Array Indexing

• Deciding the Version of equals Method

• Short-Circuit Evaluation

• Overridden equals: Phases 1, 2, 3

• Static vs. Dynamic Types, Type Casting

• Overridden equals: Phase 4

• Exercises: short-circuit, logical implication

• JUnit: assertSame vs. assertEquals

• Course Syllabus (last updated: October 28; changed A2 and Test2 dates)
• iClicker Class Attendance Rules
• Slides on Administrative Issues
• Weekly Schedule (Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Tests, Exam) [Last Update: Oct 28 (changed A2 and Test2 dates)]

• Syllabus

• Professional Engineers: Code of Ethics

• Motivating Problems

• Slides
  • Lecture 1: DbC, Modularity, ADTs
  • Lecture 1: DbC, Modularity, ADTs [4-up]
  • Lecture 2: Asymptotic Analysis
  • Lecture 2: Asymptotic Analysis [4-up]
• Tutorials
  • Week 2 (Sep 12): 2D Array Utilities, Deriving/Proving Big-O 
  • Week 3 (Sep 19): Anaylyzing the Doubing Strategy of Dynamic Arrays  Task 1 Solution;  Task 2 Solution

• Motivating Proboems

• Design by Contracts (DbC)

• Clients vs. Suppliers

• DbC: Honouring the Contract

• Modularity, ADTs

• Asymptotic Upper Bound (Big-O)

• Defining Big-O using Predicate Logic

• Deriving Big-O: Triangular Sum

• Dynamic Arrays: Constant Increments

• Amortized RT: Constant Increments

• Deriving Sum of Geometric Seq.

• Height Balance Property

• Implementing BST in Java

• BST Operations: Search & Insert

• Tree Rotation, In-Order Traversal

• Slides
  • Lecture 3: Self-Balancing BST
  • Lecture 3: Self-Balancing BST [4-up]
• Codes
  • Generic, Binary Search Trees
• Tutorials
  • Week 4 (Sep 16): Self-Balancing BSTs 

• After Insertion: Left Rotation

• After Insertion: Right-Left Rotations

• BST Deletion: Cases 1 to 3

• Basic Definitions

• Properties: Degrees, Number of Edges

• Mathematical Induction on Vertices

• Slides
  • Lecture 4: Graph ADT [Incomplete; Last Update: Oct 20]
  • Lecture 4: Graph ADT [4-up]
• Tutorials
  • Week 7 (Oct 24): Assignment 1 Solution Walkthrough 

• Mathematical Induction: Degree Sum

• Paths, Cycles, Reachability

• (Spanning vs. Connected) Subgraphs

• Forest vs. Tree vs. Spanning Tree

• Graph Traversal: Depth-First Search (DFS)

• DFS on a Tree vs. Pre-Order Traverlsal

• Proof: Spanning Tree and |V| vs. |E|

• Tracing DFS using a Stack

• Graphs in Java: Edge List

• Adapting DFS for Graph Questions

• BFS: Marking Vertices and Edges

• BFS: First Example on a Tree

• Test 1 Review Q&A

• What EECS3342 is about - a Note from Your Instructor
• iClicker Class Attendance Rules
• Course Syllabus (last updated: September 3; subject to revision until September 16)
• iClicker Class Attendance Rules
• Slides on Administrative Issues
• Weekly Schedule (Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Tests, Exam) [Last Update: Sep 3]

• Syllabus

• Slides
  • Lecture 1a: Introduction
  • Lecture 1a: Introduction [4-up]
  • Lecture 1b: Review of Math
  • Lecture 1b: Review of Math [4-up]
• Lab2 Solution Walk-Through

     

• Test Guides
  • Guide: Programming Test   [Last Updated: Sep 29]
  • Guide: Written Test 1   [Last Updated: Oct. 15]

• Propositions: Commutativity vs. Short-Circuit Evaluation

• Implications: Contracts, Theorems

• Predicates: Universal vs. Existential Quantififiers

• Implication: Alternative Expressions in English

• Logical Quantifiers: Proof Strategies

• Sets: Enumerations vs. Comprehension

• Converting ∀ and ∃: Equational Style of Proofs

• Understanding the Choose Operator

• Power Sets

• Constructing All Relations

• Domain, Range, Inverse

• Image, Restrictions, Subtractions

• Relational Overriding

• Functional Property

• Partial Functions vs. Total Functions

• Rel Image vs. Func Application

• Modelling: Rev vs. Partial vs. Total Func

• Injection, Surjection, Bijection

• Modelling Decision: Formulating Arrays

• Correct by Construction

• State Space of a Model

• M0: Abstraction, Context, Machine

• Slides
  • Bridge Controller (Initial Model: M0)
  • Bridge Controller (Initial Model: M0) [4-up]

• Before-After Predicates

• Sequents: Syntax and Semantics

• Invariant Preservation: PO/VC as as Sequent

• Before-After Predicate & Invariant Preservation

• Formal Model Components

• WrittenTest1 Review Q&A

• Proof Obligation Rule: Invariant Preservation

• Inference Rule: Syntax and Semantics

• Sequent Proofs via Inference Rules

• Justifying the OR_L Inference Rule

• Interpreting Unprovable Sequents

• Revising M0: Adding Event Guards

• Initializing System, Establishing Invariant

• Deadlock Freedom: Intuition, PO, 1st Attempt

• Course Syllabus (last updated: May 28 on ProgTest1 & ProgTest2 dates)
• iClicker Class Attendance Rules
• Slides on Administrative Issues
• Weekly Schedule (Labs, Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Labs, Tests, Exam) [Last Update: May 28 on ProgTest1 & ProgTest2 dates]

• Syllabus

• Professional Engineers: Code of Ethics

• OOP Review Question: Attribute Types

• Lab Instructions
  • Lab 0 Part 1
  • Lab 0 Part 2
• Review Tutorials on OOP in Java
  •  Tutorial Videos Playlist
  •  iPad notes
• Required Written Notes
  • Inferring Classes/Methods from JUnit Tests ( ; )
  • Declaring and Manipulating Reference-Typed, Multi-Valued Attributes

• Separation of Concerns: model vs. tests

• OO: Observe-Model-Execute Process

• Java Data Types: Primitive vs. Reference

• Slides
  • Classes and Objects
  • Classes and Objects [4-up]
• Exercises
  • Tracing OO Program with Arrays and Reference Aliasing
  • PracticeTest0 Instructions (with links to starter and submission)
• Codes
  • In-Class Demo (May 13): Default vs. Customized Constructors
  • Static vs. Non-Static Variables
• Diagrams
  • The Observe-Model-Execute Process
• Test Guides
  • Guide: Programming Test 0   [Last Updated: May 14]
  • Guide: Programming Test 1   [Last Updated: June 5]

• NullPointerException

• Parameters vs. Arguments

• Scope of Variables

• Constructors: Default vs. Customized

• Variable Shadowing, Use of this

• Tracing OOP: Creations, Method Calls

• Reference Aliasing

• Anonymous Objects

• Tracing Arrays and Aliasing

• Static Variables

• Misuse of Static Variables

• Reference-Typed Return Values

• More Advanced Use of this

• Caller vs. Callee

• Tracing Chain of Method Calls via a Stack

• Cath-or-Specify Requirement

• To Handle or Not to Handle: Version 1

• Slides
  • Exceptions
  • Exceptions [4-up]
• Codes
  • Error Handling: Circles & Banks (without exceptions)
  • Exceptions: To Handle or Not to Handle
  • Error Handling: Circles & Banks (with exceptions)
• Diagrams
  • Call Stack and Exceptions Handling: General
  • Call Stack and Exceptions Handling: Version 1
  • Call Stack and Exceptions Handling: Version 2
  • Call Stack and Exceptions Handling: Version 3

• Catch-or-Specify Req.: Execution Flows

• Catch-or-Specify Req.: Call Stack

• To Handle or Not to Handle: Version 2, 3

• Example: Exceptions, Loops, Boolean Variable

• Example: Converting Strings to Integers

• Bounded Counter: Deriving Test Cases

• Slides
  • TDD with JUnit
  • TDD with JUnit [4-up]
• Codes
  • Testing of Counter
• Diagrams
  • Workflow: Test-Driven Development (TDD) via Regression Testing
• Lab1 Solution Walk-Through

     

• ProgTest1 Review Session (by Judy):  
• Lab2 Solution Walk-Through

     

• JUnit Test Method vs. Method Under Test

• TDD & Regression Testing

• JUnit Test: An Exception Expected or Not

• Console Errors vs. fail assertions

• Two vs. Single try-catch Blocks

• Patternizing Assertions using Loops

• Call by Value

• Slides
  • Call by Value, Object Equlaity
  • Call by Value, Object Equlaity [4-up]
• Codes
  • Equality: Points and Persons
• Written Test 1
  • Guide: Written Test 1   [Last Updated: June 18]
  • Post Your Questions in here (for the review session on June 25).
• WrittenTest1 Review Session (by Judy):  
• Lab3 Solution Walk-Through

     

• Guide: Programming Test 2   [Last Updated: July 4]

• Use of ==: Primitive vs. Reference

• equals: Default Version from Object

• equals: Overridden Version Phases 1, 2

• Static Type, Dynamic Type, Type Casting

• equals: Overridden Version Phases 3, 4

• Short-Circuit Evaluation

• Short Circuit Evaluation in equals

• JUnit: assertSame vs. assertEquals

• equals: Person vs. PersonCollector

• Design: Cohesion, Single-Choice Principle

• SMS: 1st Design Attempt

• Slides
  • Inheritance
  • Inheritance [4-up]
• Codes
  • Visibility: Classes vs. Attributes/Methods
  • SMS: With vs. Without Inheritance
• Diagrams
  • Inheritance Hierarchy: Students
  • Multi-Level Inheritance Hierarchy: Students
  • Multi-Level Inheritance Hierarchy: Smart Phones
• Exercises
  •  Challenge: Magic Card
  • Design Exercise: Student Management System
• WrittenTest2
  • Guide: Written Test 2   [Last Updated: July 22]
  • WrittenTest2 Review Session (by Mychaelynn):  
• Lab4 Solution Walk-Through

     

• Guide: Programming Test 3   [Last Updated: July 25]

• SMS: 2nd Design Attempt

• SMS: Use of Inheritance (extends, super)

• Static Types, Expectations, Polymorphism

• Dynamic Binding: Intuition

• Visbility: Classes, Attributes/Methods

• Multo-Level Inheritance Hierarchy

• Ancestors vs. Descendants

• Rules of Substitutions

• Polymorphism and Dynamic Binding

• Motivation of Type Cast

• Compilable Casts

• ClassCastException

• instanceof operator

• Safe Type Casts

• Polymorphic Method Calls

• Polymorphic Arrays

• Polymorphic Return Values

• Dynamic Binding and equals

• Solving Problems Recursively

• Factorial & Fibonacci: Ideas, Java, Tracing

• Recursion on Strings: Palindrome

• Slides
  • Recursion
  • Recursion [4-up]
• Required Readings
  • Solving Problems Recursively
• Exercises
  • A Past Lab on Recursion (Only look at the solution here after you attempt these exercises)
  • CodingBat: Recursion 1
  • CodingBat: Recursion 2
  • Tracing fib(4)
• Codes
  • Recursion
    • factorial
    • fibonacci
    • palindrome
    • reverseOf
    • numberOfOccurrences
    • allPositive
    • isSorted
  • Recursion
    • Tower of Hanoi
• Tutorial Session on Recursion
  •  Problems    iPad Notes  
  •  Starter Project    Solution Project

• Recursion on Strings: Examples

• Recursion on Arrays: Call by Value

• Recursion on Arrays: Examples

• Course Syllabus (last updated: May 6; subject to revision until May 19)
• Slides on Administrative Issues
• Weekly Schedule (Labs, Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Assignments, Tests, Exam)

• Syllabus & Administratives

• Semantic Domain

• Slides
  • Overview of Compilation
  • Overview of Compilation [4-up]
• Diagrams
  • What is a Compiler?
  • Analysis: Lexical, Syntactic, Semantic
  • Workflow of an Optimizer

• What is a Compiler?

• Inferring Dynamic Behaviour

• Design Principles

• Intermediate Representations (IRs)

• Front-End, Optimizer, Back-End

• Lexical, Syntactical, Semantic Analyses

• Scanning vs. Parsing

• Example Compiler: Obj-Rel Bridge

• Alphabets and Strings

• Slides
  • Lexical Analysis
  • Lexical Analysis [4-up]
  • Math Review: Logic, Sets, Relations
  • Math Review: Logic, Sets, Relations [4-up]
• Exercises
  • Minimizing DFAs

• Formulating String, Language, Problem

• Regular Language Ops: Union, Concat, Kleene Star

• RE Operators: Formal Meanings, Precedence

• Exercises: RE Constructions and Specification

• DFA: Introduction

• DFA: Formulation

• DFA δ: Recursive vs. Non-Recursive

• NFA: Motivation

• NFA: Processing Strings

• NFA Formulation: δ & Language

• NFA to DFA: Subset Construction (Lazy Evaluation)

• Subset construction: Algorithm

• ε-NFA: Motivation, Example, δ Function

• Regular Expression to ε-NFA

• ε-NFA: Formulation, Processing

• ε-NFA to DFA: Extended Subset Const.

• Minimizing DFA: Introduction

• Formulation: Extended Subset Construction

• Minimizing DFA

• Slides
  • Syntactic Analysis
  • Syntactic Analysis [4-up]
  • Math Review: Logic, Sets, Relations
  • Math Review: Logic, Sets, Relations [4-up]
  • Design Patterns: Composite & Visitor
  • Design Patterns: Composite & Visitor [4-up]
• Design Diagrams
  • Composite: Attempt 1
  • Composite: Attempt 2
  • Composite: Attempt 3
  • Composite: Architecture
  • Composite: Multiple Instantiations
  • Visitor: Composite Structures
  • Visitor: Attempt 1
  • Visitor: Architecture
• Exercises
  • Top-Down Parsing Algorithm Tracing:
  • Removing Left Recursions

• Regular Expression to Minimized DFA

• Implementing a Scanner

• Parser in Context

• Context Free Grammar (CFG): Intro

• Project Specification

• CFG Derivations: LMD vs. Parse Trees

• Static Types, Polymorphic Assignments

• Static vs. Dynamic Types, Dynamic Binding

• Design Attempts for Recursive System

• Composite Design Pattern

• Tracing Composite

• Visitor: Design Rationales

• Visitor: Tracing Double Dispatch

• Comparing Two Versions of CFGs

• Witness String of CFG Ambiguity

• RE to CFG, DFA to CFG

• CFG: Formal Definition, Case Study (V3)

• CFG Derivations: LMD vs. RMD

• Ambiguity of CFG

• Discovering Derivations: Top-Down vs. Bottom-Up

• Top-Down Parsing (TDP) Algorithm: Left-Recursive Grammar

• TDP Algorithm: Tracing Exercise

• Removing Left Recursions: Algorithm

• Tracing: Removing Direct LRs

• Removing LRs: Indirect LRs

• Building AST Recursively: Variable Args

• FIRST Set: Intuition

• Backtrack-Free Parsing: Motivation

• FIRST, FOLLOW, START sets

• Recursive-Descent, LL(1) Parsers

• Bottom-Up Parsing (BUP)

• Course Syllabus (last updated: Jan 7; subject to revision until Jan 20)
• iClicker Class Attendance Rules
• Slides on Administrative Issues
• Weekly Schedule (Labs, Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Labs, Tests, Exam)

Playlists of All Lecture Recordings: Section X and Section Z

All Slides

All Slides (4-up)

All iPad Notes: Section X and Section Z

• Course Syllabus

• Data Structures, Algorithms, Analysis

• Profession Engineering: Code of Ethics

• Slides
  • Recursion (Part 1)
  • Recursion (Part 1) [4-up]
• Exercises
  • Recursion: splitArray (starter: ;  solution: )
  • Recursion: splitArrayHarder (starter:  solution:  tutorial:  iPad Notes: )
• Recommended Study on Recursion Basics
  • Week 12 of EECS2030-F21
  • Lecture 24, Sec. E of EECS2030-F24 (Tower of Hanoi)
• Extra Tutorial Session on Recursion
  •  Problems    iPad Notes  
  •  Starter Project    Solution Project
• Recommended Study on Call by Value
  • Week 6 (Parts A1 to B3) of EECS2030-F21

• Data Structures: Motivating Problems

• References to Recursion Bascis

• Advanced Recursion Example: splitArray

• splitArray: Java Implementation

• splitArray: Tracing on Paper (recursion tree)

• splitArray: Tracing on Eclipse debugger

• Limitations of Experiments

• Primitive Operations (POs)

• Counting Primitive Operations: findMax

• Slides
  • Asymptotic Analysis of Algorithms (Last Updated: Jan 22)
  • Asymptotic Analysis of Algorithms [4-up]

• From Absolute RT to Relative RT

• Approximating RT Functions

• Asymptotic Upper Bound (Big-O): Formal Definition

• Big-O: Predicate Definition, Properties, Examples

• Correct vs. Accurate Asymptotic Upper Bounds

• Deriving U.B. from Code: Basic Examples (Sec. Z)

• Deriving U.B. from Code: More Advanced Examples

• Inserting into an Array

• Sorting Orders

• Slides
  • Arrays vs. Linked Lists (Last Updated: Feb 13)
  • Arrays vs. Linked Lists [4-up]
• Source Code
  • Selection Sort vs. Insertion Sort
  • Singly Linked Lists of Strings
  • Generic Linked Lists
• Solutions to Exercises on DLLs
  • DLL: addFirst, addLast, addAt (using addBetween)
  • DLL: removeFirst, removeLast, removeAt (using remove)
• Diagrams
  • A Chain of Linked Nodes
  • Head of a Singly-Linked List of Strings

• Sorting Orders and Exercise

• Selection Sort vs. Insertion Sort

• Exercise: Mixing Insertion & Selection Sorts

• SLL: Visual Introduction and Operations

• SLL in Java: Node vs. SinglyLiniedList

• SLL: List Constructions

• SLL: getSize and getTail

• Trading Space for Time: tail and size

• SLL: addFirst, removeFirst, addLast

• SLL: getNodeAt, insertAt

• SLL vs. Arrays

• DLLs: Extensions

• DLLs: addBetween, remove

• Linear vs. Non-Linear Data Structures

• General Trees: Terminology

• Slides
  • General Trees ADT, Binary Trees
  • General Trees ADT, Binary Trees [4-up]
  • Recursion: Part 2
  • Recursion: Part 2 [4-up]
  • Binary Search Trees
  • Binary Search Trees [4-up]
  • Balanced BSTs, Priority Queues, Heaps
  • Balanced BSTs, Priority Queues, Heaps [4-up]
  • Wrap-Up
  • Wrap-Up [4-up]
• Exercises
  • Computing Height Recursively in Java
• Source Code
  • Generic, General Trees
  • Binary Search, MergeSort, QuickSort
  • Generic, Binary Search Trees
• Guide: Written Test
• WrittenTest Review Session:  
• ProgTest2 Review Session:    
• Final Exam
  • Example Exam Questions
  • Solution to Example Exam Questions
  • Exam Review Session:  

• Recursive Definitions: General vs. Binary Trees

• Initializing a Generic Array

• Trees in Java: Constructions, Depth, Tracing

• Binary Trees: Math Properties

• Tree Traversals

• Bounding Internal vs. External Nodes

• Proper Binary Trees

• Binary Search: Idea, Java

• Binary Search: Tracing, Recurrence Relation

• MergeSort: Ideas, Java, Tracing

• MergeSort: Recurrence Relation

• QuickSort: Ideas, Java, RT

• BST: Search Property

• BST: Sorting Property

• BST in Java: BSTNode Construction

• BST: Searching, Insertions

• Height Balance Property

• Priority Queues: Introduction

• Priority Queues: List Implementations

• Heaps: Structural, Relational Properties

• Heaps: Insertions, Deletions

• Heap Sort

•  Abstract Data Types (ADTs), Interfaces

•  Stack ADT: Last In First Out (LIFO)

•  Array-Based Implementation of Stack

•  SLL-Based Implementation of Stack

•  Polymorphic Stacks

• Slides
  • ADTs, Stacks, Queues
  • ADTs, Stacks, Queues [4-up]
  • Balanced BSTs, Priority Queues, Heaps (Slides 21, 22 - 26, 29 - 30)
  • Balanced BSTs, Priority Queues, Heaps [4-up]
• Source Code
  • Generic Stacks
  • Generic Queues

•  Queue ADT: First In First Out (FIFO)

•  Array- vs. SLL-Based Imp. of Queue

•  Circular Arrays: Empty, Insertions

•  Circular Arrays: Deletions, Insertions

•  The Double-Ended Queue (Deque) ADT

•  BST Deletions: Cases 1 to 3

•  BST Deletions: Case 4

•  Top-Down Heap Construction

•  Bottom-Up Heap Construction

•  Array-Based Implementation of BT

• Course Syllabus (last updated: January 7; subject to revision until January 20)
• iClicker Class Attendance Rules
• Slides on Administrative Issues
• Weekly Schedule (Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Tests, Exam)

Playlist of All Lecture Recordings

All Slides

All Slides (4-up)

All iPad Notes

• Syllabus

• Safety-Critical Systems: Examples

• Slides
  • Lecture 1a: Introduction
  • Lecture 1a: Introduction [4-up]

• Lab1 Guidance

• Verification vs. Validation

• Safety- vs. Mission-Critical

• Software Development Process, Assurance Cases

• Correct by Construction, State Space

• Counter Problem: Theorem Proving (model)

• Counter Problem: Theorem Proving (POs, proofs)

• Reachability Graph

• Commutativity vs. Short-Circuit Evaluation

• Formulating the Model Checking Problem

• Alternative Ways for Describing an Implication

• Theorems: Propositional Logic

• Slides
  • Lecture 1b: Math Review
  • Lecture 1b: Math Review [4-up]
• Required Background Study
  • Recall: System Variant (see from 41:39)
• Test Guides
  • Guide: Programming Test 1

• ∀ vs. ∃: Syntax, Meaning, Examples

• ∀ vs. ∃: Proof Strategies

• Switching between ∀ and ∃

• Finite Reachability Graph with Cycles

• Atomic Updates with a Single Label

• Algorithm Contracts: Precondition, Postcondition

• Identifying (Non-)Atomicity in State Graph

• Recall: System Variant (from EECS3342)

• Encoding and Checking Variant in TLA+

• Implementation Correctness

• Completeness of Contracts (Pre- vs. Post-condition)

• Slides
  • Lecture 2: Model Checking
  • Lecture 2: Model Checking [4-up]
  • Lecture 3: Program Verification
  • Lecture 3: Program Verification [4-up]
• Videos
  Correctness Conditions of Loops (53:11)
• TLA Modules
  • Syntax of Loop Specification
• Exercises
  • Solution: X,F,G
  • Solution: U,W,R
  • Solution: Loop Correctness
  • Example Exam Questions
  • Solution to Example Exam Questions
• Guide: Written Test 1
• Guide: Written Test 2
• Guide: Final Exam [Last Updated: Apr. 2]
• WrittenTest1 Review Session:  
• Guide: Programming Test 2
• Exam Review Session:  

• Nested Quantification

• Verification Methods: Proof- vs. Check-Based

• State Graph vs. (Computation) Paths

• Lab2 Solution Walkthrough

• LTL Grammar: Top-Down Derivation

• LTL Operator Precedence

• Parse Trees, LMDs, RMDs

• Subformula

• Labeled Transition System (LTS)

• Paths, Path Suffixes

• Unfolding/Unwinding Paths

• Satisfaction Relations: Path vs. Model

• Formulations: X, G, F

• Model Satisfaction

• Path vs. Model Satisfactions: X, G, F

• Nesting Temporal Operators: FGφ

• Exercise: Gφ vs. FGφ

• Parsing Property

• Exercise: Fφ ⇒ FGφ

• Nesting: GFφ

• Exercise: Gφ vs. GFφ

• Exercise: FGφ ⇒ GFφ

• Temporal Operators: U, W, R

• Formulating English Sentences in LTL

• Exercises: U, W, R

• Stronger vs. Weaker Assertions

• Weakest Precondition: Predicate Transformer

• wp rules: Assignments, Conditionals

• wp Rule: Sequential Composition

• Loop Invariant vs. Loop Variant

• Correctness Conditions of Loops

• Course Syllabus (last updated: September 5; subject to revision until September 18)
• iClicker Class Attendance Rules
• Slides on Administrative Issues
• Weekly Schedule (Labs, Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Labs, Tests, Exam) [Last Update: Oct. 15]

Playlists of All Lecture Recordings: Section E and Section F

All Slides

All Slides (4-up)

All iPad Notes: Section E and Section F

• Syllabus

• Professional Engineers: Code of Ethics

• OOP Review Question: Attribute Types

• Lab Instructions
  • Lab 0 Part 1
  • Lab 0 Part 2
• Review Tutorials on OOP in Java
  •  Tutorial Videos Playlist
  •  iPad notes
• Required Written Notes
  • Inferring Classes/Methods from JUnit Tests ( ; )
  • Declaring and Manipulating Reference-Typed, Multi-Valued Attributes

• OO: Observe-Model-Execute Proces

• Java Data Types (Primitive vs. Reference)

• NullPointerException

• Parameters vs. Arguments

• Scope of Variables

• Slides
  • Classes and Objects (up to Slide 74) [Last Update: Sep. 23]
  • Classes and Objects [4-up]
• Exercises
  • Tracing OO Program with Arrays and Reference Aliasing
• Codes
  • In-Class Demo (Sep 10; Sec. F): Default vs. Customized Constructors
  • In-Lab Demo (Sep 11; Sec. E): Helper Methods (PersonCollector)
  • In-Lab Demo (Sep 11; Sec. F): Helper Methods (Point)
  • In-Class Demo (Sep 12; Sec. E & F): Accessors vs. Mutators
  • In-Lab Demo (Sep 18; Sec. E): Programming Pattern
  • In-Lab Demo (Sep 18; Sec. F): Programming Pattern
  • Static vs. Non-Static Variables
• Diagrams
  • The Observe-Model-Execute Process

• Use of this for Attribute Access

• Tracing OO Code

• Use of Mutators vs. Accessors

• Design of Method Parameters (Sec. F)

• Reference Aliasing (Sec. F)

• Use of Mutators vs. Accessors (Section E)

• Design of Method Parameters (Sec. E)

• Arrays and Reference Aliasing

• Reference-Typed Return Values (Sec. F)

• Reference-Typed Return Values (Sec. E)

• Anonymous Objects

• Use of this: Marriage Example

• Static Variables (Sec. F)

• 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

• Slides
  • Classes and Objects (Slides 75 - 82)
  • Classes and Objects [4-up]
  • Exceptions
  • Exceptions [4-up]
• Codes
  • Error Handling: Circles & Banks (without exceptions)
  • Exceptions: To Handle or Not to Handle
  • Error Handling: Circles & Banks (with exceptions)
  • In-Lab Demo (Sep 25; Sec. E): Incremental Development for Lab1
  • In-Lab Demo (Sep 25; Sec. F): Incremental Development for Lab1
  • In-Class Demo (Sep 26; Sec. E &F): Exceptions: To Handle or Not to Handle (V1)
  • In-Class Demo (Oct 1; Sec. E &F): Exceptions: To Handle or Not to Handle (V2, V3)
• Diagrams
  • Call Stack and Exceptions Handling: General
  • Call Stack and Exceptions Handling: Version 1
  • Call Stack and Exceptions Handling: Version 2
  • Call Stack and Exceptions Handling: Version 3
• Lab1 Solution Walk-Through

     

• Test Guides
  • Guide: Written Test 1   [Last Updated: Sep. 27]
  • Guide: Programming Test 1   [Last Updated: Sep. 27]
• Review Sessions
  • WrittenTest1:    

• 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)

• 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)

• 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

• Slides
  • TDD with JUnit
  • TDD with JUnit [4-up]
• Codes
  • Testing of Counter
• Diagrams
  • Workflow: Test-Driven Development (TDD) via Regression Testing
• Review Sessions
  • ProgTest1:    
• Test Guides
  • Guide: Programming Test 2   [Last Updated: Oct. 20]
• Lab2 Solution Walk-Through

     

• 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)

• equals Method: Default vs. Overridden

• Overriding equals Method: Phases 1 - 3

• Static Type, Dynamic Type, Type Casting

• Slides
  • Object Equality
  • Object Equality [4-up]
• Codes
  • Equality: Points and Persons
•  Challenge: Magic Card

• Overriding equals Method: Phase 4

• JUnit: assertSame vs. assertEquals

• Short-Circuit Evaluation: && vs. || (Sec. F)

• Applying Short-Circuit Evaluation to equals

• equals: Person vs. PersonCollector

• equals: PersonCollector

• Call by Value

• Slides
  • Aggregation and Composition
  • Aggregation and Composition [4-up]
• Lab3 Solution Walk-Through

     

• Modelling: Aggregation vs. Composition

• Dot Notation Exercise

• Copy Constructor, Shallow Copy

• Composition: Deep Copy

• Design Attempts without Inheritance

• Programming with Inheritance: Use of extends, super

• Slides
  • Inheritance
  • Inheritance [4-up]
• Required Readings
  • Static Types, Expectations, Dynamic Types, and Type Casts
• Codes
  • Visibility: Classes vs. Attributes/Methods
  • SMS: With vs. Without Inheritance
  • In-Lab Demo (Nov 6; Sec. EF): Programming with Inheritance
• Diagrams
  • Inheritance Hierarchy: Students
  • Multi-Level Inheritance Hierarchy: Students
  • Multi-Level Inheritance Hierarchy: Smart Phones
• Test Guides
  • Guide: Written Test 2   [Last Updated: Nov. 8]
  • Guide: Programming Test 3   [Last Updated: Nov. 13]
• Review Sessions
  • WrittenTest2:  
• Lab4 Solution Walk-Through

     

• Implementing a Child Class: Principles

• Visibility: Class, Attribute/Method

• Static Types: Expectations

• Polymorphism: Intuition

• Dynamic Binding: Intuition

• Ancestors vs. Descendants, Expectations

• Variable Substitutions

• Polymorphism vs. Dynamic Binding

• Type Casts: Named vs. Anonymous

• Type Casts: Compilable vs. ClassCastException Free

• Type Casts: Exercise

• instanceof operator

• Polymorphic Method Parameters

• Polymorphic Arrays

• Polymorphic Return Values

• Type-Checking Rules

• Solving Problems Recursively

• Tracing: Factorial, Fibonacci Sequence

• Recursion on Strings: Palindrome, Reversal

• Exam Info

• Slides
  • Recursion [Last Updated: Dec. 2]
  • Recursion [4-up]
  • Wrap-Up
  • Wrap-Up [4-up]
• Required Readings
  • Solving Problems Recursively
• Exercises
  • A Past Lab on Recursion (Only look at the solution here after you attempt these exercises)
  • CodingBat: Recursion 1
  • CodingBat: Recursion 2
  • Tracing fib(4)
• Codes
  • Recursion
    • factorial
    • fibonacci
    • palindrome
    • reverseOf
    • numberOfOccurrences
    • allPositive
    • isSorted
  • Recursion
    • Tower of Hanoi
• Tutorial Session on Recursion (December 1)
  •  Problems    iPad Notes  
  •  Starter Project    Solution Project

• Recursion on Strings: occurrencesOf

• Recursion on Arrays: Call by Value

• Recursion on Arrays: allPositive, isSorted

• Tower of Hanoi: Specification, Legend

• Tower of Hanoi: Java, Tracing

• Tower of Hanoi: Running Time

• Course Wrap-Up

• Console Tester vs. JUnit Test

• Expectation: Ancestor vs. Descendent

• Recursion: strDist

• Polymorphism, Dynamic Binding, Type Casts

• Guides
  • Guide: Final Exam   [Last Updated: Dec. 2]
• Exercises
  • Example Questions
  • Solutions to Example Questions
  • Annotated Example Questions

• Course Syllabus (last updated: September 5; subject to revision until September 18)
• iClicker Class Attendance Rules
• Slides on Administrative Issues
• Weekly Schedule (Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Tests, Exam) [Last Update: Oct. 15]

Playlist of All Lecture Recordings

All Slides

All Slides (4-up)

All iPad Notes

• Syllabus

• Formal Methods: Theorem Proving vs. Model Checking

• Slides
  • Lecture 1a: Introduction
  • Lecture 1a: Introduction [4-up]

• Safety-Critical vs. Mission-Critical

• Professional Engineers: Code of Ethics

• Safety Property/Invariant

• Verification vs. Validation

• Model-Based Development

• Propositional Logic

• Implications: Contract Analogy

• Implications: Alternative Expressions

• Predicate Logic: Quantifiers

Part 1:

Part 2:

• Slides
  • Lecture 1b: Math Review
  • Lecture 1b: Math Review [4-up]
• Test Guides
  • Guide: Programming Test 1   [Last Updated: Oct. 1]
  • Guide: Written Test 1   [Last Updated: Oct. 14]
• Lab2 Solution Walk-Through

     

• ProgTest1 Review Q&A

     

• WrittenTest1 Review Q&A

     

• Logical vs. Programming Operators

• Empty Range vs. Empty Array

• Proof Strategies of Quantifiers

• Logical Quantifiers: Conversions

• Set Comprehension

• Relating Sets vs. Postconditions

• Power Set: Cardinality

• Power Set: Enumeration

• Incompleteness of Postcondition

• Interpreting the choose operator

• Cross Product

• Relation

• Constructing the Set of All Possible Relations

• Domain, Range, Inverse

• Relational Image

• Domain/Range Restrictions/Subtractions

• Relational Overriding: Formal Definition

• Algebraic Properties of Relational Ops.

• Lab2: Celebrity_0

• Functional Properties

• Partial Functions vs. Total Functions

• Relational Image vs. Function Application

• Well-Definedness of Function Application

• Modelling Decision: Rel vs. Pfun vs. Tfun

• Injective Properties

• Surjective Properties

• Bijective Properties

• Exercise: Injection vs. Surjection vs. Bijection

• 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

• Slides
  • Lecture 2: Bridge Controller [Last Update: Nov. 21]
  • Lecture 2: Bridge Controller [4-up]
• Test Guides
  • Guide: Programming Test 2   [Last Updated: Oct. 30]
  • Guide: Written Test 2
• Notes
  • Example Inference Rules - 1
  • Example Inference Rules - 2
  • Example Inference Rules - 3
  • Example Inference Rules - 4
• Sequent Proofs
  • Proofs of DLF: Initial Model
  • Proofs of Refinement: 1st Refinement (old events)
  • Proofs of Refinement: 1st Refinement (new events)
  • Proofs of Refinement: 2nd Refinement
• WrittenTest2 Review Q&A

     

• Event Action vs. Before-After Predicate

• Invariant Preservation: Before- vs. After-States

• Sequents: Syntax and Semantics

• PO of Invariant Preservation: Sketch

• PO of Invariant Preservation: Sequents

• Inference Rules: Syntax and Semantics

• Inference Rules: Proof Steps

• Interpreting Unprovable Sequents

• Revising M0: Adding Event Guards

• Re-Generating/Re-Proving PO Sequents

• Invariant Establishment

• Deadlock Freedom

• Interpreting Unprovable Sequent from DLF

• First Refinement: Added Concreteness, State Space

• Abstract vs. Concrete Transitions

• Stronger vs. Weaker Predicates

• Guard Strengthening

• Discharging Guard Strengthening POs

• Invariant Preservation: Concrete Events

• Commuting Diagram: Simulation

• New Events: IL_in, IL_out

• skip event

• Livelock, Divergence

• Variant vs. Invariant

• Proof Obligations of System Variant

(Recording Failed. Please see three W'22 recordings.)

• Relative Deadlock Freedom

• 2nd Refinement: Variables & Invariants

• Exam Info

• 2nd Refinement: Splitting Guards

• Adding Invariant to Prove INV

• Adding Actions

• Splitting Events

• Preventing Livelock/Divergence

• Proving Livelock/Divergence Freedom

• Sequent Proof Strategy

• Applying NOT_L Inference Rule

• Proving/Disproving System Variant

• Impacting Deadlock Freedom Condition

• Guide: Final Exam [Last Updated: Dec. 7]
• Example Exam Questions
• Solution to Example Exam Questions

• Course Syllabus (last updated: January 9; subject to revision until January 23)
• Slides on Administrative Issues
• Weekly Schedule (Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Tests, Exam) [Last Updated: Feb. 23]

Playlist of All Lecture Recordings

All Slides

All Slides (4-up)

All iPad Notes

• Syllabus & Administratives

• Using Data Strutures: Searching

• Slides
  • Recursion (Part 1)
  • Recursion (Part 1) [4-up]
• Recommended Study on Recursion Basics
  • Week 12 of EECS2030-F21
• Recommended Study on Call by Value
  • Week 6 (Parts A1 to B3) of EECS2030-F21

• Introduction: Searching and More

• Recursion Basics: Resources, Call by Value

• Tracing Recursion on an Array

• Problems, Algorithms, Data Structures

• Measuring Efficiency of an Algorithm

• Measuring Running Time via an Experiment

• Slides
  • Asymptotic Analysis of Algorithms
  • Asymptotic Analysis of Algorithms [4-up]
  • Arrays vs. Linked Lists (up to Slide 4)
  • Arrays vs. Linked Lists [4-up]
• Guide: Written Test 1

• Experimental Analysis: Pros and Cons

• Counting Primitive Operations

• Running Time: Absolute vs. Relative

• Asymptotic Upper Bounds: Definitions

• Guessing and Proving for Big-O

• Visualizing Proofs of Big-O

• Big-O: Justifying Proof Strategies, Properties

• Big-O: More Examples

• Big-O: Applications to Java Solutions

• Deriving Big-O: Nested Loops

• Deriving Big-O: Inserting into Arrays

• Sorting Problem, Sorting Orders

• Selection vs. Insertion Sort: Sketch

• Deriving Big-O: Sketch vs. Code

• Linked Lists: Introduction

• Slides
  • Arrays vs. Linked Lists
  • Arrays vs. Linked Lists [4-up]
• Source Code
  • Selection Sort vs. Insertion Sort

• Counting Primitive Operations

• Approximating Running Time

• Loop with LogN Iterations

• Absolute Indexing vs. Relative Positioning

• SLL in Java: Node, SinglyLinkedList

• SLL in Java: List Construction, getSize, getTail

• Slides
  • Arrays vs. Linked Lists
  • Arrays vs. Linked Lists [4-up]
  • Java Interfaces
  • Java Interfaces [4-up]
• Source Code
  • Generic Linked Lists
  • Singly Linked Lists of Strings
  • Interface in Java (Points)
• Diagrams
  • A Chain of Linked Nodes
  • Head of a Singly-Linked List of Strings
• Guide: Programming Test 1

• SLL operations: add/remove First/Last

• SLL operations: accessing/inserting into Middle

• SLL operations: insertBefore vs. insertAfter

• Performance: Arrays vs. SLLs

• Doubly-Linked Lists: Introduction, addBewteen

• Finishing off DLL (after addBetween)

  •   DLL: addFirst, addLast, addAt

  •   DLL: Removing an Arbitrary Node

  •   DLL: removeFirst, removeLast, removeAt

  •   Arrays vs. SLLs vs. DLLs, Exercises

• Implementing Interfaces in Java

  •   Interface: 2D Points Design Problem

  •   Interface: Using interface and implements

  •   Exploring Dynamic Binding in Eclipse

• Abstract Data Types (ADTs)

• LIFO Stack

• Stack Interface, ArrayStack, LinkedStack

• Slides
  • Stacks and Queues
  • Stacks and Queues [4-up]
• Source Code
  • Generic Stacks
  • Generic Queues

• Polymorphism vs. Dynamic Binding

• Polymorphic Stack

• Reversing, Matching, Postfix Notation

• FIFO Queue

• Queue Interface, ArrayQueue

•   Resources, Learning Outcomes

•   Binary Search: Ideas

•   Binary Search: Implementation in Java

•   Binary Search: Tracing Recursions

•   RT of a Linear, Recursive Algorithm

•   RT of the Recursive Binary Search

• Implementing a Queue via Two Stacks

• Linear vs. Non-Linear Data Structures

• General Trees: Terminology

• Slides
  • General Trees ADT, Binary Trees
  • General Trees ADT, Binary Trees [4-up]
• Source Code
  • Generic, General Trees
• Guide: Written Test 2

• Edge, Path, Depth, Height

• Generic Trees in Java

• Computing Depth and Height Recursively

• Binary Trees (BTs)

• Complete vs. Full vs. Proper BTs

• Mathematical Properties of BTs

•  MergeSort: Ideas

•  MergeSort: Java Implementation

•  MergeSort: Tracing Recursive Calls

•  MergeSort RT - Recursion Tree

•  MergeSort RT - Recurrence Relation

•  QuickSort: Ideas

•  QuickSort: Implementation, Tracing

•  QuickSort RT: Worst-Case vs. Best Case

• Proper BTs, Mathematical Induction

• Tree Traverals: Pre-Order, Post-Order, In-Order

• Binary Search Trees (BSTs): Introduction

• Slides
  • General Trees ADT, Binary Trees
  • General Trees ADT, Binary Trees [4-up]
  • Binary Search Trees
  • Binary Search Trees [4-up]
• Source Code
  • Generic, General Trees
  • Generic, Binary Search Trees
• Guide: Programming Test 2

• Binary Search Tree (BST)

• BST: Search vs. Sorting Properties

• BST: Generic Implementation in Java

• BST: Searching

• BST: Insertions

• BST: Deletions (Cases 1 & 2)

• BST: Deletions (Cases 3 & 4)

• Height-Balance Property

• Priority Queues, List-Based Implementation

• Slides
  • Binary Search Trees
  • Binary Search Trees [4-up]
  • Priority Queues, Heaps, Heap Sort
  • Priority Queues, Heaps, Heap Sort [4-up]
  • Wrap-Up
  • Wrap-Up [4-up]
• Guide: Final Exam [Last Updated: Apr. 6]
• Example Exam Questions
• Solution to Example Exam Questions

•  Heaps: Properties and Examples

•  Insertions and Up-Heap Bubbling

•  Deletions and Down-Heap Bubbling

•  Top-Down Heap Construction

•  Bottom-Up Heap Construction

•  Heap Sort Algorithm

•  Array-Based Implementation of BT

• Course Syllabus (last updated: January 9; subject to revision until January 23)
• Slides on Administrative Issues
• Weekly Schedule (Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Tests, Exam) [Last Updated: Feb. 23]

Playlist of All Lecture Recordings

All Slides

All Slides (4-up)

All iPad Notes

• Syllabus & Administratives

• Introduction: SCS, Code of Ethics

• Slides
  • Lecture 1a: Introduction
  • Lecture 1a: Introduction [4-up]

• Safety- vs. Mission-Critical

• Industrial Standards

• Building Right Product vs. Building Product Right

• Model-Based Development

• Logical vs. Programming Operators

• Implications: Alternative Expressions

• Propositional Axioms and Theorems

• Logical Quantifiers: Syntax

• Slides
  • Lecture 1b: Review on Math
  • Lecture 1b: Review on Math [4-up]
• Guide: Written Test 1

• Logical Quantifications: Proof Strategies

• Sets: Basic Operations, Power Sets

• Bi-Directional Subset Relations

• Cardinality of Power Set

• Constructing a Relation

• Relational Operations

• Algebraic Properties of Relations

• Functional Property

• Algebraic Properties of Relations

• Functions: Partial vs. Total

• Making Modelling Decisions

• Injection vs. Surjection vs. Bijection

• Modelling Decisions on Arrays

• Lab1 Solution Highlights

• Correct by Construction

• State Space: Axiom vs. Invariant

• Bridge Controller: Requirements Doc.

• Initial Model: State Space

• Slides
  • Lecture 2: Bridge Controller (last updated: Mar. 7)
  • Lecture 2: Bridge Controller [4-up]
• Notes
  • Example Inference Rules - 1
  • Example Inference Rules - 2
  • Example Inference Rules - 3
  • Example Inference Rules - 4
• Inference Rule Justifications
  • Proof of Inference Rule OR_L (Slide 24)
  • Proof of Inference Rule OR_R (Slide 83)
• Sequent Proofs
  • Proofs of DLF: Initial Model
  • Proofs of Refinement: 1st Refinement (old events)
  • Proofs of Refinement: 1st Refinement (new events)
  • Proofs of Refinement: 2nd Refinement
• Guide: Programming Test 1
• Lab2 Solution Walk-Through

     

• Guide: Written Test 2
• Guide: Programming Test 2
• Guide: Final Exam [Last Updated: Apr. 6]
• Example Exam Questions
• Solution to Example Exam Questions

• Invariant: Establishment and Preservation

• Finding Witness Traces for Invariant Violation

• Before-After Predicates

• Sequents: Syntax, Semantics, Sketching Invariant PO

• Invariant Preservation: Sequent

• Inference Rules

• Conducting Sequent Proofs

• Example Test Questions

• Partial vs. Total Functions

• Set Operations

• Proving Invariant Preservation

• Fixing Model: Adding Guards

• Deadlock Freedom

• Iterative Process of Proving Model Correctness

• Formulating Deadlock Freedom (DLF) PO

• Proving Sequent Formulating DLF Rule

• 1st Refinement: Abstraction

• 1st Refinement: State Space, Invariants

• 1st Refinement: Events, Guards, Actions

• 1st Refinement: Guard Strengthening

• Guard Strengthening: Intuition, Formulation, Proofs

• 1st Refinement: Invariant Preservation

• Relating Concrete and Abstract Transitions

• 1st Refinement: Concrete, New Events

• Relating New Events to the skip Event

• Example Test Questions

• OR_L rule

• 1st Refinement: New Events, Divergence/Livelock

• System Variant (vs. Invariant), Proof Obligations

• 1st Refinement: Relative Deadlock Freedom

• 2nd Refinement: Abstraction

• 2nd Refinement: State Space, Invariants

• 2nd Refinement: Abstract vs. Concrete Guards

• 2nd Refinement: Example Inference Rules

• 2nd Refinement: Invariant Preservation

• Abstract vs. Concrete Transitions

• Divergence/Livelock, Variants

• Exam Info

•  Adding Actions to New Events

•  Analyzing Unprovable Sequent

•  Splitting Old, Concrete Events

•  Divergence of New Events

•  Regulating New Event Occurrences

•  Measuring New Event Occurrences

•  DLF, Provably Correct Second Refinement

•  FTP Intro, RD, Refinement Strategy

•  Initial Model: State Space

•  Initial Model: Events

•  Initial Model: Invariant Establishment

•  Initial Model: Invariant Preservation

•  1st Refinement: Asynchrony, Gradualness

•  Concrete State Space and Invariants

•  Concrete Events: Old vs. New

•  Proofs and Exercises

• Course Syllabus (last updated: January 9; subject to revision until January 23)
• Slides on Administrative Issues
• Weekly Schedule (Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Tests, Exam) [Last Updated: Feb. 23]

Playlist of All Lecture Recordings

All Slides

All Slides (4-up)

All iPad Notes

iPad Tempalte (Exercises)

• Syllabus & Administratives

• Theorem Proving vs. Model Checking

• Slides
  • Lecture 1a: Introduction
  • Lecture 1a: Introduction [4-up]

• Safety- vs. Mission-Critical

• Code of Ethics for Profession Engineers

• Industrial Standards

• Building Right Product vs. Building Product Right

• Catching Defects at the Design Phase

• Model-Based Development: 3342 vs. 4315

• TLA+ Resources

• Propositional vs. Programming Operators

• Slides
  • Lecture 1b: Review on Math
  • Lecture 1b: Review on Math [4-up]

• Implications: Analogy, Alternative Expressions

• Propositional Theorems

• Logical Quantifications: Analogy, Exercises

• Proving/Disproving Logical Quantifiers

• Using Model Checking to Solve Puzzles

• Conversions between Quantifiers

• Equational Style Proofs

• Model Checking: Introduction

• Linear-time Temporal Logic (LTL): Syntax

• Operator Precedence, Symbols

• Slides
  • Lecture 2: Model Checking
  • Lecture 2: Model Checking [4-up]
• Guide: Written Test 1
• Guide: Programming Test 1
• Guide: Written Test 2

• Practical Knowledge about Parsing

• Drawing Parse Trees

• Left-Most Derivations (LMD)

• Parse Trees vs. LMDs vs. RMDs

• Deriving Subformulas

• (Optional) The Dangling Else Problem

• Labelled Transition System (LTS)

• Examples: LTS Formulation

• Paths, Unwinding Paths

• Path Satisfaction: X, G, F

• Path vs. Model Satisfactions

• Proving vs. Disproving Strategies

• Unary Temporal Operators: X, G, F

• Proving vs. Disproving the Unary Temporal Operator (F, G)

• Parsing LTL Formula Strings

• Model Satisfaction: Nested LTL Operators

• FGϕ

• Fϕ ⇒ FGϕ

• Fϕ ⇒ FGϕ

• Formulation, Proving vs. Disproving Strategies, Exercises

• PlusCal Assertions: getAllSuffixes, getRightShifts

• GFϕ

• GFϕ ⇒ GFϕ

• LTL Operators: Until, Weak Until, Release

• Exercises: Model Satisfaction (U, W, R)

• Exercises: Formulating Natural Language in LTL

• Showing Postcondition being Inappropriate

• Clarifying U vs. W vs. R Operators

• Stronger vs. Weaker Assertions

• Relative, Partial vs. Total Correctness

• Hoare Triple: Syntax and Interpretation

• Slides
  • Lecture 3: Program Verification [Last Updated: Apr. 6]
  • Lecture 3: Program Verification [4-up]
• TLA Modules
  • Syntax of Loop Specification
• Guide: Programming Test 2
• Guide: Final Exam [Last Updated: Apr. 6]
• Example Exam Questions
• Solution to Example Exam Questions

• Hoare Triple: Predicate Transformer

• Weakest Precondition (WP)

• WP Rules: Assignments, Conditionals, Seq. Comp.

• Contracts for Loops: Invariant vs. Variant

• Proving Loop Correctness

• ProgTest2 solution sketch

• G(p U r) vs. p U r

• Proving Maintenance of Loop Invariant

• Course Syllabus (last updated: September 7; subject to revision until September 20)
• Slides on Administrative Issues
• Weekly Schedule (Labs, Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Labs, Tests, Exam)

Playlist of All Lecture Recordings

All Slides

All Slides (4-up)

All iPad Notes

• Syllabus & Administratives

• Classes vs. Objects

• Object Aliasing

• Lab Instructions
  • Lab 0 Part 1
  • Lab 0 Part 2
• Review Tutorials on OOP in Java
  •  Tutorial Videos Playlist
  •  iPad notes
• Slides
  • Classes and Objects
  • Classes and Objects [4-up]
• Exercises
  • Tracing OO Program with Arrays and Reference Aliasing
• Required Written Notes
  • Inferring Classes/Methods from JUnit Tests ( ; )
  • Declaring and Manipulating Reference-Typed, Multi-Valued Attributes
• Codes
  • In-Class Demo (Sep 12): Attributes & Constructors
  • In-Class Demo (Sep 14): this & accessors
  • In-Class Demo (Sep 19): mutators, JUnit
  • Helper Methods & Static Variables
• Diagrams
  • The Observe-Model-Execute Process
• Guide: Written Test 1
• Guide: Programming Test 1

• 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

• 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

• 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

• More advanced use of `this`

• Static Variables: Global Variables

• Common Error: Static Counter

• 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

• Slides
  • Classes and Objects (Slides 80 - 82)
  • Classes and Objects [4-up]
  • Exceptions
  • Exceptions [4-up]
• Codes
  • Error Handling: Circles & Banks (without exceptions)
  • Exceptions: To Handle or Not to Handle
  • In-Class Demo (Sep 28): Three Versions of Exception Handling
  • Error Handling: Circles & Banks (with exceptions)
• Lab1 Solution Walk-Through

     

• What is an Exception?

• What to Do When an Exception is Thrown?

• Catch-or-Specify Requirement

• Example: To Handle or Not to Handle

• Using Exceptions: Circles & Banks

• Multiple Catch Blocks

• More Advanced Example of Exceptions

• Testing: Expected vs. Unexpected Exceptions

• Nested try-catch Blocks

• Console Testers vs. JUnit Tests

• Slides
  • TDD with JUnit (Updated on Oct. 17)
  • TDD with JUnit [4-up]
• Codes
  • Testing Expected vs. Unexpected Exceptions: Console vs. JUnit
•  Challenge: Magic Card

• Consoler Testers vs. JUnit Tests

• Regressing Testing and TDD

• == Operator: Primitive vs. Reference

• equals method from Object

• PointV1: No Overriding

• Overriding equals: 4 Phases

• Slides
  • Object Equality
  • Object Equality [4-up]
  • Call by Value (up to Slide 3)
  • Call by Value [4-up]
• Codes
  • Testing Equality: Points vs. Persons
• Lab2 Solution Walk-Through

     

• Guide: Written Test 2

• Overriding equals: Type Casting

• JUnit Assertions for Equality

• Short-Circuit Evaluation

• Object Equality: Array-Typed Attributes

• Call by Value

• Call by Value: Primitive vs. Reference

• Aggregations

• WrittenTest2 Practice Questions

• Slides
  • Call by Value, Aggregations, Compositions
  • Call by Value, Aggregations, Compositions [4-up]
• Codes
  • Call by Value: Primitive vs. Reference Arguments
  • Dotted Notation vs. Private Attributes
• Guide: Programming Test 2
• Lab3 Solution Walk-Through

     

• Dot Notation vs. Private Attributes

• Compositions

• Inheritance: SMS Problem

• SMS: Two Design Attempts

• SMS: Use of extends and super

• Visibility: private vs. none vs. protected vs. public

• Slides
  • Inheritance
  • Inheritance [4-up]
• Required Readings
  • Static Types, Expectations, Dynamic Types, and Type Casts
• Codes
  • Visibility: Classes vs. Attributes/Methods
  • SMS: With vs. Without Inheritance
• Diagrams
  • Inheritance Hierarchy: Students
  • Multi-Level Inheritance Hierarchy: Students
  • Multi-Level Inheritance Hierarchy: Smart Phones
• Guide: Written Test 3
• Lab4 Solution Walk-Through

     

• Guide: Programming Test 3

• Code Reuse, Static Types, Expectations

• Intuition: Polymorphism

• Intuition: Dynamic Binding

• Multi-Level Inheritance

• Rules of Substitutions

• Static Types vs. Dynamic Types

• Motivation of Type Casting

• Anatomy of a Type Cast

• Compilale Casts: Upwards vs. Downwards

• Compilable Casts May Fail at Runtime

• Type Casts: Compilable vs. Exception-Free

• Checking Dynamic Types via instanceof

• Polymorphic Method Parameters

• Polymorphic Array

• Polymorphic Return Types

• Dynamic Binding of equals Method

• Inheritance: Type Checking Rules

• Recursion: Introduction

• Examples: Factorial, Fibonacci, Palindrome

• Slides
  • Inheritance (Slide 90)
  • Recursion
  • Recursion [4-up]
• Exercises
  • Lab5 on Recursion (Only look at the solution here after you attempt these exercises)
  • CodingBat: Recursion 1
  • CodingBat: Recursion 2
• Source Code
  • Recursion
    • factorial
    • fibonacci
    • palindrome
    • reverseOf
    • numberOfOccurrences
    • allPositive
    • isSorted

•  Tracing Fibonacci Number

•  Recursion on Strings: Reverse

•  Recursion on Strings: Occurrences

•  Recursions on Arrays: Specifying Sub-Ranges

•  Recursions on Arrays: All Positive?

•  Recursions on Arrays: Sorted?

• Recap of Recursion

• Wrap-Up of the Course

• Exam Info

• Slides
  • Wrap-Up
  • Wrap-Up [4-up]

• Exam Review Q&A

• Type Casts

• Polymorphic Method Parameters

• Short-Circuit Evaluation

• Course Syllabus (last updated: September 8; subject to revision until September 20)
• Slides on Administrative Issues
• Weekly Schedule (Labs, Office Hours)
• Semester Calendar (In-Class Lectures, Office Hours, Labs, Tests, Exam) [Updated: Oct 25]

Playlist of All Lecture Recordings

All Slides

All Slides (4-up)

All iPad Notes

• Syllabus & Administratives

• Semantic Domain

• Limitation of Eclipse Compiler (A+ challenge)

• Slides
  • Overview of Compilation (Final Ver.)
  • Overview of Compilation [4-up]
  • Lexical Analysis (Slides 1 - 5)
  • Lexical Analysis [4-up]
• Diagrams
  • What is a Compiler?
  • Analysis: Lexical, Syntactic, Semantic
  • Workflow of an Optimizer

• Compiler Infrastructure

• Intermediate Representation (IR)

• Analysis: Lexical, Syntactic, Semantic

• Example Optimizer

• Example Object-to-Relational Compiler

• Scanner in Context

• Alphabets

• Strings (Σ^k)

• Langauges, Problems

• Regular Language Operations

• Constructing Regular Expressions

• Slides
  • Lexical Analysis (Slides 6 - 15)
  • Lexical Analysis [4-up]

• Review Exercises: Strings & Languages

• Exercises: RE Constructions & Specification

• RE Operator Precedence

• DFA: Basics

• Review Exercise: Drawing DFA

• Slides
  • Lexical Analysis (Slides 16 - 23)
  • Lexical Analysis [4-up]

• DFA Formulation

• NFA: Non-Deterministic State Transitions

• Slides
  • Lexical Analysis (Slides 24 - 31)
  • Lexical Analysis [4-up]

• NFA: "Alternative Realities"

• Subset Construction with Lazy Evaluation

• epsilon-NFA: Motivating Examples

• Slides
  • Lexical Analysis (Slides 32 - 42)
  • Lexical Analysis [4-up]

• ε-closures

• Conversion: ε-NFA to DFA

• Conversion: Regular Expressions to ε-NFA

• Slides
  • Lexical Analysis (Slides 43 - 56)
  • Lexical Analysis [4-up]

• Minimizing DFA

• Implementing a Scanner

• Context-Free Grammar: Terminology

• Slides
  • Lexical Analysis (Slides 57 - 62)
  • Lexical Analysis [4-up]
  • Syntactic Analysis (Slides 2 - 9)
  • Syntactic Analysis [4-up]

• Comparing Two CFGs

• Semantic Analysis

• Finding Witnesses of Ambiguity

• Slides
  • Syntactic Analysis (Slides 10 - 16)
  • Syntactic Analysis [4-up]
• Exercise Solutions
  • Minimizing DFA States

• CFG: Formulation

• RE/DFA to CFG

• Ambiguity: Dangling else

• Slides
  • Syntactic Analysis (Slides 17 - 21)
  • Syntactic Analysis [4-up]

• Derivations vs. Parse Trees

• Dangling else Problem

• Composite Pattern: Problem, Attempts

• Slides
  • Syntactic Analysis (Slides 22 - 32)
  • Syntactic Analysis [4-up]
  • Composite Pattern (Slides 2 - 10)
  • Composite Pattern [4-up]
• Design Diagrams
  • Composite: Attempt 1
  • Composite: Attempt 2
  • Composite: Attempt 3

• Composite Pattern: Architecture & Tests

• Visitor Pattern: Problem, Architecture & Tests

• Slides
  • Composite Pattern (Slides 11 - 18)
  • Composite Pattern [4-up]
  • Visitor Pattern (Slides 19 - 26)
  • Visitor Pattern [4-up]
• Design Diagrams
  • Composite: Architecture
  • Composite: Multiple Instantiations
  • Visitor: Composite Structures
  • Visitor: Attempt 1
  • Visitor: Architecture
• Codes
  • Composite Design Pattern
  • Visitor Design Pattern