Removing bonus section

Author: FranciscoThiesen

cppcon2025/cppcon_2025_slides.md

@@ -751,300 +751,3 @@ GitHub: github.com/simdjson/simdjson
 Thank you!
 
 ---
-
-# BONUS: Assembly Deep Dive
-
-Want to see the actual machine code?
-
-Let's look under the hood! 🔧
-
----
-
-# The Shocking Truth: Instruction Counts
-
-<div style="display: flex; align-items: center; gap: 30px">
-<div style="flex: 1.5">
-
-![Instruction Count Analysis](images/bonus_chart1_instructions.png)
-
-</div>
-<div style="flex: 1">
-
-### The Numbers:
-- **Manual:** 1,635 instructions
-- **Reflection:** 648 instructions
-- **Speedup:** 2.5x fewer!
-
-### You Write:
-- **Manual:** 70+ lines of C++
-- **Reflection:** 1 line!
-
-[Try it yourself →](https://godbolt.org/z/94jPx6bEb)
-
-</div>
-</div>
-
----
-
-# Field Names: The Power of Compile-Time Constants
-
-<div style="display: flex; gap: 20px">
-<div style="flex: 1">
-
-### Manual: Byte-by-byte
-```asm
-mov  byte ptr [rdx], 34      ; '"'
-mov  byte ptr [rdx+1], 109   ; 'm'
-mov  byte ptr [rdx+2], 97    ; 'a'
-mov  byte ptr [rdx+3], 107   ; 'k'
-mov  byte ptr [rdx+4], 101   ; 'e'
-mov  byte ptr [rdx+5], 34    ; '"'
-mov  byte ptr [rdx+6], 58    ; ':'
-; ... plus bounds checks
-```
-**50+ instructions per field name**
-
-</div>
-<div style="flex: 1">
-
-### Reflection: 64-bit constant
-```asm
-movabs  rax, 0x223A656B616D22
-; "make":" as single value!
-
-mov  qword ptr [rdx], rax
-; Store 8 bytes at once!
-```
-**2 instructions per field name**
-
-</div>
-</div>
-
-![Field Name Encoding](images/bonus_chart3_fields.png)
-
-*Source: compiler_explorer_instruction_comparison.asm - 25x fewer instructions for field operations*
-
----
-
-# Branch Prediction: The Hidden Performance Killer
-
-<div style="columns: 2; column-gap: 40px">
-
-### Manual: 311 branches! 😱
-```asm
-cmp     al, 34        ; quote?
-je      .LBB0_19      ; branch!
-cmp     al, 92        ; backslash?
-je      .LBB0_27      ; branch!
-cmp     al, 10        ; newline?
-je      .LBB0_35      ; branch!
-cmp     al, 13        ; return?
-je      .LBB0_42      ; branch!
-; ... 300+ more conditions
-```
-
-**Problem:** Each branch = potential CPU pipeline stall
-
-<div style="break-before: column"></div>
-
-### Reflection: 20 branches 🎯
-```asm
-call simdjson::to_json_string
-; Most logic inside optimized
-; library with straight-line
-; SIMD code
-```
-
-**Benefit:**
-- 15x fewer misprediction opportunities
-- Better CPU pipeline utilization
-- Predictable control flow
-
-</div>
-
-*Measured from assembly: 311 je/jne/jb/ja instructions vs 20*
-
----
-
-# Memory Allocation: Death by a Thousand Cuts
-
-<style scoped>
-table {
-  font-size: 0.9em;
-}
-</style>
-
-| Operation | Manual | Reflection | Impact |
-|-----------|--------|------------|--------|
-| String appends | 40 | 5 | 8x fewer |
-| Memory reallocations | 235 | 1 | **235x fewer!** |
-| Escape checks | 600+ | (inside lib) | Bulk SIMD |
-
-### Manual: Growing pain
-```cpp
-std::string json = "{";           // alloc 1
-json += "\"make\":\"";            // realloc 2
-json += car.make;                 // realloc 3
-json += "\",\"model\":\"";        // realloc 4
-// ... 231 more reallocations!
-```
-
-### Reflection: Pre-sized perfection
-```cpp
-return simdjson::to_json(car);    // 1 allocation, perfectly sized!
-```
-
-*Source: Assembly analysis of compiler_explorer_instruction_comparison.asm*
-
----
-
-# Real Code Comparison
-
-## What developers write (Manual):
-```cpp
-std::string serialize_manual(const Car& car) {
-    std::string json = "{";
-    json += "\"make\":\"";
-    for (char c : car.make) {
-        switch(c) {
-            case '"':  json += "\\\""; break;
-            case '\\': json += "\\\\"; break;
-            case '\n': json += "\\n"; break;
-            // ... more escape cases
-            default: json += c;
-        }
-    }
-    json += "\",\"model\":\"";
-    // ... 70+ more lines of similar code
-}
-```
-
-## What developers write (Reflection):
-```cpp
-std::string serialize_reflection(const Car& car) {
-    return simdjson::to_json(car);  // That's it!
-}
-```
-
-Try both: https://godbolt.org/z/1n539e7cq
-
----
-
-# Branch Complexity Analysis
-
-![Branch Complexity](images/bonus_chart2_branches.png)
-
-### What the Numbers Mean:
-- **Manual:** 311 conditional branches in assembly
-- **Reflection:** 20 conditional branches in assembly
-- **Impact:** Fewer branches = fewer potential mispredictions
-- **Note:** Actual performance depends on data patterns
-
----
-
-
-
-# How Reflection Optimizes
-
-## Compile-Time Field Discovery
-```cpp
-template for (constexpr auto member :
-              std::meta::nonstatic_data_members_of(^^Car)) {
-    // Field names known at compile time!
-    // Compiler generates optimal code for each field
-}
-```
-
-## Result: Pre-computed Constants
-- Field names → 64-bit integers
-- String lengths → compile-time constants
-- Escape sequences → eliminated entirely
-- Buffer sizes → calculated at compile time
-
----
-
-# Escape Processing: Different Approaches
-
-## Manual: Character-by-character checking
-```cpp
-for (char c : str) {
-    if (c == '"') output += "\\\"";
-    else if (c == '\\') output += "\\\\";
-    else if (c < 0x20) {
-        // Unicode escape sequence
-        snprintf(buf, 7, "\\u%04x", c);
-        output += buf;
-    }
-    // ... more checks
-}
-```
-
-## Reflection: Library handles escaping
-- Escaping logic encapsulated in simdjson
-- Implementation may use SIMD for bulk processing
-- Details hidden inside `simdjson::to_json_string`
-
----
-
-# Try It Yourself!
-
-## Compiler Explorer Links:
-
-1. **Basic Comparison** (Manual vs Reflection):
-   https://godbolt.org/z/1n539e7cq
-
-2. **Reflection-Only Serialization**:
-   https://godbolt.org/z/94jPx6bEb
-
-3. **Full simdjson Integration** (requires reflection support):
-   ```bash
-   clang++ -std=c++26 -freflection \
-           -fexpansion-statements -O3
-   ```
-
-## What to Look For:
-- Search for `movabs` instructions with large numbers
-- Count the `je/jne/jb/ja` branch instructions
-- Look at the size of each function
-- Notice the `.rodata` section with pre-computed strings
-
----
-
-# Why This Matters for Real Applications
-
-## Benefits Compound:
-1. Fewer instructions → Better I-cache usage
-2. Fewer branches → Better speculation
-3. Compile-time strings → Better D-cache usage
-4. SIMD-ready layout → Vectorization opportunities
-
----
-
-# Key Takeaways from Assembly Analysis
-
-1. **Reflection generates highly optimized code**
-   - Consistently applies optimizations
-   - Eliminates manual boilerplate
-   - Reduces opportunity for errors
-
-2. **Compile-time is powerful**
-   - Field names become constants
-   - No runtime string building
-   - Pre-computed buffer sizes
-
-3. **Modern C++ delivers on its promises**
-   - Zero-overhead abstraction is real
-   - Better performance AND better ergonomics
-
-4. **simdjson + reflection = excellent match**
-   - Compile-time structure analysis
-   - Optimized library implementation
-   - Significant reduction in code complexity
-
----
-
-# End of Bonus Section
-
-Return to main presentation or explore the code yourself!
-
-Remember: The assembly doesn't lie! 🚀