Advanced Projects¶

Ten projects of one to three weeks each. They are the tier where the design is the deliverable as much as the program: each one forces at least one named design-pattern decision, requires a multi-file layout with persistence or a documented input, and is marked on whether the structures you chose survive a change you did not anticipate.

Every project here requires all seven integration elements — multiple classes, relationships between classes, encapsulation, inheritance or composition, polymorphism, the STL, exception handling — and at least one design-pattern decision you must make, name in your report, and justify against the alternative you rejected.

No complete solutions are provided, and that matters most here. If you read a solution to an advanced project you have practised reading, not designing.

The ten projects¶

#	Project	Difficulty	Effort	Patterns it demands	What it really tests
1	Chess Engine Core	Advanced	2–3 weeks	Factory, Command	Modelling a rule-heavy domain without a rule switchboard
2	Spreadsheet Engine	Advanced	2–3 weeks	Composite, Observer	Recalculation as a dependency problem, not a loop
3	Task Scheduler	Advanced	2 weeks	Strategy, Template Method	Ordering under constraints, with cycles refused
4	Document Conversion Pipeline	Advanced	2 weeks	Chain of Responsibility, Abstract Factory	A pipeline whose stages are replaceable
5	Elevator Simulation	Advanced	2–3 weeks	State, Strategy	Time, events and state transitions kept honest
6	Policy-Based Cache	Advanced	2 weeks	Policy-based design, Decorator	Genericity that stays readable
7	Campus Navigation	Advanced	2 weeks	Strategy, Observer	Two routing policies over one graph, editable at run time
8	Plugin Command Runner	Advanced	2 weeks	Factory, Registry, Command	Extension without touching the host
9	Serialization Framework	Advanced	2–3 weeks	Visitor, Factory	Round-tripping arbitrary objects, safely
10	Component Game Engine	Advanced	3 weeks	Observer, Composite, Command	A frame loop over owned, polymorphic objects

What every advanced project requires¶

A multi-file layout with public headers that depend on nothing internal, and a documented build command.
At least two design patterns, each named in the report with the requirement that earned it — and one pattern considered and declined, with the reason. Declining a pattern on purpose is marked as highly as using one.
A persistence or input format with a version marker and a documented round trip.
A test suite with assertions, covering invariants, boundaries and failure paths, including one deliberate bug introduced to prove the suite notices it.
A UML class diagram matching the code, with multiplicities and ownership marked.
A design note of one to two pages naming the decisions, the costs accepted, the alternatives rejected, and one decision you would reverse, with what reversing it would cost.
No warnings with g++ -std=c++17 -Wall -Wextra -Werror.

The seven integration elements, once more¶

Requirement	What "yes" looks like
Multiple classes	Eight or more types with single responsibilities; none is a namespace in disguise
Relationships	Composition, aggregation and association, each named in the diagram with a reason
Encapsulation	Invariants unreachable from outside; the arrow of dependency points inward
Inheritance or composition	Interfaces where behaviour varies; inheritance only for genuine substitution
Polymorphism	Dispatch through interfaces, with no type tags in the core logic
The STL	Containers and algorithms doing the work, each chosen for a stated reason
Exception handling	A documented failure policy, with every guarantee tested rather than asserted

How to choose¶

Choose by the difficulty you want to spend two weeks on, not by the domain you like:

If you want to practise	Choose
Rules with exceptions to the rules	Chess Engine, Spreadsheet
Dependency and change propagation	Spreadsheet, Campus Navigation
Ordering and constraint solving	Task Scheduler
Replacement of pipeline stages	Document Conversion, Plugin Command Runner
Time, events and states	Elevator Simulation, Component Game Engine
Genericity that stays readable	Policy-Based Cache, Serialization Framework
Extension without editing the host	Plugin Command Runner, Document Conversion

Do not attempt an advanced project before finishing the middle of the course. Modules 11 to 15 are the prerequisites for this tier in practice, not merely on paper: you will be working with smart pointers, templates, exceptions, algorithms and patterns simultaneously.

How to work¶

Write the design note's skeleton first — class list, relationships, and the two patterns you expect to need. Expect it to be wrong; that is the point of writing it early.
Build the smallest correct core, with no patterns, and get a test to pass.
Then introduce the pattern where the variation actually appeared, and record why.
Introduce one deliberate bug, confirm the suite catches it, then fix it and keep the test.
Reverse one decision at the end, and write down the cost. This is the item that distinguishes an advanced submission from a large intermediate one.