Jackie's Lectures

• 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

• Visitor Pattern: Double Dispatch

• Visitor Pattern: Open-Closed Principle

• Visitor Pattern: Single-Choice Principle

• Slides
  • Visitor Pattern (Slides 27 - 30)
  • Visitor Pattern [4-up]
• Design Diagrams
  • Visitor: Architecture
• Codes
  • Visitor Design Pattern

• Identifying Derivations

• Top-Down Parsing Algorithm

• Left- vs. Right-Recursive CFG

• Slides
  • Syntactic Analysis (Slides 33 - 37)
  • Syntactic Analysis [4-up]

• Removing Left Recursions from CFG

• Removing epsilon-Productions

• Backtrack-Free Parsing: Motivation

• Slides
  • Syntactic Analysis (Slides 38 - 41)
  • Syntactic Analysis [4-up]

• Computing the FIRST Set: Algorithm

• Slides
  • Syntactic Analysis (Slides 42 - 44)
  • Syntactic Analysis [4-up]

• FOLLOW Set, START Set

• Backtrack-Free Top-Down Parsing

• Slides
  • Syntactic Analysis (Slides 45 - 51)
  • Syntactic Analysis [4-up]

• Left Factoring

• LL(1) vs. LR(1) Parsers

• Bottom-Up Parsing, Discovering RMDs

• Slides
  • Syntactic Analysis (Slides 52 - 60)
  • Syntactic Analysis [4-up]

• Bottom-Up Parsing: Shift vs. Reduce

• Exercise: LL(1) Parser

• Slides
  • Syntactic Analysis (Slides 61 - 65)
  • Syntactic Analysis [4-up]

• Bottom-Up Parsing: Handles

• Bottom-Up Parsing: Right Most Derivations

• LR(1) Items: Definition & Exercises

• Slides
  • Syntactic Analysis (Slides 66 - 71)
  • Syntactic Analysis [4-up]

• Canonical Collection ≈ Subset States

• Computing closure

• Computing goto

• Slides
  • Syntactic Analysis (Slides 72 - 76)
  • Syntactic Analysis [4-up]

• Building CC and Transition Function

• Building Action and Goto Tables

• Shift-Reduce vs. Reduce-Reduce Conflicts

• Slides
  • Syntactic Analysis (Slides 77 - 88)
  • Syntactic Analysis [4-up]

• Exam Review Q&A

• FOLLOW Set

• epsilon-NFA to DFA

• Course syllabus (last updated: January 10; subject to revision until January 23)
• Two Q&A sessions were held on the course syllabus:
  • Syllabus Q&A on January 10 (Section N):  Recording and  iPad Notes
  • Syllabus Q&A on January 11 (Section Z):  Recording and  iPad Notes
  • Diagrams
    • Motivating Problem: Program Optimization
    • Motivating Problem: Program Translator
• Slides on Administrative Issues
• Weekly Schedule (Q&A, Labs, Office Hours)
• Semester Calendar (Weekly lecture series, Q&A sessions, tests, assignments, exam) [Updated: Mar 2]

Playlist of All Lecture Recordings

All Slides

All Slides (4-up)

All iPad Notes

  Playlist for Week 1

•  Lecture 1 - Part A1 - Resources, Algorithm vs. Data Structures

•  Lecture 1 - Part A2 - Measuring Running Time

•  Lecture 1 - Part B1 - Primitive Operations

•  Lecture 1 - Part B2 - Counting Primitive Op. (for-Loop)

•  Lecture 1 - Part B3 - Counting Primitive Op. (while-Loop)

•  Lecture 1 - Part C1 - From Absolute RT to Relative RT

•  Lecture 1 - Part C2 - The Big-O Notation

•  Lecture 1 - Part C3 - Proposition: Big-O Proof Strategy

•  Lecture 1 - Part C4 - Proposition: Relating Functions

•  Lecture 1 - Part D - Big-O for Math Functions

 Notes

• (Optional) Review Tutorials on OOP in Java
  •  Tutorial Videos Playlist
  •  iPad notes
• Slides
  • Lecture 1: Asymptotic Analysis of Algorithms (Slides 1 - 28)
  • Lecture 1: Asymptotic Analysis of Algorithms [4-up]
• Questions?
  • Post Your Questions in this Document.

 Problems

• Recursion: groupSum
• Recursion: groupSum6
• Recursion: parenBit
• Complexity: containsDuplicate

 Jan 19 (WED)

 Jan 20 (THU)

  Playlist for Week 2

•  Lecture 1 - Part E1 - Remarks on Using the Big-O Notation

•  Lecture 1 - Part E2 - Exercises: Approximating Running Time

•  Lecture 1 - Part E3 - More Advanced Exercise on RT

•  Lecture 2 - Part A1 - Resources for Generics in Java

•  Lecture 2 - Part A2 - Upper Bounds of Array Operations

•  Lecture 2 - Part B1 - Variants of the Sorting Problem

•  Lecture 2 - Part B2 - Visualizing Selection vs. Insertion Sort

•  Lecture 2 - Part B3 - Selection Sort: Java and Tracing

•  Lecture 2 - Part B4 - Insertion Sort: Java and Tracing

•  Lecture 2 - Part B5 - Using the Eclipse Debugger for Tracing

 Notes

• Background Study: Generics in Java
  • We need this for Week 4's lecture.
  • Review if needed:  EECS2030 F21 Lectures
    • Parts A1 - A3, Lecture 7, Week 10
    • Parts B - C, Lecture 7, Week 11
• Slides
  • Lecture 1: Asymptotic Analysis of Algorithms (Slides 29 - 37)
  • Lecture 1: Asymptotic Analysis of Algorithms [4-up]
  • Lecture 2: Arrays vs. Linked Lists (Slides 1 - 9)
  • Lecture 2: Arrays vs. Linked Lists [4-up]
• Source Code
  • Selection Sort vs. Insertion Sort
• Questions?
  • Post Your Questions in this Document.

 Problems

• Recursion: climb
• Recursion: climbStrategies

 Jan 26 (WED)

 Jan 27 (THU)

  Playlist for Week 3

