Complete expert module parity across languages

Author: lucasbellesi

LANGUAGE_PARITY_MATRIX.md

@@ -3,7 +3,7 @@
 This matrix tracks module and checkpoint parity across C++, C#, Go, and Python.
 
 - Canonical order is defined by the C++ track.
-- Current priority is to extend checkpoint parity beyond `02-core` without fragmenting the curriculum.
+- Current priority is to extend checkpoint parity beyond `02-core` now that module parity reaches `04-expert` across all active tracks.
 - Status labels:
   - `Done`: module implemented with example, exercises, and README.
   - `Planned`: module not implemented yet, already queued in order.
@@ -42,9 +42,9 @@ Current parity progress in non-C++ tracks:
 
 Current parity progress in non-C++ tracks:
 
-- C#: `5/5` modules complete in `03-advanced`
-- Go: `5/5` modules complete in `03-advanced`
-- Python: `5/5` modules complete in `03-advanced`
+- C#: `5/5` modules complete in `03-advanced`, `5/5` in `04-expert`
+- Go: `5/5` modules complete in `03-advanced`, `5/5` in `04-expert`
+- Python: `5/5` modules complete in `03-advanced`, `5/5` in `04-expert`
 
 ### Advanced (`03-advanced`) - Current Expansion Queue
 
@@ -56,17 +56,17 @@ Current parity progress in non-C++ tracks:
 | 4 | inheritance-and-polymorphism | Done | Done | Done | Done |
 | 5 | templates-basics | Done | Done | Done | Done |
 
-`04-expert` has started in C# with `memory-management-and-raii`, `concurrency-basics`, and `modularization-and-build-structure`; broader expert parity is still planned.
+`04-expert` is now implemented across C#, Go, and Python; the next parity target is projects and assessments beyond `02-core`.
 
-### Expert (`04-expert`) - Early Expansion
+### Expert (`04-expert`)
 
 | Order | Module | C++ | C# | Go | Python |
 | --- | --- | --- | --- | --- | --- |
-| 1 | memory-management-and-raii | Done | Done | Planned | Planned |
-| 2 | smart-pointers-in-depth | Done | Planned | Planned | Planned |
-| 3 | concurrency-basics | Done | Done | Planned | Planned |
-| 4 | performance-and-profiling-basics | Done | Planned | Planned | Planned |
-| 5 | modularization-and-build-structure | Done | Done | Planned | Planned |
+| 1 | memory-management-and-raii | Done | Done | Done | Done |
+| 2 | smart-pointers-in-depth | Done | Done | Done | Done |
+| 3 | concurrency-basics | Done | Done | Done | Done |
+| 4 | performance-and-profiling-basics | Done | Done | Done | Done |
+| 5 | modularization-and-build-structure | Done | Done | Done | Done |
 
 ## Checkpoint Parity
 

README.md

@@ -25,9 +25,9 @@ This repository teaches programming through small runnable examples and focused
 | Language | Current Levels | Coverage | Track Status |
 | --- | --- | --- | --- |
 | C++ | 00-setup, 01-foundations, 02-core, 03-advanced, 04-expert | Foundations, Core, Advanced, Expert, projects, assessments | Most complete and primary track |
-| C# | 01-foundations, 02-core, 03-advanced, 04-expert (partial) | 8/8 foundations modules, 6/6 core modules, 5/5 advanced modules, 3/5 expert modules, 2/4 projects, 2/4 assessments | Advanced parity complete, expert rollout in progress |
-| Go | 01-foundations, 02-core, 03-advanced | 8/8 foundations modules, 6/6 core modules, 5/5 advanced modules, 2/4 projects, 2/4 assessments | Advanced parity complete, checkpoints started |
-| Python | 01-foundations, 02-core, 03-advanced | 8/8 foundations modules, 6/6 core modules, 5/5 advanced modules, 2/4 projects, 2/4 assessments | Advanced parity complete, checkpoints started |
+| C# | 01-foundations, 02-core, 03-advanced, 04-expert | 8/8 foundations modules, 6/6 core modules, 5/5 advanced modules, 5/5 expert modules, 2/4 projects, 2/4 assessments | Module parity complete through expert |
+| Go | 01-foundations, 02-core, 03-advanced, 04-expert | 8/8 foundations modules, 6/6 core modules, 5/5 advanced modules, 5/5 expert modules, 2/4 projects, 2/4 assessments | Module parity complete through expert |
+| Python | 01-foundations, 02-core, 03-advanced, 04-expert | 8/8 foundations modules, 6/6 core modules, 5/5 advanced modules, 5/5 expert modules, 2/4 projects, 2/4 assessments | Module parity complete through expert |
 
 Parity planning reference: [LANGUAGE_PARITY_MATRIX.md](LANGUAGE_PARITY_MATRIX.md)
 

languages/csharp/04-expert/README.md

@@ -1,17 +1,17 @@
 # C# 04 Expert
 
-This level is rolling out incrementally in C# while the rest of expert parity is still in progress.
+This level is now fully implemented in C#.
 
 ## Module Order
 
 1. [memory-management-and-raii](./memory-management-and-raii/README.md)
