after talk

.gitignore

···
 *.db-shm
 *.ttf
 *.jpg
+*.png
 *.db-wal
 package-lock.json
 *.sqlite

assets/slides.md

···
 
 ---
 
+# @nonbinary.computer
+
+- Embedded (and everything else) developer, electronics designer
+- Utopian in the Terra Ignota sense
+- atproto hit me like a truck
+
+---
+
 ## Spite-driven development
 
 - Existing atproto libraries kinda sucked to work with
···
 ---
 
 ## Why Rust?
-
-Only language where you can actually run it anywhere 
-
-and it's not a stupid idea to.
-
----
-
-## Why Rust?
-
-- Rust has a reputation as a difficult and demanding language
-- That reputation is sort of deserved
-
-
----
-
-## Why Rust?
-
 - The things Rust asks of you are things you often need to think about anyway
 - It just makes them explicit
 - We can make the sharp edges easier, if we care to
···
 
 # "Parse, don't validate" considered harmful
 
-If serde_json can't parse something as the type you're asking of it,
-
-it will give you nothing except an error.
-
----
-
-# "Parse, don't validate" considered harmful
-
 Jacquard has its `Data<S>` type to handle some classes of this, 
 
 to work with freeform data in useful ways, 
···
 
 # Smart constraints
 
-- Also a bad developer experience. 
-- All of a sudden you can't take advantage of all the nice types! 
-- `serde_json::Value` or `ipld_core::Ipld` offers literally nothing useful beyond "this thing is valid JSON/CBOR". 
+`Data<S>` is **less** useless but still sucks donkey balls when you wanted your type.
 
 ---
 
-# Smart constraints
-
-`Data<S>` is **less useless** but still sucks donkey balls when you wanted your type.
-
 ![](avasarala.jpg)
 
 ---
 
 # Smart constraints
 
-And that is why jacquard's handle constructor has a specific carveout for "handle.invalid"
+And that is why jacquard's handle constructor has a specific carveout for 'handle.invalid'
 
 Because there's a time to follow the spec
 
···
 
 ---
 
+## Why borrowing and lifetimes everywhere
+
+
+- Lifetimes (Jacquard, `serde_json_borrow`)
+- Unsafe (wrapped up, like `zerocopy` crate)
+- Separate borrowed/owned type variants (what Rust does)
+- `bytemuck` approach (`&'a Did` and `Box<Did>`)
+- **Borrow or Share** (available on `bos-beta` branch on tangled)
+
+
+---
+
 ## What you're seeing
 
 - Each dot is a Jetstream event
···
 
 - We can change that!
 
+![](example-derive.png)
+
 ---
 
 ## HOW?
···
 
 ---
 
-## Thank you!
+## Thank you
 
-Questions?
+![Questions?](qr-code.png)

src/event_card.rs

···
                 let wrapper = world
                     .spawn(Node {
                         align_self: AlignSelf::Center,
+                        max_width: Val::Percent(60.0),
+                        max_height: Val::Percent(40.0),
                         margin: UiRect::axes(Val::Px(0.0), Val::Px(8.0)),
                         ..default()
                     })
                     .id();
 
-                let img = world
-                    .spawn(ImageNode::new(handle))
-                    .id();
+                let img = world.spawn(ImageNode::new(handle)).id();
 
                 world.entity_mut(wrapper).add_child(img);
                 world.entity_mut(content_entity).add_child(wrapper);
···
     let cached_text = {
         let cache = world.resource::<RecordCache>();
         cache.records.get(uri).map(|cached| {
-            let text = cached.data.get_at_path("text")
+            let text = cached
+                .data
+                .get_at_path("text")
                 .and_then(|d| d.as_str())
                 .unwrap_or("[no text]")
                 .to_string();
···
     };
 
     let border = UiRect::all(Val::Px(1.0));
-    let (display_text, author_label) = cached_text
-        .unwrap_or_else(|| (format!("loading {uri}…"), String::new()));
+    let (display_text, author_label) =
+        cached_text.unwrap_or_else(|| (format!("loading {uri}…"), String::new()));
 
     let container = world
         .spawn((
···
         let author_node = world
             .spawn((
                 Text::new(author_display),
-                TextFont { font: font.clone(), font_size: 28.0, ..default() },
+                TextFont {
+                    font: font.clone(),
+                    font_size: 28.0,
+                    ..default()
+                },
                 TextColor(dim),
             ))
             .id();
···
     let text_node = world
         .spawn((
             Text::new(display_text),
-            TextFont { font: font.clone(), font_size: 32.0, ..default() },
+            TextFont {
+                font: font.clone(),
+                font_size: 32.0,
+                ..default()
+            },
             TextColor(bright),
             TextLayout::new_with_linebreak(LineBreak::WordBoundary),
         ))
···
                     let mut cache = world.resource_mut::<RecordCache>();
                     cache.records_pending.remove(&uri_owned);
                     if let Some((data, author_did)) = result {
-                        cache.records.insert(uri_owned, CachedRecord { data, author_did });
+                        cache
+                            .records
+                            .insert(uri_owned, CachedRecord { data, author_did });
                         cache.bump();
+                        // Trigger slide re-render
+                        let mut render = world.resource_mut::<CardRenderState>();
+                        render.slide_generation += 1;
                     }
-                });
+                })
+                .await;
             });
         }
     }
···
         return world
             .spawn((
                 Text::new(full_text),
-                TextFont { font: font.clone(), font_size, ..default() },
+                TextFont {
+                    font: font.clone(),
+                    font_size,
+                    ..default()
+                },
                 TextColor(bright),
                 TextLayout::new_with_linebreak(LineBreak::WordBoundary),
             ))
···
         let child = world
             .spawn((
                 Text::new(span.text.clone()),
-                TextFont { font: span_font, font_size, ..default() },
+                TextFont {
+                    font: span_font,
+                    font_size,
+                    ..default()
+                },
                 TextColor(bright),
             ))
             .id();
···
     use jacquard::types::string::Did;
     use smol_str::ToSmolStr;
 
-    let parsed = AtUri::new(uri.to_smolstr()).ok()?;
-    let output = client.fetch_record_slingshot(&parsed).await.ok()?;
+    let parsed = match AtUri::new(uri.to_smolstr()) {
+        Ok(u) => u,
+        Err(e) => {
+            warn!("fetch_record_by_uri: invalid AT-URI {uri}: {e:?}");
+            return None;
+        }
+    };
+    let output = match client.fetch_record_slingshot(&parsed).await {
+        Ok(o) => o,
+        Err(e) => {
+            warn!("fetch_record_by_uri: slingshot failed for {uri}: {e:?}");
+            return None;
+        }
+    };
     let author = Did::new(parsed.authority().as_str().to_smolstr()).ok()?;
     Some((output.value, author))
 }