•  Lecture 2 - Part C1 - Chain of Nodes, Relative Positioning

•  Lecture 2 - Part C2 - Dynamic Size, Reference Aliasing

•  Lecture 2 - Part D1 - Node vs. SinglyLinkedList

•  Lecture 2 - Part D2 - Constructing a Chain of Nodes

•  Lecture 2 - Part D3 - Setting a List's Head to a Chain

•  Lecture 2 - Part D4 - List/Node Constructions in Debugger

•  Lecture 2 - Part E1 - Computing Size, current Node

•  Lecture 2 - Part E2 - Computing Tail, Tracing in Debugger

•  Lecture 2 - Part E3 - Inserting to the Front, Exercises

 Notes

• Background Study: Generics in Java
  • We need this for Week 4's lecture.
  • Review if needed:  EECS2030 F21 Lectures
    • Parts A1 - A3, Lecture 7, Week 10
    • Parts B - C, Lecture 7, Week 11
• Slides
  • Lecture 2: Arrays vs. Linked Lists (Slides 10 - 23)
  • Lecture 2: Arrays vs. Linked Lists [4-up]
• Source Code
  • Singly-Linked Lists of Strings
• Diagrams
  • A Chain of Linked Nodes
  • Head of a Singly-Linked List of Strings
• Questions?
  • Post Your Questions in this Document.

 Problems

• SLL: reverseOf

 Feb 2 (WED)

 Feb 3 (THU)

 Guide: Written Test 1

  Playlist for Week 4

•  Lecture 2 - Part E4 - Accessing Middle of List

•  Lecture 2 - Part E5 - Sketch: Adding into Middle of List

•  Lecture 2 - Part E6 - Adding into Start/Middle/End of List

•  Lecture 2 - Part E7 - removeLast, addLast, removeFirst

•  Lecture 2 - Part F - Comparing Arrays vs. SLLs, Exercises

•  Lecture 2 - Part G1 - Non-Generic SLLs: Code Duplicates

•  Lecture 2 - Part G2 - Generic SLLs: Node<Str>, Node<Int>

•  Lecture 2 - Part G3 - Generic List Creations and Methods

 Notes

• Background Study: Generics in Java
  • Review if needed:  EECS2030 F21 Lectures
    • Parts A1 - A3, Lecture 7, Week 10
    • Parts B - C, Lecture 7, Week 11
• Slides
  • Lecture 2: Arrays vs. Linked Lists (Slides 24 - 36)
  • Lecture 2: Arrays vs. Linked Lists [4-up]
• Source Code
  • Generic Linked Lists
  • Singly-Linked Lists of Strings
• Diagrams
  • Head of a Generic Singly-Linked List
• Questions?
  • Post Your Questions in this Document.

 Problems

• SLL: removeNthFromEnd
  • Specification
  • 

 Feb 9 (WED)

 Feb 10 (THU)

  Playlist for Week 5

•  Lecture 2 - Part H1 - DLL: prev reference, header vs. trailer

•  Lecture 2 - Part H2 - DLL: Empty vs. Non-empty DLLs

•  Lecture 2 - Part I - Generic DLL: Initializing an Empty List

•  Lecture 2 - Part J1 - DLL: Adding between Nodes

•  Lecture 2 - Part J2 - DLL: addFirst, addLast, addAt

•  Lecture 2 - Part J3 - DLL: Removing an Arbitrary Node

•  Lecture 2 - Part J4 - DLL: removeFirst, removeLast, removeAt

•  Lecture 2 - Part K - Arrays vs. SLLs vs. DLLs, Exercises

•  Lecture 3 - Part A1 - Contractual Relation: Supplier vs. Client

•  Lecture 3 - Part A2 - Contractual Relation in OOP

•  Lecture 3 - Part A3 - Modularity, Modular Design

•  Lecture 3 - Part A4 - Abstract Data Types (ADTs), Interfaces

 Notes

• Background Study: Interfaces in Java
  • Review if needed:  EECS2030 F21 Lectures
    • Parts B1 - B3, Lecture 6, Week 10
• Slides
  • Lecture 2: Arrays vs. Linked Lists (Slides 37 - 51)
  • Lecture 2: Arrays vs. Linked Lists [4-up]
  • Lecture 3: ADTs and Modularity (Slides 1 - 15)
  • Lecture 3: ADTs and Modularity [4-up]
• Source Code
  • Generic DLLs [Updated: Feb. 20 on DLL.getNodeAt]
• Questions?
  • Post Your Questions in this Document.

 Guide: Programming Test 1

 Feb 23 (WED) - ProgTest1

 Problems

• SLL: shiftedToRightBy
  • Specification
  • 

 Mar 2 (WED)

  Playlist for Week 6

•  Lecture 3 - Part B1 - Stack ADT: Last In First Out (LIFO)

•  Lecture 3 - Part B2 - Array-Based Implementation of Stack

•  Lecture 3 - Part B3 - SLL-Based Implementation of Stack

•  Lecture 3 - Part B4 - Polymorphic Stacks

•  Lecture 3 - Part C1 - Stack App: Reversing an Array

•  Lecture 3 - Part C2 - Stack App: Matching Delimiters

•  Lecture 3 - Part C3 - Stack App: Postfix Calculations

•  Lecture 3 - Part D1 - Queue ADT: First In First Out (FIFO)

•  Lecture 3 - Part D2 - Array- vs. SLL-Based Imp. of Queue

•  Lecture 4 - Part A1 - Background Studies on Recursion

 Notes

• Background Study: Interfaces in Java
  • Review if needed:  EECS2030 F21 Lectures
    • Parts B1 - B3, Lecture 6, Week 10
• Background Study: Basic Recursion in Java
  • We need this for next week's lecture.
  • Review if needed:  EECS2030 F21 Lectures
    • Parts A - C, Lecture 8, Week 12
• Slides
  • Lecture 3: Stacks and Queues (Slides 16 - 43)
  • Lecture 3: Stacks and Queues [4-up]
  • Lecture 4: Recursion (Slides 1 - 3)
  • Lecture 4: Recursion [4-up]
• Source Code
  • Generic Stacks
  • Generic Queues
