Table of Contents

0. Table of Contents

Est 0 minutes

Topics

1. Course Overview and Introduction to Java

Est 70 minutes

Topics

• Understand the structure of this course and what will be expected of you every week (15 minutes)
• Review the Systematic Program Design and Implementation Process (10 minutes)
• Describe the context of Java in the historical development of OO languages and "run anywhere" technology/JIT runtimes (10 minutes)
• Compare the Java runtime environment to Python (10 minutes)
• Recognize Java syntax (10 minutes)
• Understand the difference between core datatypes in Java: primitives, objects and array (15 minutes)

2. Inheritance and Polymorphism in Java

Est 55 minutes

Required preparation

• Complete sets 1 and 2 of the Java syntax flashcards

Optional preparation

• Read Core Java Volume I: Fundamentals, Ch 3

Topics

• Describe why inheritance is a core concept of object-oriented programming (10 minutes)
• Define a type hierarchy and understand the relationship between superclasses and subclasses (10 minutes)
• Explain the role of interfaces and abstract classes in a Java class hierarchy (10 minutes)
• Describe the JVM's implementation of dynamic dispatch (10 minutes)
• Describe the difference between static methods and instance methods (5 minutes)
• Describe the JVM exception handling mechanism (5 minutes)
• Recognize common Java exceptions and when to use them (5 minutes)

3. Inheritance and Polymorphism in Java II

Est 45 minutes

Topics

• Review the role of inheritance and dynamic dispatch in Java (5 minutes)
• Describe the role of generics in the Collections API (10 minutes)
• Recognize and apply Java's core data structures (10 minutes)
• Describe the purpose of primitive wrapper types (5 minutes)
• Utilize Java methods for reading input and writing output to streams (15 minutes)

4. Specifications and Common Contracts

Est 53 minutes

Topics

• Describe the role of method specifications in achieving program modularity and improving readability (10 minutes)
• Evaluate the efficacy of a given specification using the terminology of restrictiveness, generality, and clarity (15 minutes)
• Utilize type annotations to express invariants such as non-nullness (5 minutes)
• Define the role of methods common to all Objects in Java

5. Functional Programming and Readability

Est 55 minutes

Topics

• Describe the historical context of functional programming in the JVM (10 minutes)
• Read and write Java code that uses functional programming (10 minutes)
• Compare the readability of Java code that uses functional vs OO styles
• Utilize modern Java features for readability
• Describe common misconceptions about what makes code "readable" and draw on evidence-based research to evaluate the readability of code

6. Changeability I: Modularity and Information Hiding

Est 57 minutes

Topics

• Describe the importance of changeability as a goal of program design and implementation (10 minutes)
• Describe the relevance of modularity to changeability (5 minutes)
• Describe the role of information hiding and immutability in enabling effective modularity (5 minutes)
• Be able to apply Java language features to achieve information hiding and immutability

7. Changeability II: Coupling and Cohesion

Est 55 minutes

Topics

• Analyze the changeability of a software module for some hypothetical change using the language of coupling and cohesion (10 minutes)
• Define and recognize cases of data coupling, stamp coupling, control coupling, common coupling and content coupling (20 minutes)
• Define and recognize cases of coincidental, logical, temporal, procedural, communication, sequential, and functional cohesion (15 minutes)
• Use the vocabulary of coupling and cohesion to review the Strategy pattern (10 minutes)

8. Changeability III: Principles for inheritance

Est 60 minutes

Topics

• Other design principles related to changeability: SOLID (20 minutes)
• Describe why to favor composition over inheritance by default (10 minutes)
• Describe rules for safely implementing inheritance (5 minutes)
• Define the decorator method pattern and its relationship to design for change (15 minutes)
• Identify cases where inheritance is preferred over other implementation tricks (10 minutes)

9. Interpreting Requirements

Est 55 minutes

Topics

• Explain the overall purpose of requirements analysis (10 minutes)
• Enumerate and explain 3 major dimensions of risk in requirements analysis (15 minutes)
• Identify the stakeholders of a software module, along with their values and interests (15 minutes)
• Describe methods to elicit users' requirements (15 minutes)
• Summary

10. Review

Est 60 minutes

Topics

• Review the first third of the course in advance of the first exam (60 minutes)

11. Exam 1

Est 60 minutes

Topics

• Placeholder for Exam 1 (60 minutes)

12. Domain Modeling

Est 55 minutes

Topics

• Introduction: Object-oriented design and the challenge of understandability (5 minutes)
• Formulate a domain model given requirements (15 minutes)
• Validate domain models with stakeholders (5 minutes)
• Translate a domain model into an object-oriented design using responsibility assignment heuristics (20 minutes)
• Evaluate the representational gap between a domain model and an object-oriented design (10 minutes)
• Summary

13. Introduction to AI Programming Agents

Est 45 minutes

Topics