-2. smart-pointers-in-depth (planned, language-adapted)
+2. [smart-pointers-in-depth](./smart-pointers-in-depth/README.md)
 3. [concurrency-basics](./concurrency-basics/README.md)
-4. performance-and-profiling-basics (planned)
+4. [performance-and-profiling-basics](./performance-and-profiling-basics/README.md)
 5. [modularization-and-build-structure](./modularization-and-build-structure/README.md)
 
 Track progress in [../CHECKLIST.md](../CHECKLIST.md).
 
 ## Study Tip
 
-Use this level to move from deterministic cleanup into concurrent coordination and then into modular project structure before tackling performance topics.
+Use this level to move from deterministic cleanup into ownership modeling, concurrent coordination, performance measurement, and modular project structure.

languages/csharp/04-expert/performance-and-profiling-basics/README.md

@@ -0,0 +1,48 @@
+# Performance and Profiling Basics (C#)
+
+This module introduces simple measurement and optimization patterns in C#.
+
+## Quick Run
+
+~~~bash
+dotnet run --project example/performance-and-profiling-basics-example.csproj
+~~~
+
+## Topics Covered
+
+- Measuring elapsed time with `Stopwatch`.
+- Comparing two implementations on the same workload.
+- Reducing allocations with `StringBuilder` or pre-sized collections.
+- Avoiding conclusions from noisy one-off timings.
+
+## Common Pitfalls
+
+- Timing workloads that are too small to compare meaningfully.
+- Mixing data generation time with the code under test.
+- Treating a single faster run as a final truth.
+- Optimizing without understanding algorithmic cost first.
+
+## Exercise Focus
+
+- exercises/01.cs: compare string concatenation with `StringBuilder`.
+- exercises/02.cs: compare `List<T>` growth with and without initial capacity.
+
+### Exercise Specs
+
+1. exercises/01.cs
+- Input: line count.
+- Output: elapsed ticks for both string-building approaches.
+- Edge cases: zero lines; very small workloads produce noisy timings.
+
+2. exercises/02.cs
+- Input: element count.
+- Output: elapsed ticks for list fill with and without preset capacity.
+- Edge cases: zero count; small sizes with little visible difference.
+
+## Checkpoint
+
+- [ ] I can measure work with `Stopwatch`.
+- [ ] I can compare two implementations on the same input fairly.
+- [ ] I can explain why pre-sizing or reducing allocations can help.
+- [ ] I completed exercises/01.cs.
+- [ ] I completed exercises/02.cs.

languages/csharp/04-expert/performance-and-profiling-basics/example/main.cs

@@ -0,0 +1,82 @@
+// Example purpose: compare a couple of small optimization choices with Stopwatch.
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+
+class Program
+{
+    static void Main()
+    {
+        // Program flow: measure two paired implementations on the same workload size.
+        const int lineCount = 4000;
+        long concatTicks = Measure(() => BuildWithConcatenation(lineCount));
+        long builderTicks = Measure(() => BuildWithStringBuilder(lineCount));
+
+        Console.WriteLine($"String concatenation ticks: {concatTicks}");
+        Console.WriteLine($"StringBuilder ticks: {builderTicks}");
+
+        const int itemCount = 200000;
+        long noCapacityTicks = Measure(() => FillWithoutCapacity(itemCount));
+        long withCapacityTicks = Measure(() => FillWithCapacity(itemCount));
+
+        // Intent: final output keeps the comparison direct and easy to verify.
+        Console.WriteLine($"List fill without capacity ticks: {noCapacityTicks}");
+        Console.WriteLine($"List fill with capacity ticks: {withCapacityTicks}");
+    }
+
+    static long Measure(Action action)
+    {
+        Stopwatch stopwatch = Stopwatch.StartNew();
+        action();
+        stopwatch.Stop();
+        return stopwatch.ElapsedTicks;
+    }
+
+    static string BuildWithConcatenation(int lineCount)
+    {
+        string result = string.Empty;
+        for (int index = 0; index < lineCount; index++)
+        {
+            result += $"row-{index};";
+        }
+
+        return result;
+    }
+
+    static string BuildWithStringBuilder(int lineCount)
+    {
+        StringBuilder builder = new StringBuilder(lineCount * 8);
+        for (int index = 0; index < lineCount; index++)
+        {
+            builder.Append("row-");
+            builder.Append(index);
+            builder.Append(';');
+        }
+
+        return builder.ToString();
+    }
+
+    static List<int> FillWithoutCapacity(int itemCount)
+    {
+        List<int> values = new List<int>();
+        for (int index = 0; index < itemCount; index++)
+        {
+            values.Add(index);
+        }
+
+        return values;
+    }
+
+    static List<int> FillWithCapacity(int itemCount)
+    {
+        List<int> values = new List<int>(itemCount);
+        for (int index = 0; index < itemCount; index++)
+        {
+            values.Add(index);
+        }
+
+        return values;
+    }
+}

