Strengthen cross-language notes and checkpoint smoke

Author: lucasbellesi

languages/cpp/01-foundations/functions/README.md

@@ -38,6 +38,12 @@ g++ -std=c++17 -Wall -Wextra -pedantic example/function-overload-basics.cpp -o f
 - Missing `const` in read-only reference parameters.
 - Missing return values in non-`void` functions.
 
+## Cross-Language Notes
+
+- C++ is the baseline for overloads, parameter passing choices, and return-type declarations as distinct language features.
+- Compared with Python, Go, and TypeScript, function signatures carry more control over value and reference behavior.
+- The main comparison is how much semantic weight each language puts on a function declaration.
+
 ## Exercise Focus
 
 - `exercises/01.cpp`: return max of three integers.

languages/cpp/01-foundations/types-and-io/README.md

@@ -38,6 +38,12 @@ g++ -std=c++17 -Wall -Wextra -pedantic example/input-validation-loop.cpp -o type
 - Assuming numeric input always succeeds.
 - Forgetting to check ranges for user input.
 
+## Cross-Language Notes
+
+- C++ is the canonical baseline here: types are explicit and stream state matters immediately when input goes wrong.
+- Compared with Python and TypeScript, this track forces you to think earlier about conversion failures and mixed text and numeric reads.
+- The recurring comparison is compile-time type safety versus runtime parsing flexibility.
+
 ## Exercise Focus
 
 - `exercises/01.cpp`: read `N` numbers and compute sum, average, min, max.

languages/cpp/02-core/file-io-basics/README.md

@@ -38,6 +38,12 @@ g++ -std=c++17 -Wall -Wextra -pedantic example/csv-like-reader.cpp -o file_io_cs
 - Not handling malformed lines.
 - Forgetting to close output files (or relying on scope without understanding it).
 
+## Cross-Language Notes
+
+- C++ is the baseline for stream-oriented file I/O and manual parse loops over text lines.
+- Compared with Python and TypeScript, the file APIs are less compact but make the flow of reading and writing more explicit.
+- The key comparison is low-level control versus concise file-processing ergonomics.
+
 ## Exercise Focus
 
 - `exercises/01.cpp`: copy lines with line numbers.

languages/cpp/03-advanced/copy-and-move-semantics/README.md

@@ -34,6 +34,12 @@ g++ -std=c++17 -Wall -Wextra -pedantic example/main.cpp -o copy_move_example
 - Implementing custom resource types without rule-of-five awareness.
 - Accidental copies in performance-sensitive paths.
 
+## Cross-Language Notes
+
+- C++ is the canonical version: copy and move are real language-level semantics with direct performance and ownership consequences.
+- Other tracks adapt this topic because most of them do not have true move semantics in the same sense.
+- Use this module as the anchor for every later comparison about aliasing and transfer.
+
 ## Exercise Focus
 
 - `exercises/01.cpp`: resource-owning buffer with copy and move.

languages/cpp/03-advanced/inheritance-and-polymorphism/README.md

@@ -38,6 +38,12 @@ g++ -std=c++17 -Wall -Wextra -pedantic example/polymorphic-menu.cpp -o inheritan
 - Calling derived-only APIs through base interfaces.
 - Object slicing with pass-by-value base types.
 
+## Cross-Language Notes
+
+- C++ is the baseline for virtual dispatch, abstract interfaces, and explicit ownership of polymorphic objects.
+- Other tracks keep the same idea of common behavior through a shared contract, but often reduce the amount of machinery required.
+- The comparison to watch is how each language balances power, safety, and ceremony in polymorphic design.
+
 ## Exercise Focus
 
 - `exercises/01.cpp`: extend shape hierarchy with `Triangle`.

languages/cpp/assessments/01-foundations/README.md

@@ -56,6 +56,12 @@ Lowest: Bob Lee (55)
 Passed: 2/3
 ```
 
+## Cross-Language Notes
+
+- This is the canonical first assessment for structured input, storage, and summary accuracy.
+- Compared with other tracks, it exposes the most detail around basic console handling and value management.
+- Use it as the baseline for comparing beginner-level discipline across runtimes.
+
 ## What To Check
 
 - full names are preserved exactly as entered

languages/cpp/assessments/02-core/README.md

@@ -41,6 +41,12 @@ g++ -std=c++17 -Wall -Wextra -pedantic main.cpp -o assessment_02_core
 - Only values in `0..100` are used for statistics and frequency table.
 - If no valid values are entered, print a friendly message and still create the report file.
 
+## Cross-Language Notes
+
+- This is the canonical validation-and-counting assessment for the core level.
+- Compared with the other tracks, it keeps the most explicit control over parse flow, ranges, and report generation.
+- Use it to compare how each runtime expresses the same defensive-programming goal.
+
 ## What To Check
 
 - out-of-range or malformed values do not pollute the valid-score summary

languages/cpp/assessments/03-advanced/README.md

@@ -37,7 +37,14 @@ Shape areas:
 Total area: ...
 Minimum area: ...
 Maximum area: ...
+Sample counts: [...]
+Computed areas: [...]
 ```
+## Cross-Language Notes
+
+- This is the canonical advanced assessment for abstraction, polymorphism, and generic reuse in one program.
+- Compared with the other tracks, it ties those ideas most directly to explicit ownership and compile-time templates.
+- Use it as the baseline when comparing what advanced abstraction looks like in each language.
 
 ## What To Check
 

languages/cpp/projects/01-foundations/README.md

@@ -63,6 +63,12 @@ Maximum: 91
 - Accepting invalid scores without retrying.
 - Dividing by zero when no students are provided.
 
+## Cross-Language Notes
+
+- This capstone is the canonical first integration point for validated input, record storage, and summary statistics.
+- Compared with the scripting-friendly tracks, C++ makes mixed text and numeric input plus container handling more explicit.
+- Use it as the baseline for how the same learner goal looks under stricter compile-time control.
+
 ## What To Check
 
 - invalid score input is rejected or retried without corrupting later reads

languages/cpp/projects/02-core/README.md

@@ -44,6 +44,12 @@ Minimum: 77
 Maximum: 91
 ```
 
+## Cross-Language Notes
+
+- This is the canonical file-processing checkpoint: parse rows, reject malformed input, and write a report deterministically.
+- Compared with higher-level tracks, C++ exposes more of the mechanics of streams and parse loops.
+- The useful cross-language question is how much library convenience changes the same defensive workflow.
+
 ## What To Check
 
 - malformed rows are skipped or counted without crashing the program