• Define AI programming agents and enumerate their capabilities (10 minutes)
• A high-level workflow for using AI programming agents (5 minutes)
• Determine when it is appropriate to use an AI programming agent (5 minutes)
• Example: using AI programming agents to prototype a new project (25 minutes)
• SceneItAll - Domain Model Alternatives

14. Program Understanding & Debugging

Est 55 minutes

Topics

• Situate debugging within the software development lifecycle (5 minutes)
• Utilize control flow and data flow analysis to understand a program (10 minutes)
• Utilize diagrams to visualize control and data flow (5 minutes)
• Describe the scientific method of debugging (15 minutes)
• Utilize a debugger to step through a program and inspect state (10 minutes)
• Utilize an AI programming agent to assist with debugging (10 minutes)

15. Test Doubles and Isolation

Est 55 minutes

Topics

• Distinguish between unit, integration, and end-to-end tests (10 minutes)
• Explain the challenge of testing code with external dependencies (5 minutes)
• Differentiate between stubs, fakes, and spies as types of test doubles (10 minutes)
• Apply mocking frameworks to generate test doubles (10 minutes)
• Evaluate the tradeoffs of using test doubles (10 minutes)
• Apply AI coding assistants to generate test plans and test doubles (10 minutes)

16. Designing for Testability

Est 55 minutes

Topics

• Evaluate the testability of a software module and propose changes to improve its testability (20 minutes)
• Explain the Hexagonal Architecture and its relationship to testability (15 minutes)
• Describe general properties of "good" test suites (10 minutes)
• Recognize common anti-patterns that lead to untestable code (10 minutes)

17. From Code Patterns to Architecture Patterns

Est 50 minutes

Topics

• Review the creation patterns you have already implemented (5 minutes)
• Evaluate the tradeoffs in readability, reusability, and changeability between object creation patterns in Java (15 minutes)
• Describe Dependency Injection as a solution to the problems of Singleton (10 minutes)
• Compare Service Locator and Dependency Injection patterns (10 minutes)
• Recognize how code-level patterns manifest at larger architectural scales (10 minutes)

18. Thinking Architecturally

Est 60 minutes

Topics

• Define software architecture and distinguish it from design (8 minutes)
• Identify architectural drivers that shape decisions (10 minutes)
• Determine service/module boundaries and design good interfaces (20 minutes)
• Communicate architecture through diagrams and documentation (12 minutes)
• Compare upfront planning with piecemeal growth (10 minutes)

19. Architectural Styles: From Hexagons to Monoliths

Est 0 minutes

Topics

• Learning Objectives
• How Do We Organize Our Code?
• The Monolith: Where Most Projects Start
• Technical vs. Domain Partitioning
• Quality Attributes: The "-ilities"
• Architectural Styles vs. Patterns
• Continuing Our Running Examples: Pawtograder and Bottlenose
• Hexagonal Architecture in Pawtograder
• Other Common Architectural Styles
• Two Big Families: Monolith vs. Microservices
• Architecture and Quality Attributes

20. Distributed Architecture: Networks, Microservices, and Security

Est 0 minutes

Topics

• Learning Objectives
• Recap: Why Leave the Monolith?
• Client-Server Architecture
• How Services Communicate: REST APIs
• The Fallacies of Distributed Computing
• Microservices Architecture
• Network-Related Requirements and Patterns
• Security as an Architectural Concern
• Bringing It Together: From Monolith to Microservices

21. Serverless Architecture

Est 55 minutes

Topics

• Recognize common infrastructure building blocks (15 minutes)
• Define "serverless" architecture and its core concepts (5 minutes)
• Compare serverless to traditional architectures (10 minutes)
• Requirements suited (and unsuited) for serverless (10 minutes)
• Connection to Earlier Concepts (5 minutes)
• Choosing an Architecture: A Decision Framework (10 minutes)

22. Teams and Collaboration

Est 60 minutes

Topics

• Explain key advantages of working in a team and sharing information with your team (10 minutes)
• Describe the stages of team formation and strategies for establishing productive working agreements (15 minutes)
• Describe the HRT pillars of social interaction and strategies for resolving team conflicts (10 minutes)
• Seeking and receiving feedback effectively (5 minutes)
• Write clear and specific GitHub issues, pull requests, and comments (10 minutes)
• Ask technical questions effectively (10 minutes)

23. Open Source Frameworks

Est 40 minutes

Topics

• Explain how component reuse simplifies software development and the role of OSS ecosystems in distributing reusable components (15 minutes)
• Describe the role and impact of "copyleft" licenses on OSS (10 minutes)
• Describe tradeoffs that should be considered when adopting a library or framework (15 minutes)

24. Usability

Est 50 minutes

Topics

• Define usability and describe the five key aspects of usability (15 minutes)
• Identify stakeholders and their usability concerns (10 minutes)
• Recognize the relationship between usability and safety (5 minutes)
• Introduce approaches to evaluating usability (5 minutes)
• Apply Nielsen's 10 Usability Heuristics to evaluate an interface (15 minutes)

25. Review 2

Est 0 minutes

