Refine expert examples and Go smoke handling

Author: lucasbellesi

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

@@ -7,31 +7,61 @@
 
 class Program
 {
+    static string retainedText = string.Empty;
+    static List<int> retainedValues = new List<int>();
+
     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));
+        const int repetitions = 12;
+        long concatTicks = MeasureAverage(
+            () => retainedText = BuildWithConcatenation(lineCount),
+            repetitions
+        );
+        long builderTicks = MeasureAverage(
+            () => retainedText = BuildWithStringBuilder(lineCount),
+            repetitions
+        );
 
-        Console.WriteLine($"String concatenation ticks: {concatTicks}");
-        Console.WriteLine($"StringBuilder ticks: {builderTicks}");
+        Console.WriteLine(
+            $"Average string concatenation ticks ({repetitions} runs): {concatTicks}"
+        );
+        Console.WriteLine($"Average StringBuilder ticks ({repetitions} runs): {builderTicks}");
 
         const int itemCount = 200000;
-        long noCapacityTicks = Measure(() => FillWithoutCapacity(itemCount));
-        long withCapacityTicks = Measure(() => FillWithCapacity(itemCount));
+        long noCapacityTicks = MeasureAverage(
+            () => retainedValues = FillWithoutCapacity(itemCount),
+            repetitions
+        );
+        long withCapacityTicks = MeasureAverage(
+            () => retainedValues = FillWithCapacity(itemCount),
+            repetitions
+        );
 
         // 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}");
+        Console.WriteLine(
+            $"Average list fill without capacity ticks ({repetitions} runs): {noCapacityTicks}"
+        );
+        Console.WriteLine(
+            $"Average list fill with capacity ticks ({repetitions} runs): {withCapacityTicks}"
+        );
     }
 
-    static long Measure(Action action)
+    static long MeasureAverage(Action action, int repetitions)
     {
-        Stopwatch stopwatch = Stopwatch.StartNew();
         action();
-        stopwatch.Stop();
-        return stopwatch.ElapsedTicks;
+
+        long totalTicks = 0;
+        for (int iteration = 0; iteration < repetitions; iteration++)
+        {
+            Stopwatch stopwatch = Stopwatch.StartNew();
+            action();
+            stopwatch.Stop();
+            totalTicks += stopwatch.ElapsedTicks;
+        }
+
+        return totalTicks / repetitions;
     }
 
     static string BuildWithConcatenation(int lineCount)

languages/csharp/04-expert/smart-pointers-in-depth/example/main.cs

@@ -11,11 +11,6 @@ public Report(string title)
     }
 
     public string Title { get; }
-
-    ~Report()
-    {
-        Console.WriteLine($"Finalized report: {Title}");
-    }
 }
 
 sealed class ReportOwner