• Questions?
  • Post Your Questions in this Document.

  Playlist for Week 7

•  Lecture 3 - Part D3 - Circular Arrays: Empty, Insertions

•  Lecture 3 - Part D4 - Circular Arrays: Deletions, Insertions

•  Lecture 3 - Part D5 - The Double-Ended Queue (Deque) ADT

•  Lecture 3 - Part E1 - Dynamic Arrays: Increments vs. Doubling

•  Lecture 3 - Part E2 - Amortized RT of Increments Strategy

•  Lecture 3 - Part E3 - Deriving Sum of Geometric Sequence

•  Lecture 3 - Part E4 - Amortized RT of Doubling Strategy

•  Lecture 3 - Part E5 - Comparing RTs of Increments vs. Doubling

•  Lecture 4 - Part A2 - Resources, Learning Outcomes

•  Lecture 4 - Part B1 - Binary Search: Ideas

•  Lecture 4 - Part B2 - Binary Search: Implementation in Java

•  Lecture 4 - Part B3 - Binary Search: Tracing Recursions

•  Lecture 4 - Part B4 - RT of a Linear, Recursive Algorithm

•  Lecture 4 - Part B5 - RT of the Recursive Binary Search

 Notes

• Background Study: Basic Recursion in Java
  • Review if needed:  EECS2030 F21 Lectures
    • Parts A - C, Lecture 8, Week 12
• Slides
  • Lecture 3: Stacks and Queues (Slides 44 - 53)
  • Lecture 3: Stacks and Queues [4-up]
  • Lecture 4: Recursion (Slides 4 - 8)
  • Lecture 4: Recursion [4-up]
• Source Code
  • Recursion
    • Binary Search
• Questions?
  • Post Your Questions in this Document.

 Mar 9 (WED)

  Playlist for Week 8

•  Lecture 5a - Part A1 - Linear vs. Non-Linear Structures

•  Lecture 5a - Part A2 - General Tree Terminology I

•  Lecture 5a - Part A3 - General Tree Terminology II

•  Lecture 5a - Part A4 - Tree Definitions and Applications

•  Lecture 5a - Part B1 - TreeNode Class, Generic Array

•  Lecture 5a - Part B2 - Testing Tree Construction

•  Lecture 5a - Part B3 - Computing Depth Recursively

•  Lecture 5a - Part B4 - Computing Height Recursively

•  Lecture 5a - Part C1 - Binary Trees: Recursive Structure

•  Lecture 5a - Part C2 - BTs: Counting Nodes at Levels

•  Lecture 5a - Part C3 - Complete BTs vs. Full BTs

•  Lecture 5a - Part C4 - Bounding Various Measures of BTs

 Notes

• Background Study: Basic Recursion in Java
  • Review if needed:  EECS2030 F21 Lectures
    • Parts A - C, Lecture 8, Week 12
• Slides
  • Lecture 5a: General Trees and Binary Trees (Slides 2 - 34)
  • Lecture 5a: General Trees and Binary Trees [4-up]
• Source Code
  • Generic, General Trees
• Questions?
  • Post Your Questions in this Document.

 Guide: Written Test 2

 Mar 16 (WED)

  Playlist for Week 9

•  Lecture 5a - Part C5 - Property of a Proper Binary Tree

•  Lecture 5a - Part D - Applications of Binary Trees

•  Lecture 5a - Part E1 - Definitions of Tree Traversals

•  Lecture 5a - Part E2 - Tracing Pre-Order vs. Post-Order

•  Lecture 5a - Part E3 - Pre-Order vs. In-Order vs. Post-Order

•  Lecture 5b - Part A1 - Binary Search Tree (BST): Definition

•  Lecture 5b - Part A2 - In-Order Traversal on a BST

 Notes

• Background Study: Basic Recursion in Java
  • Review if needed:  EECS2030 F21 Lectures
    • Parts A - C, Lecture 8, Week 12
• Slides
  • Lecture 5a: General Trees and Binary Trees (Slides 35 - 43)
  • Lecture 5a: General Trees and Binary Trees [4-up]
  • Lecture 5b: Binary Search Trees (Slides 2 - 5)
  • Lecture 5b: Binary Search Trees Trees [4-up]

  Playlist for Week 10

•  Lecture 5b - Part B1 - BSTNode vs. Doubly-Linked Node

•  Lecture 5b - Part B2 - In-Order Traversal in Java

•  Lecture 5b - Part B3 - Tracing Tree Construction and Traversal

•  Lecture 5b - Part C1 - Searching: Successful vs. Unsuccessful

•  Lecture 5b - Part C2 - Searching: Running Time

•  Lecture 5b - Part C3 - Binary Search: BST vs. Sorted Array

•  Lecture 5b - Part D - BST Insertions

•  Lecture 5b - Part E1 - BST Deletions: Cases 1 to 3

•  Lecture 5b - Part E2 - BST Deletions: Case 4

•  Lecture 4 - Part C1 - MergeSort: Ideas

•  Lecture 4 - Part C2 - MergeSort: Java Implementation

•  Lecture 4 - Part C3 - MergeSort: Tracing Recursive Calls

 Notes

• Background Study: Basic Recursion in Java
  • Review if needed:  EECS2030 F21 Lectures
    • Parts A - C, Lecture 8, Week 12
• Slides
  • Lecture 5b: Binary Search Trees (Slides 6 - 24)
  • Lecture 5b: Binary Search Trees Trees [4-up]
  • Lecture 4: Recursion (Slides 9 - 16)
  • Lecture 4: Recursion [4-up]
• Source Code
  • Generic Binary Search Tree
  • Recursion
    • Merge Sort
• Questions?
  • Post Your Questions in this Document.

 Guide: Programming Test 2

 Mar 30 (WED)

  Playlist for Week 11

•  Lecture 5c - Part A1 - BST with Linear Height

•  Lecture 5c - Part A2 - Height-Balance Property

•  Lecture 5c - Part A3 - Intuition: Tree Rotations

•  Lecture 5c - Part B0 - Fixing Balance after Insertions

•  Lecture 5c - Part B1 - Case 1: Single, Left Rotation

•  Lecture 5c - Part B2 - Case 2: Single, Right Rotation