Topics

• Review content from the last 10 lectures for the second midterm exam

26. Exam 2

Est 60 minutes

Topics

• Exam (60 minutes)

27. User-Centered Design

Est 45 minutes

Topics

• Describe the value of user-centered design in software development (10 minutes)
• Describe the UCD process: prototyping and evaluation for usability (20 minutes)
• Apply UCD as a requirements elicitation technique (15 minutes)

28. Accessibility and Inclusivity

Est 45 minutes

Topics

• Describe common accessibility and inclusivity requirements and their importance (25 minutes)
• Evaluate the validity of an accessibility evaluation (20 minutes)

29. GUIs in Java

Est 55 minutes

Topics

• Describe the historical context of GUI development in Java (10 minutes)
• Review event-driven programming and the callback model (10 minutes)
• Define the Model-View-Controller (MVC) pattern (15 minutes)
• Create a simple GUI application using JavaFX and Scene Builder (20 minutes)

30. GUI Patterns and Testing

Est 55 minutes

Topics

• Define the Model-View-ViewModel (MVVM) pattern (15 minutes)
• Compare and contrast MVC with MVVM patterns (10 minutes)
• Explain why separation of concerns makes GUIs testable units (10 minutes)
• Write end-to-end tests for a GUI application using TestFX (20 minutes)

31. Concurrency I: Threads and Synchronization

Est 60 minutes

Topics

• Describe the role of threads as a concurrency mechanism and understand the concept of "interrupts" (15 minutes)
• Recognize the need for synchronization in concurrent programs and understand the concept of "atomicity" (15 minutes)
• Utilize locks and concurrent collections to implement basic thread-safe code (15 minutes)
• Understand the concept of "deadlocks" and "race conditions" (15 minutes)

32. Concurrency II: Asynchronous Programming

Est 45 minutes

Topics

• Compare and contrast the use of threads and asynchronous programming (10 minutes)
• Understand the concept of "blocking" and "non-blocking" operations (5 minutes)
• Utilize futures to implement asynchronous programming in Java (15 minutes)
• Evaluate the safety of asynchronous functions (15 minutes)

33. Event-Driven Architecture

Est 43 minutes

Topics

• Describe the Observer pattern and how it reduces coupling (5 minutes)
• Define and describe the event-driven architecture (12 minutes)
• Describe the role of event brokers and evaluate delivery guarantees (8 minutes)
• Define "consistency models" and determine the appropriate consistency model for a given software requirement (10 minutes)
• Describe common patterns in event-driven architecture (8 minutes)

34. Performance

Est 60 minutes

Topics

• Reason about algorithmic growth using Big-O notation (10 minutes)
• Identify performance bottlenecks: measure, don't guess (5 minutes)
• Analyze the performance impact of architectural decisions (15 minutes)
• Apply common patterns to improve performance (15 minutes)
• Understand garbage collection and automatic memory management (10 minutes)
• Performance and sustainability (5 minutes)

. L34 Technical Interviews

Est 0 minutes

Topics

. L35 Java Puzzlers

Est 0 minutes

Topics

35. Safety and Reliability

Est 68 minutes

Topics

• Distinguish safety from reliability and explain why both are architectural drivers (12 minutes)
• Apply the Swiss cheese model to analyze layered defenses (13 minutes)
• Analyze blast radius and fail-safe design in your own systems (15 minutes)
• Recognize prior course concepts as safety mechanisms (12 minutes)
• Connect safety to sustainability (8 minutes)
• Evaluate safety trade-offs and explain why professional judgment is currently the primary safety mechanism in most software (8 minutes)

. L36 Kotlin: A Better Java

Est 0 minutes

Topics

36. Sustainability

Est 50 minutes

Topics

• Define software sustainability as a meta-quality attribute and connect it to the semester's recurring themes (10 minutes)
• Apply the four dimensions of sustainability to evaluate design trade-offs in familiar systems (12 minutes)
• Recognize how efficiency gains can increase total resource consumption, and identify cascading effects of design decisions (10 minutes)
• Evaluate who benefits and who bears risk in software design trade-offs (18 minutes)

37. Design Case Study: MapReduce

Est 50 minutes

Topics

• Describe the MapReduce programming model and the Google File System at the level needed to analyze their design decisions (10 minutes)
• Analyze MapReduce and GFS architectural decisions using quality attributes from the course (15 minutes)
• Identify how MapReduce and GFS apply patterns learned throughout the semester (15 minutes)
• Evaluate sustainability and trade-off dimensions of MapReduce and GFS design decisions (10 minutes)

38. The Future of Programming

Est 50 minutes

Topics

• Analyze what AI coding tools actually change about software engineering — and what they don't (15 minutes)
• Evaluate the real-world evidence on AI-assisted development and identify when AI helps vs. hinders (20 minutes)
• Identify durable skills and concrete next steps for continuous learning (15 minutes)

39. Final Exam Review

Est 0 minutes

Topics

• TODO