languages/csharp/04-expert/performance-and-profiling-basics/example/performance-and-profiling-basics-example.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>disable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+    </PropertyGroup>
+    <ItemGroup>
+        <Compile Include="main.cs" />
+    </ItemGroup>
+</Project>

languages/csharp/04-expert/performance-and-profiling-basics/exercises/01.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Diagnostics;
+using System.Text;
+
+class Program
+{
+    static void Main()
+    {
+        Console.Write("Line count: ");
+        if (!int.TryParse(Console.ReadLine(), out int lineCount))
+        {
+            Console.WriteLine("Invalid line count.");
+            return;
+        }
+
+        if (lineCount < 0)
+        {
+            Console.WriteLine("Line count cannot be negative.");
+            return;
+        }
+
+        long concatTicks = Measure(() => BuildWithConcatenation(lineCount));
+        long builderTicks = Measure(() => BuildWithBuilder(lineCount));
+
+        Console.WriteLine($"Concatenation ticks: {concatTicks}");
+        Console.WriteLine($"StringBuilder ticks: {builderTicks}");
+    }
+
+    static long Measure(Action action)
+    {
+        Stopwatch stopwatch = Stopwatch.StartNew();
+        action();
+        stopwatch.Stop();
+        return stopwatch.ElapsedTicks;
+    }
+
+    static string BuildWithConcatenation(int lineCount)
+    {
+        string text = string.Empty;
+        for (int index = 0; index < lineCount; index++)
+        {
+            text += $"item-{index};";
+        }
+
+        return text;
+    }
+
+    static string BuildWithBuilder(int lineCount)
+    {
+        StringBuilder builder = new StringBuilder(lineCount * 8);
+        for (int index = 0; index < lineCount; index++)
+        {
+            builder.Append("item-");
+            builder.Append(index);
+            builder.Append(';');
+        }
+
+        return builder.ToString();
+    }
+}

languages/csharp/04-expert/performance-and-profiling-basics/exercises/02.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+class Program
+{
+    static void Main()
+    {
+        Console.Write("Element count: ");
+        if (!int.TryParse(Console.ReadLine(), out int elementCount))
+        {
+            Console.WriteLine("Invalid element count.");
+            return;
+        }
+
+        if (elementCount < 0)
+        {
+            Console.WriteLine("Element count cannot be negative.");
+            return;
+        }
+
+        long noCapacityTicks = Measure(() => FillWithoutCapacity(elementCount));
+        long withCapacityTicks = Measure(() => FillWithCapacity(elementCount));
+
+        Console.WriteLine($"Without capacity ticks: {noCapacityTicks}");
+        Console.WriteLine($"With capacity ticks: {withCapacityTicks}");
+    }
+
+    static long Measure(Action action)
+    {
+        Stopwatch stopwatch = Stopwatch.StartNew();
+        action();
+        stopwatch.Stop();
+        return stopwatch.ElapsedTicks;
+    }
+
+    static List<int> FillWithoutCapacity(int elementCount)
+    {
+        List<int> values = new List<int>();
+        for (int index = 0; index < elementCount; index++)
+        {
+            values.Add(index);
+        }
+
+        return values;
+    }
+
+    static List<int> FillWithCapacity(int elementCount)
+    {
+        List<int> values = new List<int>(elementCount);
+        for (int index = 0; index < elementCount; index++)
+        {
+            values.Add(index);
+        }
+
+        return values;
+    }
+}

languages/csharp/04-expert/smart-pointers-in-depth/README.md

@@ -0,0 +1,48 @@
+# Smart Pointers in Depth (C#)
+
+This module adapts smart pointer ideas to managed references, ownership transfer, and weak observation in C#.
+
+## Quick Run
+
+~~~bash
+dotnet run --project example/smart-pointers-in-depth-example.csproj
+~~~
+
+## Topics Covered
+
+- Treating nullable references as explicit ownership slots.
+- Moving an owned reference by transferring it and clearing the original holder.
+- Using `WeakReference<T>` for non-owning observation.
+- Distinguishing strong lifetime responsibility from temporary access.
+
+## Common Pitfalls
+
+- Assuming the garbage collector makes ownership design irrelevant.
+- Keeping accidental strong references in caches or observers.
+- Using `WeakReference<T>` where a normal strong dependency is simpler.
+- Forgetting to clear the old owner after a transfer.
+
+## Exercise Focus
+
+- exercises/01.cs: move an owned document reference between holders.
+- exercises/02.cs: observe cache entries through `WeakReference<T>`.
+
+### Exercise Specs
+
+1. exercises/01.cs
+- Input: none.
+- Output: ownership transfer logs before and after moving.
+- Edge cases: moving from an empty owner; destination already holding another object.
+
+2. exercises/02.cs
+- Input: none.
+- Output: alive/expired cache lookup logs.
+- Edge cases: expired weak reference; cache miss.
+
+## Checkpoint
+
+- [ ] I can explain strong vs weak references in C#.
+- [ ] I can model an ownership transfer by clearing the previous owner.
+- [ ] I can choose when a weak observer is appropriate.
+- [ ] I completed exercises/01.cs.
+- [ ] I completed exercises/02.cs.