•  Lecture 5c - Part B3 - Case 3: R-L Rotations, Exercise

•  Lecture 5c - Part C0 - Fixing Balance after Deletions

•  Lecture 5c - Part C1 - Case 1: Single Trinode Step

•  Lecture 5c - Part C2 - Case 2: Multiple Trinode Steps

•  Lecture 5c - Part C3 - RTs and Implementations of Rotations

•  Lecture 4 - Part C4 - MergeSort RT - Recursion Tree

•  Lecture 4 - Part C5 - MergeSort RT - Recurrence Relation

 Notes

• Background Study: Basic Recursion in Java
  • Review if needed:  EECS2030 F21 Lectures
    • Parts A - C, Lecture 8, Week 12
• Slides
  • Lecture 5c: Balanced BSTs (Slides 2 - 20)
  • Lecture 5c: Balanced BSTs [4-up]
  • Lecture 4: Recursion (Slides 17 - 20)
  • Lecture 4: Recursion [4-up]
• Source Code
  • Recursion
    • Merge Sort
• Exercises
  • Exercise: L-R Rotations after Insertion
  • Exercise: L Rotation after Deletion
• Questions?
  • Post Your Questions in this Document.

  Playlist for Week 12

•  Lecture 4 - Part D1 - QuickSort: Ideas

•  Lecture 4 - Part D2 - QuickSort: Implementation, Tracing

•  Lecture 4 - Part D3 - RT: Worst-Case vs. Best Case

•  Lecture 5d - Part A1 - Priority Queue (PQ): Introduction

•  Lecture 5d - Part A2 - List-Based Implementation of PQ

•  Lecture 5d - Part B - Heaps: Properties and Examples

•  Lecture 5d - Part C - Insertions and Up-Heap Bubbling

•  Lecture 5d - Part D - Deletions and Down-Heap Bubbling

•  Lecture 5d - Part E - Top-Down Heap Construction

•  Lecture 5d - Part F - Bottom-Up Heap Construction

•  Lecture 5d - Part G - Heap Sort Algorithm

•  Lecture 5d - Part H - Array-Based Implementation of BT

•  Wrap-Up of the Course

 Notes

• Background Study: Basic Recursion in Java
  • Review if needed:  EECS2030 F21 Lectures
    • Parts A - C, Lecture 8, Week 12
• Slides
  • Lecture 4: Recursion (Slides 21 - 33)
  • Lecture 4: Recursion [4-up]
  • Lecture 5d: Priority Queue and Heaps
  • Lecture 5d: Priority Queue and Heaps [4-up]
  • Wrap-Up of the Course
  • Wrap-Up of the Course [4-up]
• Source Code
  • Recursion
    • Quick Sort
• Questions?
  • Post Your Questions in this Document.

 Guide: Final Exam (Last Updated: April 7)

 Example Exam Questions

 Example Exam Questions (solution)

• Course syllabus (last updated: January 10; subject to revision until January 23)
• A Q&A session was held on the course syllabus:
  • Syllabus Q&A on January 11 (Section Z):  Recording
• Slides on Administrative Issues
• Weekly Schedule (Q&A, Labs, Office Hours)
• Semester Calendar (Weekly lecture series, Q&A sessions, tests, labs, exam)

Playlist of All Lecture Recordings

All Slides

All Slides (4-up)

All iPad Notes

  Playlist for Week 1

•  Lecture 1a - Part A - SCS, FM, Code of Ethics

•  Lecture 1a - Part B - Verification vs. Validation

•  Lecture 1a - Part C - Model-Based Development

•  Lecture 1b - Part A1 - Propositional Operators

•  Lecture 1b - Part A2 - More Insights of Implications

•  Lecture 1b - Part B1 - Universal Quantification

•  Lecture 1b - Part B2 - Existential Quantification, Conversions

•  Lecture 1b - Part C - Set Relations, Set Operations, Power Set

•  Lecture 1b - Part D1 - Constructing Tuples using Cross Products

•  Lecture 1b - Part D2 - Defining Possible Relations

•  Lecture 1b - Part D3 - Exercise: Enumerating Possible Relations

•  Lecture 1b - Part D4 - Relations: Domain, Range, Image

•  Lecture 1b - Part D5 - Relations: Restrictions vs. Subtractions

 Notes

• Slides [Updated: Jan. 20]
  • Lecture 1a: Introduction
  • Lecture 1a: Introduction [4-up]
  • Lecture 1b: Review of Math (Slides 1 to 25)
  • Lecture 1b: Review of Math [4-up]
• Diagrams
  • Verification vs. Validation
•  (Draft) Modelling in Event-B (MEB) [PPY login required]
• Questions?
  • Post Your Questions in this Document.

 Jan 20 (THU)

 Guide: Written Test 1

  Playlist for Week 2

•  Lecture 1b - Part D6 - Relational Overriding

•  Lecture 1b - Part D7 - Exercise: Rewriting Relational Operations

•  Lecture 1b - Part E1 - Defining the Functional Property

•  Lecture 1b - Part E2 - Partial vs. Total, Modelling Exercise

•  Lecture 1b - Part E3 - Partial vs. Total Injections

•  Lecture 1b - Part E4 - Partial vs. Total Surjections

•  Lecture 1b - Part E5 - Bijections

•  Lecture 1b - Part E6 - Exercise: Categorizing Functions

•  Lecture 1b - Part E7 - Formalizing Arrays as Functions

 Notes

• Slides [Updated: Jan. 20]
  • Lecture 1b: Review of Math (Slides 26 - 37)
  • Lecture 1b: Review of Math [4-up]
• Tutorial: Rodin Tool for Formal Specifications
  •  Lab1 Instructions [PPY login required]
  •  List of Tutorial Videos
  •  iPad notes
•  (Draft) Modelling in Event-B (MEB) [PPY login required]
• Questions?
  • Post Your Questions in this Document.

 Jan 27 (THU)

  Playlist for Week 3

•  Lecture 2 - Part A1 - Correct by Construction

•  Lecture 2 - Part A2 - State Space, Combinatorial Explosion

•  Lecture 2 - Part A3 - Requirements Document, Refinement Strategy