@@ -74,7 +69,7 @@ class Program
 {
     static void Main()
     {
-        // Program flow: move one strongly-owned reference, then watch a weak observer expire.
+        // Program flow: move one strongly-owned reference, then observe a weak reference expire.
         ReportOwner inbox = new ReportOwner("Inbox", new Report("Quarterly Summary"));
         ReportOwner archive = new ReportOwner("Archive", null);
 
@@ -87,11 +82,11 @@ static void Main()
         PreviewPane preview = CreatePreview();
         preview.Describe();
 
+        // Intent: the helper method released the last strong owner before we force collection.
         GC.Collect();
         GC.WaitForPendingFinalizers();
         GC.Collect();
 
-        // Intent: final state confirms that the weak observer did not keep the object alive.
         preview.Describe();
     }
 

languages/go/04-expert/modularization-and-build-structure/README.md

@@ -5,14 +5,14 @@ This module introduces separation of responsibilities and package-oriented desig
 ## Quick Run
 
 ~~~bash
-go run example/main.go
+go run example/main.go example/pricing.go example/formatting.go
 ~~~
 
 ## Topics Covered
 
-- Separating calculation, formatting, and orchestration responsibilities.
+- Separating calculation, formatting, and orchestration responsibilities across files.
 - Keeping `main` thin and coordination-focused.
-- Designing helper functions and types that could later move into packages.
+- Designing helper functions and types that live outside the entrypoint.
 - Treating file and package layout as part of program design.
 
 ## Common Pitfalls

languages/go/04-expert/modularization-and-build-structure/example/formatting.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+func renderSummary(summary invoiceSummary) string {
+	return fmt.Sprintf(
+		"Subtotal: %.2f\nDiscount: %.2f\nTax: %.2f\nTotal: %.2f",
+		summary.subtotal,
+		summary.discountValue,
+		summary.taxValue,
+		summary.total,
+	)
+}

languages/go/04-expert/modularization-and-build-structure/example/main.go

@@ -4,45 +4,6 @@ package main
 
 import "fmt"
 
-type lineItem struct {
-	name      string
-	quantity  int
-	unitPrice float64
-}
-
-type invoiceSummary struct {
-	subtotal      float64
-	discountValue float64
-	taxValue      float64
-	total         float64
-}
-
-func buildSummary(items []lineItem, discountPercent, taxPercent float64) invoiceSummary {
-	subtotal := 0.0
-	for _, item := range items {
-		subtotal += float64(item.quantity) * item.unitPrice
-	}
-	discountValue := subtotal * (discountPercent / 100.0)
-	taxedBase := subtotal - discountValue
-	taxValue := taxedBase * (taxPercent / 100.0)
-	return invoiceSummary{
-		subtotal:      subtotal,
-		discountValue: discountValue,
-		taxValue:      taxValue,
-		total:         taxedBase + taxValue,
-	}
-}
-
-func renderSummary(summary invoiceSummary) string {
-	return fmt.Sprintf(
-		"Subtotal: %.2f\nDiscount: %.2f\nTax: %.2f\nTotal: %.2f",
-		summary.subtotal,
-		summary.discountValue,
-		summary.taxValue,
-		summary.total,
-	)
-}
-
 func main() {
 	// Program flow: define input data, delegate calculations, then format a report.
 	items := []lineItem{

languages/go/04-expert/modularization-and-build-structure/example/pricing.go

@@ -0,0 +1,32 @@
+package main
+
+type lineItem struct {
+	name      string
+	quantity  int
+	unitPrice float64
+}
+
+type invoiceSummary struct {
+	subtotal      float64
+	discountValue float64
+	taxValue      float64
+	total         float64
+}
+
+func buildSummary(items []lineItem, discountPercent, taxPercent float64) invoiceSummary {
+	subtotal := 0.0
+	for _, item := range items {
+		subtotal += float64(item.quantity) * item.unitPrice
+	}
+
+	discountValue := subtotal * (discountPercent / 100.0)
+	taxedBase := subtotal - discountValue
+	taxValue := taxedBase * (taxPercent / 100.0)
+
+	return invoiceSummary{
+		subtotal:      subtotal,
+		discountValue: discountValue,
+		taxValue:      taxValue,
+		total:         taxedBase + taxValue,
+	}
+}

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

@@ -8,28 +8,40 @@ import (
 	"time"
 )
 
+var (
+	retainedText   string
+	retainedValues []int
+)
+
 func main() {
 	// Program flow: measure two paired implementations on the same workload size.
 	const lineCount = 4000
-	concatDuration := measure(func() { _ = buildWithConcatenation(lineCount) })
-	builderDuration := measure(func() { _ = buildWithBuilder(lineCount) })
+	const repetitions = 12
+	concatDuration := measureAverage(func() { retainedText = buildWithConcatenation(lineCount) }, repetitions)
+	builderDuration := measureAverage(func() { retainedText = buildWithBuilder(lineCount) }, repetitions)
 
-	fmt.Printf("String concatenation: %v\n", concatDuration)
-	fmt.Printf("strings.Builder: %v\n", builderDuration)
+	fmt.Printf("Average string concatenation (%d runs): %v\n", repetitions, concatDuration)
+	fmt.Printf("Average strings.Builder (%d runs): %v\n", repetitions, builderDuration)
 
 	const itemCount = 200000
-	noCapacity := measure(func() { _ = fillWithoutCapacity(itemCount) })
-	withCapacity := measure(func() { _ = fillWithCapacity(itemCount) })
+	noCapacity := measureAverage(func() { retainedValues = fillWithoutCapacity(itemCount) }, repetitions)
+	withCapacity := measureAverage(func() { retainedValues = fillWithCapacity(itemCount) }, repetitions)
 
 	// Intent: final output keeps the comparison direct and easy to verify.
-	fmt.Printf("Slice fill without capacity: %v\n", noCapacity)
-	fmt.Printf("Slice fill with capacity: %v\n", withCapacity)
+	fmt.Printf("Average slice fill without capacity (%d runs): %v\n", repetitions, noCapacity)
+	fmt.Printf("Average slice fill with capacity (%d runs): %v\n", repetitions, withCapacity)
 }
 
-func measure(action func()) time.Duration {
-	start := time.Now()
+func measureAverage(action func(), repetitions int) time.Duration {
 	action()
-	return time.Since(start)
+
+	var total time.Duration
+	for iteration := 0; iteration < repetitions; iteration++ {
+		start := time.Now()
+		action()
+		total += time.Since(start)
+	}
+	return total / time.Duration(repetitions)
 }
 
 func buildWithConcatenation(lineCount int) string {

languages/python/04-expert/performance-and-profiling-basics/example/main.py

@@ -5,10 +5,18 @@
 import time
 
 
-def measure(action) -> float:
-    start = time.perf_counter()
+retained_object: object | None = None
+
+
+def measure_average(action, repetitions: int) -> float:
     action()
-    return time.perf_counter() - start
+
+    total = 0.0
+    for _ in range(repetitions):
+        start = time.perf_counter()
+        action()
+        total += time.perf_counter() - start
+    return total / repetitions
 
 
 def build_with_concatenation(line_count: int) -> str:
@@ -40,19 +48,37 @@ def fill_with_presize(item_count: int) -> list[int]:
 def main() -> None:
     # Program flow: measure two paired implementations on the same workload size.
     line_count = 4_000
-    concat_duration = measure(lambda: build_with_concatenation(line_count))
-    join_duration = measure(lambda: build_with_join(line_count))
+    repetitions = 12
+
+    def remember(value: object) -> None:
+        global retained_object
+        retained_object = value
+
+    concat_duration = measure_average(
+        lambda: remember(build_with_concatenation(line_count)),
+        repetitions,
+    )
+    join_duration = measure_average(
+        lambda: remember(build_with_join(line_count)),
+        repetitions,
+    )
 
-    print(f"String concatenation: {concat_duration:.6f}s")
-    print(f"str.join: {join_duration:.6f}s")
+    print(f"Average string concatenation ({repetitions} runs): {concat_duration:.6f}s")
+    print(f"Average str.join ({repetitions} runs): {join_duration:.6f}s")
 
     item_count = 200_000
-    no_presize = measure(lambda: fill_without_presize(item_count))
-    with_presize = measure(lambda: fill_with_presize(item_count))
+    no_presize = measure_average(
+        lambda: remember(fill_without_presize(item_count)),
+        repetitions,
+    )
+    with_presize = measure_average(
+        lambda: remember(fill_with_presize(item_count)),
+        repetitions,
+    )
 
     # Intent: final output keeps the comparison direct and easy to verify.
-    print(f"List fill without pre-size: {no_presize:.6f}s")
-    print(f"List fill with pre-size: {with_presize:.6f}s")
+    print(f"Average list fill without pre-size ({repetitions} runs): {no_presize:.6f}s")
+    print(f"Average list fill with pre-size ({repetitions} runs): {with_presize:.6f}s")
 
 
 if __name__ == "__main__":

languages/python/04-expert/smart-pointers-in-depth/example/main.py

@@ -11,9 +11,6 @@ def __init__(self, title: str) -> None:
         self.title = title
         print(f"Created report: {title}")
 
-    def __del__(self) -> None:
-        print(f"Finalized report: {self.title}")
-
 
 class ReportOwner:
     def __init__(self, name: str, report: Report | None) -> None:
@@ -44,13 +41,27 @@ def describe(self) -> None:
         print(f"Preview can still see: {report.title}")
 
 
-def make_preview() -> PreviewPane:
-    transient = Report("Transient Draft")
-    return PreviewPane(transient)
+class PreviewSession:
+    def __init__(self, report: Report) -> None:
+        self._report = report
+
+    @property
+    def current(self) -> Report | None:
+        return self._report
+
+    def release(self) -> None:
+        self._report = None
+
+
+def create_preview_session() -> tuple[PreviewPane, PreviewSession]:
+    session = PreviewSession(Report("Transient Draft"))
+    current = session.current
+    assert current is not None
+    return PreviewPane(current), session
 
 
 def main() -> None:
-    # Program flow: move one strongly-owned reference, then watch a weak observer expire.
+    # Program flow: move one strongly-owned reference, then release a temporary strong owner.
     inbox = ReportOwner("Inbox", Report("Quarterly Summary"))
     archive = ReportOwner("Archive", None)
 
@@ -60,11 +71,12 @@ def main() -> None:
     inbox.describe()
     archive.describe()
 
-    preview = make_preview()
+    preview, session = create_preview_session()
     preview.describe()
-    gc.collect()
 
-    # Intent: final state confirms that the weak observer did not keep the object alive.
+    # Intent: dropping the last strong owner makes the weak observer expire on the next collection.
+    session.release()
+    gc.collect()
     preview.describe()