Modern C++ Capstone Projects

Capstone workflow

Build each project as a sequence of vertical milestones. Start with a one-page brief naming the user, problem, non-goals, inputs, outputs, constraints, and acceptance tests. Draw the ownership map and identify untrusted boundaries before choosing classes or libraries.

# Project brief
User outcome: What can a real user accomplish?
Inputs/trust: Which arguments, files, network data, or callbacks are untrusted?
Core contracts: What must always be true?
Non-goals: What will this version deliberately not do?
Ownership map: Who owns each long-lived resource and task?
Failure policy: Which errors are recoverable and how are they reported?
Acceptance: Which automated and manual scenarios prove completion?
Evidence: Which benchmark, sanitizer, portability, or release artifact will be published?

Projects 1–2: reliable values and objects

Project 1: validated command-line application. Build an expense tracker, unit converter, habit log, or text analyzer. Parse every argument, model units with types, persist data through safe replacement, and return meaningful process exit codes.

Project 2: object-oriented simulation or management system. Build a transit simulation, reservation system, library manager, or board game. Center the design on invariants and behavior; use composition by default and runtime polymorphism only for a real open extension point.

• No raw owning pointers
• No silent input fallback
• One command builds and runs tests
• README includes example workflows and limitations

Projects 3–4: STL and generic design

Project 3: data-processing and filesystem utility. Create a duplicate finder, log analyzer, photo organizer, or source metrics tool. Traverse paths safely, stream large inputs, use algorithms and ranges, and produce deterministic machine-readable and human-readable output.

Project 4: reusable generic library. Implement a small algorithms library, fixed-capacity collection, graph traversal toolkit, units type, or validated result utilities. Constrain templates with concepts and test multiple types, boundary sizes, iterator categories, exception safety, and compile-time use where relevant.

project/
  CMakeLists.txt
  cmake/
  include/project/        # public headers
  src/                    # non-template implementation
  tests/                  # unit, property, regression
  examples/               # minimal consumer programs
  benchmarks/             # measured questions, not demos
  docs/                    # contracts and design decisions

Project 5: concurrent or asynchronous system

Build a task processor, parallel indexer, thumbnail pipeline, chat relay, or asynchronous downloader using an established library where networking is involved. Document thread and task ownership, queue backpressure, shutdown order, cancellation, error propagation, and the synchronization protecting each invariant.

Producer owns input enumeration.
Queue owns pending Job values and has a maximum capacity.
Workers are scoped jthreads owned by Processor.
Each Job owns its input path and output destination.
Stop request closes intake, wakes waiters, and lets in-flight jobs reach a safe point.
First fatal error is stored; shutdown joins all workers before resources die.
Metrics are atomic counters only; multi-field state remains mutex-protected.

• Compare one-thread and multi-thread throughput on representative work
• Test empty input, saturation, worker failure, cancellation, and shutdown races
• Run ThreadSanitizer on supported configurations
• Report speedup, p95 latency, CPU use, and contention—not only average throughput

Project 6: professional C++ product

Combine the course in a substantial multi-file product: an offline search engine, asset pipeline, package inspector, embedded simulator, database-like store, or cross-platform desktop core. Publish a stable domain API, isolate platform detail, and include at least one externally consumed library target plus a real application.

cmake_minimum_required(VERSION 3.24)
project(portfolio_product VERSION 1.0.0 LANGUAGES CXX)

option(PRODUCT_BUILD_TESTS "Build tests" ON)
option(PRODUCT_BUILD_BENCHMARKS "Build benchmarks" OFF)

add_subdirectory(src/core)
add_subdirectory(apps/cli)

if(PRODUCT_BUILD_TESTS)
  enable_testing()
  add_subdirectory(tests)
endif()

if(PRODUCT_BUILD_BENCHMARKS)
  add_subdirectory(benchmarks)
endif()

Review rubric and presentation

Review each milestone as if you were maintaining it for two years. Score contracts, ownership, tests, errors, readability, build reproducibility, security, performance evidence, portability, and documentation. A polished portfolio page explains the problem, constraints, architecture, hard decisions, measured result, and what you would change next.

- [ ] Clean clone configures with documented prerequisites
- [ ] Strict-warning build passes on the compiler matrix
- [ ] Unit, integration, and regression tests pass
- [ ] Sanitizer and static-analysis jobs pass
- [ ] Package installs and a clean consumer links against it
- [ ] Benchmarks include method and baseline
- [ ] README examples match the released command line/API
- [ ] Changelog, version, license, checksums, and known limitations are present