•  Lecture 2 - Part B1 - Applying Abstraction w.r.t. REQ2

•  Lecture 2 - Part B2 - Initial Model: state space and invariants

•  Lecture 2 - Part B3 - Initial Model: events, guards, actions

•  Lecture 2 - Part B4 - Event Traces Causing Invariant Violations

•  Lecture 2 - Part B5 - Event Actions vs. Before-After Predicates

 Notes

• Slides
  • Lecture 2: Bridge Controller (Slides 1 - 14)
  • Lecture 2: Bridge Controller [4-up]
• Tutorial: Rodin Tool for Formal Specifications
  •  Lab1 Instructions [PPY login required]
  •  List of Tutorial Videos
  •  iPad notes
•  (Draft) Modelling in Event-B (MEB) [PPY login required]
• Questions?
  • Post Your Questions in this Document.

  Playlist for Week 4

•  Lecture 2 - Part C1 - Event Design: Updates Subject to Invariants

•  Lecture 2 - Part C2 - Sequents: Syntax and Semantics

•  Lecture 2 - Part C3 - Sketching PO Rule of Invariant Preservation

•  Lecture 2 - Part C4 - PO Rule of Invariant Preservation: Components

•  Lecture 2 - Part C5 - PO Rule of Invariant Preservation: Sequents

•  Lecture 2 - Part C6 - Inference Rules: Syntax and Semantics

•  Lecture 2 - Part C7 - Proving a Sequent: Steps and Structures

•  Lecture 2 - Part C8 - Example Inference Rules

•  Lecture 2 - Part C9 - Proving INV Sequents for ML_out and ML_in

 Notes

• Slides
  • Lecture 2: Bridge Controller (Slides 15 - 29)
  • Lecture 2: Bridge Controller [4-up]
• Notes
  • Example Inference Rules - 1
•  (Draft) Modelling in Event-B (MEB) [PPY login required]
• Questions?
  • Post Your Questions in this Document.

 Feb 10 (THU)

  Playlist for Week 5

•  Lecture 2 - Part D1 - Initializing the System

•  Lecture 2 - Part D2 - Proving PO of Invariant Establishment

•  Lecture 2 - Part E1 - Formulating PO of Deadlock Freedom

•  Lecture 2 - Part E2 - More Example Inference Rules, Exercise

•  Lecture 2 - Part E3 - Discharging PO of DLF: First Attempt

•  Lecture 2 - Part E4 - Revising Model, Second Attempt

•  Lecture 2 - Part E5 - Final, Provably Correct Initial Model

•  Lecture 2 - Part F1 - 1st Refinement: More "Concrete" Abstraction

 Notes

• Slides
  • Lecture 2: Bridge Controller (Slides 30 - 44)
  • Lecture 2: Bridge Controller [4-up]
• Notes
  • Example Inference Rules - 2
  • Proofs of DLF: Initial Model
•  (Draft) Modelling in Event-B (MEB) [PPY login required]
• Questions?
  • Post Your Questions in this Document.

 Mar 3 (THU)

  Playlist for Week 6

•  Lecture 2 - Part F2 - Refined, Concrete State Space

•  Lecture 2 - Part F3 - Deriving Concrete Event Guards

•  Lecture 2 - Part F4 - State Transitions: Abstract vs. Concrete

•  Lecture 2 - Part F5 - States, Invariants, Events: Abstract vs. Concrete

•  Lecture 2 - Part G1 - Sketching PO of Refinement

•  Lecture 2 - Part G2 - PO of Guard Strengthening: Sequents

•  Lecture 2 - Part G3 - Proving Guard Strengthening: ML_out/GRD

•  Lecture 2 - Part G4 - Proving Guard Strengthening: ML_in/GRD

•  Lecture 2 - Part H - PO of Invariant Preservation, Exercises

•  Lecture 2 - Part I - PO of Invariant Establishment, Exercises

 Notes

• Slides
  • Lecture 2: Bridge Controller (Slides 45 - 67)
  • Lecture 2: Bridge Controller [4-up]
• Notes
  • Proofs of Refinement: First Refinement (old events)
•  (Draft) Modelling in Event-B (MEB) [PPY login required]
• Questions?
  • Post Your Questions in this Document.

  Playlist for Week 7

•  Lecture 2 - Part J1 - New Events (IL_in, IL_out)

•  Lecture 2 - Part J2 - Guarded Actions of New Events

•  Lecture 2 - Part J3 - Simulating a New Event via skip

•  Lecture 2 - Part J4 - PO of Invariant Preservation: New Events

•  Lecture 2 - Part J5 - Proving Inv. Preservation: IL_in/inv1_4

•  Lecture 2 - Part J6 - Proving Inv. Preservation: IL_in/inv1_5

•  Lecture 2 - Part K1 - Livelock Caused by New Events Diverging

•  Lecture 2 - Part K2 - Variant Measuring New Events Converging

•  Lecture 2 - Part K3 - Convergence of New Events: NAT and VAR

•  Lecture 2 - Part L1 - Relative DLF: Idea and Sequent

•  Lecture 2 - Part L2 - More Example Inference Rules

•  Lecture 2 - Part L3 - Final, Provably Correct First Refinement

 Notes

• Slides
  • Lecture 2: Bridge Controller (Slides 68 - 86)
  • Lecture 2: Bridge Controller [4-up]
• Notes
  • Proofs of Refinement: First Refinement (new events)
  • Example Inference Rules - 3
•  (Draft) Modelling in Event-B (MEB) [PPY login required]
• Questions?
  • Post Your Questions in this Document.

 Guide: Written Test 3

 Mar 10 (THU)

  Playlist for Week 9

•  Lecture 2 - Part M1 - 2nd Refinement (m2): Superposition

•  Lecture 2 - Part M2 - Carrier Set, Axioms, Invariants

•  Lecture 2 - Part M3 - Refining Old Events from m1

•  Lecture 2 - Part M4 - Designing new Events in m2

•  Lecture 2 - Part N1 - INV POs: Refined Events

•  Lecture 2 - Part N2 - More Example Inference Rules

