Updates

Author: FranciscoThiesen

cppcon2025/cppcon_2025_slides.md

@@ -243,63 +243,21 @@ This manual approach has several problems:
 
 ---
 
-# Goal: Seamless Serialization/Deserialization
+# Our goal: Seamless Serialization/Deserialization
 
 <img src="images/tofrom.svg" width="100%">
 
 ---
 
-# The Solution: C++26 Static Reflection
-
-With C++26 reflection and simdjson, **all that boilerplate disappears**:
-
-```cpp
-// Just define your struct - no extra code needed!
-struct Player {
-    std::string username;
-    int level;
-    double health;
-    std::vector<std::string> inventory;
-    std::map<std::string, Equipment> equipped;
-    std::vector<Achievement> achievements;
-    std::optional<std::string> guild_name;
-};
-```
-
----
-
-# Automatic Serialization
-
-```cpp
-// Serialization - one line!
-void save_player(const Player& p) {
-    std::string json = simdjson::to_json(p);  // That's it!
-    // Save json to file...
-}
-```
-
----
-
-# Automatic Deserialization
-
-```cpp
-// Deserialization - one line!
-Player load_player(std::string& json_str) {
-    return simdjson::from(json_str);  // That's it!
+<!-- _class: centered -->
+<style scoped>
+section {
+  text-align: center;
+  font-size: 2em;
 }
-```
-
-Runnable example at https://godbolt.org/z/Efr7bK9jn
-
----
-
-# Benefits of our implementation
+</style>
 
-- **No manual field mapping**
-- **No maintenance burden**
-- **Handles nested and user-defined structures and containers automatically**
-- **You can still customize things if you want**
-- **Performance tuned by the library**
+<p style="text-align:center">How do other languages do it?</p>
 
 ---
 
@@ -314,6 +272,11 @@ Player deserializedPlayer = JsonSerializer.Deserialize<Player>(jsonInput, option
 
 ---
 
+# Why can C# implementation be so elegant?
+It is using **reflection** to access the attributes of a struct during runtime.
+
+---
+
 # Rust (serde)
 
 ```rust
@@ -322,22 +285,20 @@ let json_str = serde_json::to_string(&player)?;
 let player: Player = serde_json::from_str(&json_str)?;
 ```
 
-
 <img src="images/rust.png" width="10%" />
 
 ---
 
 # Rust reflection
 
-
-- Rust does not have ANY reflection.
-- You cannot enumerate the methods of a struct. Either at runtime or at compile-time.
-- Serde relies on annotation followed by re-parsing of the code.
+- Rust does not have any built-in reflection capabilities.
+- Serde relies on annotation and macros.
 
 <img src="image/rust_reflection.png">
 
 ---
 
+
 # Reflection as accessing the attributes of a struct.
 
 | language | runtime reflection | compile-time reflection |
@@ -350,42 +311,66 @@ let player: Player = serde_json::from_str(&json_str)?;
 
 ---
 
-# With C++26: simple, maintainable, performant code
+# Now it's our turn to have reflection!
+
+<!-- TODO: maybe add a reference to one of Herb's talks -->
+
+With C++26 reflection and simdjson, **all that boilerplate disappears**:
 
 ```cpp
-std::string json_str = simdjson::to_json(player);
-Player player = simdjson::from(json_str);
+// Just define your struct - no extra code needed!
+struct Player {
+    std::string username;
+    int level;
+    double health;
+    std::vector<std::string> inventory;
+    std::map<std::string, Equipment> equipped;
+    std::vector<Achievement> achievements;
+    std::optional<std::string> guild_name;
+};
 ```
 
-- no extra tooling required
-- no annotation
-
 ---
 
+# Automatic Serialization
 
-# How Does It Work?
-
-## The Key Insight: Compile-Time Code Generation
-
-**"How can compile-time reflection handle runtime JSON data?"**
-
-The answer: Reflection operates on **types and structure**, not runtime values.
+```cpp
+// Serialization - one line!
+void save_player(const Player& p) {
+    std::string json = simdjson::to_json(p);  // That's it!
+    // Save json to file...
+}
+```
 
-It generates regular C++ code at compile time that handles your runtime data.
+---
 
+# Automatic Deserialization
 
+```cpp
+// Deserialization - one line!
+Player load_player(std::string& json_str) {
+    return simdjson::from(json_str);  // That's it!
+}
+```
 
+Runnable example at https://godbolt.org/z/Efr7bK9jn
 
+---
 
+# Benefits of our implementation
 
+- **No manual field mapping**
+- **Minimal maintenance burden**
+- **Handles nested and user-defined structures and containers automatically**
+- **You can still customize things if and when you want to**
 
 ---
 
 # What Happens Behind the Scenes
 
 ```cpp
 // What you write:
-Player p = simdjson::from<Player>(runtime_json_string);
+Player p = simdjson::from(runtime_json_string);
 
 // What reflection generates at COMPILE TIME (conceptually):
 Player deserialize_Player(const json& j) {
@@ -406,6 +391,8 @@ Player deserialize_Player(const json& j) {
 ```cpp
 // Simplified snippet, members stores information about the class
 // obtained via std::define_static_array(std::meta::nonstatic_data_members_of(^^T, ...))...
+simdjson::ondemand::object obj;
+
 template for (constexpr auto member : members) {
     // These are compile-time constants
     constexpr std::string_view field_name = std::meta::identifier_of(member);
@@ -436,7 +423,7 @@ struct Player {
 
 // RUNTIME: The generated code processes actual JSON data
 std::string json = R"({"username":"Alice","level":42,"health":100.0})";
-Player p = simdjson::from<Player>(json);
+Player p = simdjson::from(json);
 // Runtime values flow through compile-time generated code
 ```
 

cppcon2025/instruction_count_analysis.md

@@ -185,17 +185,19 @@ std::string serialize_manual(const Car& car) {
     // Generates 1,635 lines of assembly!
 }
 
-// Reflection: 38 assembly instructions for user
+// Reflection: 648 total assembly instructions
 std::string serialize_reflection(const Car& car) {
-    return simdjson::to_json(car);  // 1 line!
-    // User sees: 38 lines of wrapper assembly
-    // Compiler generates: 648 lines of optimized template code
+    return simdjson::to_json(car);  // 1 line of C++!
+    // Compiler generates: 648 lines of optimized assembly
+    // (38 wrapper + 610 template instantiation)
 }
 ```
 
-**43x code reduction for the developer!**
-**2.5x fewer instructions overall!**
-**15x fewer branches to predict!**
+**What actually matters:**
+- **2.5x fewer instructions** (1,635 → 648)
+- **15x fewer branches** (311 → ~20)
+- **70+ lines of C++ → 1 line**
+- **Zero manual string escaping**
 
 ---