Jackie's Lectures

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

• 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

•

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

• 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

•

• 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

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