•  Lecture 2 - Part N3 - INV POs: First Attempt & Analysis

•  Lecture 2 - Part O - INV POs: Second Attempt

•  Lecture 2 - Part P - Adding Actions to New Events

•  Lecture 2 - Part Q1 - Analyzing Unprovable Sequent

•  Lecture 2 - Part Q2 - Splitting Old, Concrete Events

 Notes

• Slides
  • Lecture 2: Bridge Controller (Slides 87 - 107)
  • Lecture 2: Bridge Controller [4-up]
• Notes
  • Proofs of Refinement: Second Refinement
  • Example Inference Rules - 4
•  (Draft) Modelling in Event-B (MEB) [PPY login required]
• Questions?
  • Post Your Questions in this Document.

  Playlist for Week 10

•  Lecture 2 - Part R1 - Divergence of New Events

•  Lecture 2 - Part R2 - Regulating New Event Occurrences

•  Lecture 2 - Part R3 - Measuring New Event Occurrences

•  Lecture 2 - Part S - DLF, Provably Correct Second Refinement

 Notes

• Slides
  • Lecture 2: Bridge Controller (Slides 108 - 113)
  • Lecture 2: Bridge Controller [4-up]
•  (Draft) Modelling in Event-B (MEB) [PPY login required]
• Questions?
  • Post Your Questions in this Document.

 Guide: Written Test 4

 Mar 31 (THU)

  Playlist for Week 11

•  Lecture 3 - Part A1 - Introduction, RD, Refinement Strategy

•  Lecture 3 - Part A2 - Initial Model: State Space

•  Lecture 3 - Part A3 - Initial Model: Events

•  Lecture 3 - Part A4 - Initial Model: Invariant Establishment

•  Lecture 3 - Part A5 - Initial Model: Invariant Preservation

 Notes

• Slides
  • Lecture 3: File Transfer Protocol (Slides 2 - 13)
  • Lecture 3: File Transfer Protocol [4-up]
•  (Draft) Modelling in Event-B (MEB) [PPY login required]
• Questions?
  • Post Your Questions in this Document.

 Apr 7 (THU)

  Playlist for Week 12

•  Lecture 3 - Part B1 - First Refinement: Asynchrony & Gradualness

•  Lecture 3 - Part B2 - Concrete State Space and Invariants

•  Lecture 3 - Part B3 - Concrete Events: Old vs. New

•  Lecture 3 - Part B4 - Proofs and Exercises

 Notes

• Slides
  • Lecture 3: File Transfer Protocol (Slides 14 - 25)
  • Lecture 3: File Transfer Protocol [4-up]
• Notes
  • Proofs of Refinement: First Refinement
•  (Draft) Modelling in Event-B (MEB) [PPY login required]
• Questions?
  • Post Your Questions in this Document.

 Guide: Final Exam (Last Updated: April 7)

 Example Exam Questions

 Example Exam Questions (solution)

• Course syllabus (last updated: September 9; subject to revision until September 22)
• Two Q&A sessions were held on the course syllabus:
  • Syllabus Q&A on September 8 (Section B):  Recording and  iPad Notes
  • Syllabus Q&A on September 9 (Section E):  Recording and  iPad Notes
• Slides on Administrative Issues
• Weekly Schedule (Q&A, Labs, Office Hours)
• Semester Calendar (Weekly lecture series, Q&A sessions, tests, labs, exam)

Playlist of All Lecture Recordings

All Slides

All Slides (4-up)

All iPad Notes

• Review Tutorials (Part 1 and Part 2).

•  Week 1 - Intro

•  Week 2 - Intro

 Intro

• Lab Instructions
  • Lab 0 Part 1
  • Lab 0 Part 2
• Review Tutorials on OOP in Java
  •  Tutorial Videos Playlist
  •  iPad notes
• Slides
  • Lecture 1: Classes and Objects (Updated: Sep. 15)
  • Lecture 1: Classes and Objects (Updated: Sep. 15) [4-up]
• Required Written Notes
  • Inferring Classes/Methods from JUnit Tests
  • Declaring and Manipulating Reference-Typed, Multi-Valued Attributes
• Diagrams
  • The Observe-Model-Execute Process
• Questions?
  • Post Your Questions in this Document (Review Tutorial Part 1).
  • Post Your Questions in this Document (Review Tutorial Part 2).

 Sep 15 (W1)

 Sep 16 (W1)

 Intro

 Sep 22 (W2)

 Sep 23 (W2)

  Playlist for Week 3

•  Week 3 - Intro

•  Lecture 2a - Part A - Caller vs. Callee in a Method Invocation

•  Lecture 2a - Part B - Visualizing a Method Call Chain as a Stack

•  Lecture 2a - Part C1 - Error Handling via Console Messages (Circle)

•  Lecture 2a - Part C2 - Error Handling via Console Messages (Bank)

•  Lecture 2a - Part D1 - When an Exception is Thrown at Runtime

•  Lecture 2a - Part D2 - The Catch-or-Specify Requirement

•  Lecture 2a - Part E1 - To Handle or Not to Handle: Background

•  Lecture 2a - Part E2 - To Handle or Not to Handle: Version 1

•  Lecture 2a - Part E3 - To Handle or Not to Handle: Version 2

•  Lecture 2a - Part E4 - To Handle or Not to Handle: Version 3

•  Lecture 2a - Part F1 - Error Handling via Exceptions (Circle)

•  Lecture 2a - Part F2 - Error Handling via Exceptions (Bank)

•  Lecture 2a - Part G - Multiple Catch Blocks, Parsing Strings to Integers

 Intro

 Notes

• Slides
  • Lecture 2a: Exceptions
  • Lecture 2a: Exceptions [4-up]
• Questions?
  • Post Your Questions in this Document.
• 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
• Source Code
  • Circle and Bank
  • To Handle or Not to Handle

 Guide: Written Test 1

 Sep 29 (W3)

 Sep 30 (W3)

  Playlist for Week 4

•  Week 4 - Intro

•  Lecture 2a - Part A1 - Revisiting the Catch-or-Specify Requirement

•  Lecture 2a - Part A2 - Introducing the Bounded Counter Problem

