12:55

FTC 2023

03:59

Command Passing -The Interpreter design pattern

03:24

Command Passing - The Command design pattern

07:57

Algorithm Abstraction - Decorator applied to Chess

07:16

Command Passing -The Delegate design pattern

04:14

Object Creation - Applying the Factory to a Chess Program

10:39

Polymorphism - Relation between inheritance and polymorphism

10:58

Assert - Examples of good and bad assert placements

04:23

Unit Test - Use a Spy double to detect memory leaks

03:38

Trace - How using a trace can improve exam scores

03:38

Separation of Concerns - MVC

04:51

Trace - Creating a Trace Table with Complex Data

07:01

Debugger - How to fix a failed unit test

05:55

Trace - How to perform a program trace

05:15

Separation of Concerns - Integration

08:05

Trace - Using a Trace in a job interview

06:58

Unit Test - How to create and use a stub double

06:03

Efficiency - The different levels of algorithmic efficiency

04:12

Efficiency - Instrumenting code to determine efficiency

06:57

Unit Test - How to create and use a dummy double

05:55

Efficiency - How to identify the efficiency of an algorithm

04:13

Redundancy - Demonstration of reducing redundancy in a chess program

05:02

Message Passing - The Observer Design Pattern

04:40

Pseudocode - Demonstration of designing a function

12:44

Message Passing - The Visitor Design Pattern

04:43

Redundancy - How to classify the quality of an inheritance tree

05:45

Message Passing - The Chain of Responsibility Design Pattern

04:53

Pseudocode - How do design an algorithm using pseudocode

09:40

Message Passing - The Mediator Design Pattern

04:41

Decisions - How to simplify SWITCH/CASE statements

04:28

Decisions - How to simplify a multi-way IF statement

05:28

Decisions - How to Optimize a Two-way IF Statement

05:52

Alignment - Measuring Inheritance Design Quality

09:27

Decisions - How to simplify a Boolean Expression

04:26

Adaptability - Why Adaptability is an important design metric

08:10

Object Creation - The Decorator design pattern

04:39

Adaptability - Measuring Inheritance Design Quality

06:18

Object Creation - The Decorator design pattern

05:40

Flowchart - Designing an Algorithm

04:28

Object Creation - The Strategy design pattern

05:15

Object Creation - The Prototype design pattern

04:54

Object Creation - The Singleton design pattern

04:56

Functional - How to use map()

08:24

Object Creation - The Abstract Factory design pattern

06:19

Object Creation - The Builder Design Pattern

07:43

Object Creation - the Factory Design Pattern

05:50

Software Design - The slides accompanying the textbook

07:40

Software Design - Textbook features

07:19

Software Design Textbook

05:24

Functional - How to use Filter()

06:17

Assert - How to add assert to code

09:22

Maintainability - Characterizing and improving understandability

05:09

Bottom-Up - Demonstration of how to implement a design bottom up

05:57

Top Down - Creating stubs from a structure chart

07:23

Top-Down - Demonstration of the top-down design process

03:18

Loops - The sentinel-controlled loop

06:46

Bottom-Up - How to implement a software design bottom-up

02:27

Top-Down - The top-down design process

03:41

Collections - How to use an array for table lookup

04:10

Is a and Has a - Designing with Inheritance and Composition