What to Learn Next & Final Checklist

Where to go after this course, and a checklist to confirm you have mastered every topic.

OOP Glossary

A type definition: data plus operations Object / instance A run-time value of a class, with state and identity Field / attribute Data stored in an object Method / member function An operation defined by a class

A request to an object to perform an operation (a method call)

A named set of operations without implementation Exposing essential operations and hiding details

Protecting state behind operations that keep invariants Defining a type as a specialisation of another One interface, many implementations

Choosing the method implementation at run time from the object's type

Same name, different parameters (compile-time choice) Derived class replaces a virtual method (run-time choice) Constructor / destructor

Establishes invariants at creation / releases resources at the end of life

A condition that always holds for an object between operations Coupling / cohesion

Dependence between modules / relatedness within a module Composition / aggregation / association / dependency

Owns / has (independent) / knows / uses temporarily Generic / template Code parameterised by types

Hiding concrete types behind a uniform interface with value semantics

Resource lifetime tied to object lifetime Inspecting and manipulating program structure at run time State cannot change after construction

SRP, OCP, LSP, ISP, DIP design principles A named solution to a recurring design problem with trade-offs

Objects representing business concepts and rules A consistency boundary of objects changed through a root

A boundary within which one model and language apply

Pattern Selection Guide

Create behind an abstraction Factory Method / Abstract Factory Construct complex objects incrementally Adapt an incompatible API Add behaviour by wrapping Simplify a subsystem Control access or lazy loading Observer / publish–subscribe Represent an undoable request Change behaviour by internal state Traverse a collection Share state among many logical objects

Separate abstraction from implementation Represent part–whole trees Add operations to a stable structure Fail fast on a failing dependency

This is a starting guide, not a mandate to use a pattern.

Design Review Checklist

Does each class have a clear purpose?

Is mutable state protected by meaningful invariants?

Are dependencies explicit?

Is inheritance substitutable, or would composition be simpler?

Are interfaces focused?

Do constructors leave objects valid?

Are resource lifetimes explicit?

Are errors represented consistently?

Can behaviour be tested without global state?

Are patterns solving real problems?

Is abstraction proportional to requirements?

Are concurrency guarantees documented?

Are public APIs stable and understandable?

Assessment Types

Concept quiz, trace object state, predict output, find invalid invariants, implement a class, refactor procedural code, identify an LSP violation, choose and justify a pattern, draw UML, write tests, review a pull request, design under changing requirements, compare language behaviour, explain performance/lifetime trade-offs.

Recommended Teaching Sequence

Paradigms, classes, objects, fields, methods (Modules 1–2).

Encapsulation, abstraction, constructors (3–5).

Inheritance, overriding, polymorphism (6–8).

Relationships, interfaces, UML (9, 23–24).

Lifetime, copying, memory, exceptions (10–14).

Generics, operator behaviour, domain types (15–18).

SOLID, coupling/cohesion, DI (19–22).

OOAD and design patterns (25–51).

Testing, refactoring, security, performance (52–54, 64–70).

Runtime mechanics and language tracks (55–63, 77–82).

Architecture, DDD, distributed design (71–76).

Projects and interviews (83–89).

What to Learn Next

Domain-Driven Design in depth: Eric Evans' *Domain-Driven Design* and Vaughn Vernon's *Implementing Domain-Driven Design*.

Refactoring: Martin Fowler's *Refactoring* (2nd edition) and Michael Feathers' *Working Effectively with Legacy Code*.

Patterns: the GoF book, Fowler's *Patterns of Enterprise Application Architecture*, Nygard's *Release It!*.

Language depth: *Effective Modern C++*, *Effective Java*, *C# in Depth*, *Fluent Python*, *Effective TypeScript*.

Architecture: *Clean Architecture*, *Software Architecture: The Hard Parts*, C4 modelling.

On EngiLipi: the C++, C#, Java, Python and TypeScript language courses, *OS & Computer Architecture* for what objects become in memory, and the CAN course for an embedded domain to model.

Final OOP Course Checklist

[ ] I can explain the four pillars with one coherent example and name each one's misuse.

[ ] I can write a class whose constructor and operations protect its invariants.

[ ] I know when to use inheritance and when composition, and can spot LSP violations.

[ ] I can predict construction/destruction order, slicing and dispatch behaviour in C++.

[ ] I apply RAII and the Rule of Zero; I can implement the Rule of Five correctly when needed.

[ ] I choose between exceptions and result types and can give the strong guarantee.

[ ] I can model a domain with entities, value objects and aggregates.

[ ] I can apply SOLID, DI and the common patterns — and argue against them when they don't fit.

[ ] I can draw class, sequence and state diagrams that match my code.

[ ] I write deterministic unit tests with appropriate doubles and contract tests.

[ ] I can reason about concurrency, async lifetimes and distributed failures in OO designs.

[ ] I can explain the main OO differences between C++, Java, C#, Python and TypeScript.

[ ] I can run a design interview end to end: clarify, model, code, test, discuss trade-offs.