•  Lecture 2a - Part B1 - Sketching the Design of Test Cases

•  Lecture 2a - Part B2 - ConsoleTester1: VTSE expected

•  Lecture 2a - Part B3 - ConsoleTester2: Correct Implementation

•  Lecture 2a - Part B4 - ConsoleTester2: Incorrect Implementations

•  Lecture 2a - Part B5 - Exercise and an Iterative Console Tester

•  Lecture 2a - Part C - Deriving Test Cases, Limitation of Console Testers

•  Lecture 2a - Part D1 - Automated Unit Testing via JUnit Assertions

•  Lecture 2a - Part D2 - Example JUnit Assertions

•  Lecture 2a - Part E1 - Testing for Legal Usage of the Counter Method

•  Lecture 2a - Part E2 - Testing for Illegal Usage of the Counter Method

•  Lecture 2a - Part E3 - Exercises and Using Loops in JUnit Tests

•  Lecture 2a - Part F - Regression Testing Visualized

 Intro

 Notes

• Slides
  • Lecture 2b: Test-Driven Development (TDD) with JUnit
  • Lecture 2b: Test-Driven Development (TDD) with JUnit [4-up]
• Questions?
  • Post Your Questions in this Document.
• Diagrams
  • Regression Testing Visualized
• Source Code
  • Testing Counter: Console vs. JUnit

 Guide: Programming Test 1

 Lab1 Solution Walk-Through

 Oct 6 (W4)

 Oct 7 (W4)

  Playlist for Week 5

•  Week 5 - Intro

•  Lecture 3 - Part A - To Override or Not to Override

•  Lecture 3 - Part B - V1: Default equals method

•  Lecture 3 - Part C1 - V2: Comparing References

•  Lecture 3 - Part C2 - V2: Dynamic Types

•  Lecture 3 - Part C3 - V2: Type Casting

•  Lecture 3 - Part C4 - V2: Example 1 & Debugger

•  Lecture 3 - Part C5 - V2: Example 2 & Comparison

•  Lecture 3 - Part D - assertSame vs. assertEquals in JUnit

•  Lecture 3 - Part E - Asserting Reference vs. Object Equality

•  Lecture 3 - Part F - (Optional Review) Short-Circuit Effect of Logical Operators

•  Lecture 3 - Part G1 - Exercise: equals for Single-Valued Attributes

•  Lecture 3 - Part G2 - Exercise: equals for Multi-Valued Attributes

•  Lecture 3 - Part H1 - Asserting Equality on Single-Valued Attributes

•  Lecture 3 - Part H2 - Asserting Equality on Multi-Valued Attributes

 Intro

 Notes

• Slides
  • Lecture 3: Object Equality
  • Lecture 3: Object Equality [4-up]
• Questions?
  • Post Your Questions in this Document.
• Source Code
  • Testing Equality: Points vs. Persons

 Guide: Written Test 2

 Oct 20 (W5)

 Oct 21 (W5)

  Playlist for Week 6

•  Lecture 4 - Part A1 - Call by Value: Definition & Manipulation

•  Lecture 4 - Part A2 - setRadius(int r) vs. setRadius(Circle c)

•  Lecture 4 - Part B1 - Example 1 - Re-Assigning Primitive Parameter

•  Lecture 4 - Part B2 - Example 2 - Re-Assigning Reference Parameter

•  Lecture 4 - Part B3 - Example 3 - Calling Mutator on Reference Parameter

•  Lecture 4 - Part C1 - Terminology - Container vs. Containee

•  Lecture 4 - Part C2 - Modelling vs. Implementing Aggregation

•  Lecture 4 - Part D1 - Building Aggregations: Course, Faculty

•  Lecture 4 - Part D2 - Building Aggregations: Course, Faculty, Student

•  Lecture 4 - Part E1 - Navigating Aggregations: Two Approaches

•  Lecture 4 - Part E2 - Navigating Aggregations: Switching Context

•  Lecture 4 - Part F1 - Composition - Shallow Copy Constructor

•  Lecture 4 - Part F2 - Composition - Deep Copy Constructor

•  Lecture 4 - Part G - Aggregation vs. Composition: More Examples

 Notes

• Slides
  • Lecture 4: Aggregation and Composition (Updated: Oct 24)
  • Lecture 4: Aggregation and Composition [4-up] (Updated: Oct 24)
• Questions?
  • Post Your Questions in this Document.
• Source Code
  • Call by Value: Primitive vs. Reference Argument Values

 Oct 27 (W6)

 Oct 28 (W6)

  Playlist for Week 7

•  Lecture 5 - Part A1 - SMS: from Requirements to Design

•  Lecture 5 - Part A2 - SMS: 1st Design (without Inheritance)

•  Lecture 5 - Part B - SMS: 2nd Design (without Inheritance)

•  Lecture 5 - Part C - Visibility: Project, Package, (Sub-)Class

•  Lecture 5 - Part D1 - SMS: 3rd Design - Use of extends and super

•  Lecture 5 - Part D2 - SMS: 3rd Design - Code Reuse & Visualization

•  Lecture 5 - Part E - Static Types, Code Reuse, Expectations

•  Lecture 5 - Part F1 - Intuition of Polymorphism

•  Lecture 5 - Part F2 - Intuition of Dynamic Binding

•  Lecture 5 - Part G1 - Multi-Level Inheritance Hierarchies

•  Lecture 5 - Part G2 - Type Hierarchy Formed by Inheritance

•  Lecture 5 - Part G3 - Exercise - Inheritance Accumulates Code

 Notes

• Slides
  • Lecture 5: Inheritance (up to Slide 41)
  • Lecture 5: Inheritance [4-up]
• Diagrams
  • Inheritance Hierarchy: Students
  • Multi-Level Inheritance Hierarchy: Students
  • Multi-Level Inheritance Hierarchy: Smart Phones
• Questions?
  • Post Your Questions in this Document.
• Source Code
  • Visibility: Project, Package, (Sub-)Classe
  • SMS: Design 2 (without inheritance) vs. Design 3 (with inheritance)

 Guide: Programming Test 2

 Lab2 Solution Walk-Through

 Lab3 Solution Walk-Through

 Nov 3 (W7)

 Nov 4 (W7)

  Playlist for Week 8

•  Lecture 5 - Part H1 - Static Types Determining Expectations

•  Lecture 5 - Part H2 - Rules of Substitutions (Assignments)

•  Lecture 5 - Part I1 - Dynamic Types: Re-Assigning to New Objects

•  Lecture 5 - Part I2 - Dynamic Types: Re-Assigning to Existing Objects

•  Lecture 5 - Part J1 - Motivation of Type Casting

•  Lecture 5 - Part J2 - Syntax of Type Cast, Named vs. Anonymous Casts

•  Lecture 5 - Part J3 - Compilable Casts: Upwards vs. Downwards

•  Lecture 5 - Part J4 - Compilable Casts Subject to ClassCastException

•  Lecture 5 - Part J5 - Visual Summary of Type Casting

•  Lecture 5 - Part J6 - Exercise: Compilation vs. Runtime of Type Casts

•  Lecture 5 - Part K - Checking Dynamic Type via instanceof

 Notes

• Slides
  • Lecture 5: Inheritance (Slide 42 to Slide 71)
  • Lecture 5: Inheritance [4-up]
• Required Readings
  • Static Types, Expectations, Dynamic Types, and Type Casts
• Questions?
  • Post Your Questions in this Document.
• Source Code
  • Reproduce the examples in slides.
  • See in Eclipse how compilation errors or runtime ClassCastException might occur.

 Nov 10 (W8)

 Nov 11 (W8)

  Playlist for Week 9

•  Lecture 5 - Part L - Static Types, Casts, Polymorphism

•  Lecture 5 - Part M1 - Polymorphic Parameters, Call by Value

•  Lecture 5 - Part M2 - Passing Casts as Method Call Arguments

•  Lecture 5 - Part M3 - A Polymorphic Collection of Students

•  Lecture 5 - Part N - Polymorphic Return Types

•  Lecture 5 - Part O - Type Checking, Dynamic Binding of equals/toString

 Notes

• Slides
  • Lecture 5: Inheritance (Slide 72 to 99)
  • Lecture 5: Inheritance [4-up]
• Required Readings
  • Static Types, Expectations, Dynamic Types, and Type Casts
• Diagrams
  • A Polymorphic Collection of Students
• Questions?
  • Post Your Questions in this Document.
• Source Code
  • Reproduce the examples in slides.
  • See in Eclipse how compilation errors or runtime ClassCastException might occur.
  • Example: Type Casts

 Nov 17 (W9)

  Playlist for Week 10

•  Lecture 6 - Part A1 - Abstract Class: Polygon Design Problem

•  Lecture 6 - Part A2 - Abstract Class: Alternative Design

•  Lecture 6 - Part A3 - Abstract Class: Using abstract

•  Lecture 6 - Part A4 - Abstract Class: Polymorphic Collection of Polygons

•  Lecture 6 - Part A5 - Abstract Class: Polymorphic Return Type of Polygons

•  Lecture 6 - Part B1 - Interface: 2D Points Design Problem

•  Lecture 6 - Part B2 - Interface: Using interface and implements

•  Lecture 6 - Part B3 - Interface: Exploring Dynamic Binding in Eclipse

•  Lecture 7 - Part A1 - Generics: A General Book and Exercise

•  Lecture 7 - Part A2 - Generics: Using instanceof and Casts for Retrievals

•  Lecture 7 - Part A3 - A General Book Violates Single Choice Principle

 Notes

• Slides
  • Lecture 6: Abstract Classes and Interfaces
  • Lecture 6: Abstract Classes and Interfaces [4-up]
  • Lecture 7: Generics in Java (up to Slide 9)
  • Lecture 7: Generics in Java [4-up]
• Questions?
  • Post Your Questions in this Document.
• Source Code
  • Example: Abstract Classes (Polygons)
  • Example: Interfaces (Points)
  • Example: Generics in Java (General Book)

 Guide: Written Test 3

 Nov 24 (W10)

 Nov 25 (W10)

  Playlist for Week 11

•  Lecture 7 - Part B - Generics in Java: Generic Book - Storage vs. Retrieval

•  Lecture 7 - Part C - Generics in Java: ArrayList, Hashtable, Exercise

 Notes

• Slides
  • Lecture 7: Generics in Java (Slide 10 to Slide 17)
  • Lecture 7: Generics in Java [4-up]
• Extra Studies
  • Using the generic ArrayList
  • Using the generic Hashtable
• Questions?
  • Post Your Questions in this Document.
• Source Code
  • Exercise: Generics in Java (General Book vs. Generic Book)

 Guide: Programming Test 3

 Lab4 Solution Walk-Through

  Playlist for Week 12

•  Lecture 8 - Part A1 - Thinking Recursively

•  Lecture 8 - Part A2 - Tracing Factorial, Common Recursion Errors

•  Lecture 8 - Part A3 - Tracing Fibonacci Number

•  Lecture 8 - Part B1 - Useful Methods on Strings

•  Lecture 8 - Part B2 - Recursion on Strings: Palindrome

•  Lecture 8 - Part B3 - Recursion on Strings: Reverse

•  Lecture 8 - Part B4 - Recursion on Strings: Occurrences

•  Lecture 8 - Part C1 - Recursions on Arrays: Specifying Sub-Ranges

•  Lecture 8 - Part C2 - Recursions on Arrays: All Positive?

•  Lecture 8 - Part C3 - Recursions on Arrays: Sorted?

 Notes

• Slides
  • Lecture 8: Recursion
  • Lecture 8: Recursion [4-up]
• Notes
  • Solving Problems Recursively
• Exercises
  • EECS2030-F19 Lab5 on Recursion (Only look at the solution here after you attempt these exercises)
  • CodingBat: Recursion 1
  • CodingBat: Recursion 2
• Questions?
  • Post Your Questions in this Document.
• Source Code
  • Recursion
    • factorial
    • fibonacci
    • palindrome
    • reverseOf
    • numberOfOccurrences
    • allPositive
    • isSorted

 Guide: Programming Test 3

 Lab4 Solution Walk-Through

 Guide: Final Exam