From 5a81cc4678254e1401e412725d881d40939974f6 Mon Sep 17 00:00:00 2001 From: Justin Bennett Date: Sat, 27 Dec 2025 10:42:02 -0500 Subject: [PATCH] Sync transcript with talk audio --- mise.toml | 7 + public/transcripts/t2468.json | 39001 +++++++++++++++++ requirements.txt | 1 + scripts/transcribe.py | 104 + src/components/AudioTranscript.astro | 231 + src/components/TUIAudioPlayer.astro | 145 + src/components/TalkSlides.astro | 190 +- src/content.config.ts | 10 + src/content/talks/t2468--codegen-in-rust.mdx | 67 +- src/pages/talks/[code]/[slug].astro | 66 +- 10 files changed, 39729 insertions(+), 93 deletions(-) create mode 100644 public/transcripts/t2468.json create mode 100644 requirements.txt create mode 100644 scripts/transcribe.py create mode 100644 src/components/AudioTranscript.astro create mode 100644 src/components/TUIAudioPlayer.astro diff --git a/mise.toml b/mise.toml index f3784b1..225207b 100644 --- a/mise.toml +++ b/mise.toml @@ -1,6 +1,9 @@ [tools] bun = "1.3.5" lefthook = "2.0.12" +python = "3.11" +ffmpeg = "latest" +uv = "latest" [settings] experimental = true @@ -43,3 +46,7 @@ description = "Upload images to R2 and update manifest" [tasks.deploy] run = "wrangler deploy" depends = ["build"] + +[tasks.transcribe] +run = "python scripts/transcribe.py" +description = "Generate word-level transcript from audio/video" diff --git a/public/transcripts/t2468.json b/public/transcripts/t2468.json new file mode 100644 index 0000000..1e58a5e --- /dev/null +++ b/public/transcripts/t2468.json @@ -0,0 +1,39001 @@ +{ + "language": "en", + "duration": 2462.16, + "segments": [ + { + "start": 0.86, + "end": 6.98, + "text": "All right. Hello, everyone. This is my first talk since like 2018 or something like that.", + "words": [ + { + "word": "All", + "start": 0.86, + "end": 1.3 + }, + { + "word": "right.", + "start": 1.3, + "end": 1.72 + }, + { + "word": "Hello,", + "start": 2.26, + "end": 2.52 + }, + { + "word": "everyone.", + "start": 2.54, + "end": 3.02 + }, + { + "word": "This", + "start": 3.5, + "end": 3.64 + }, + { + "word": "is", + "start": 3.64, + "end": 3.8 + }, + { + "word": "my", + "start": 3.8, + "end": 3.96 + }, + { + "word": "first", + "start": 3.96, + "end": 4.18 + }, + { + "word": "talk", + "start": 4.18, + "end": 4.42 + }, + { + "word": "since", + "start": 4.42, + "end": 4.7 + }, + { + "word": "like", + "start": 4.7, + "end": 5.08 + }, + { + "word": "2018", + "start": 5.08, + "end": 5.84 + }, + { + "word": "or", + "start": 5.84, + "end": 6.26 + }, + { + "word": "something", + "start": 6.26, + "end": 6.54 + }, + { + "word": "like", + "start": 6.54, + "end": 6.8 + }, + { + "word": "that.", + "start": 6.8, + "end": 6.98 + } + ] + }, + { + "start": 6.98, + "end": 12.42, + "text": "So it's been a long time. Glad to be here. I've changed my talk a little bit since I", + "words": [ + { + "word": "So", + "start": 6.98, + "end": 7.12 + }, + { + "word": "it's", + "start": 7.12, + "end": 7.28 + }, + { + "word": "been", + "start": 7.28, + "end": 7.44 + }, + { + "word": "a", + "start": 7.44, + "end": 7.64 + }, + { + "word": "long", + "start": 7.64, + "end": 8.02 + }, + { + "word": "time.", + "start": 8.02, + "end": 8.82 + }, + { + "word": "Glad", + "start": 8.92, + "end": 9.24 + }, + { + "word": "to", + "start": 9.24, + "end": 9.4 + }, + { + "word": "be", + "start": 9.4, + "end": 9.54 + }, + { + "word": "here.", + "start": 9.54, + "end": 9.86 + }, + { + "word": "I've", + "start": 10.28, + "end": 10.66 + }, + { + "word": "changed", + "start": 10.66, + "end": 10.86 + }, + { + "word": "my", + "start": 10.86, + "end": 11.08 + }, + { + "word": "talk", + "start": 11.08, + "end": 11.18 + }, + { + "word": "a", + "start": 11.18, + "end": 11.32 + }, + { + "word": "little", + "start": 11.32, + "end": 11.5 + }, + { + "word": "bit", + "start": 11.5, + "end": 11.66 + }, + { + "word": "since", + "start": 11.66, + "end": 12.02 + }, + { + "word": "I", + "start": 12.02, + "end": 12.42 + } + ] + }, + { + "start": 12.42, + "end": 18.82, + "text": "gave the intro, and I just want to talk about CodeGen with Rust. So for some background", + "words": [ + { + "word": "gave", + "start": 12.42, + "end": 12.56 + }, + { + "word": "the", + "start": 12.56, + "end": 12.76 + }, + { + "word": "intro,", + "start": 12.76, + "end": 13.14 + }, + { + "word": "and", + "start": 13.18, + "end": 13.46 + }, + { + "word": "I", + "start": 13.46, + "end": 13.62 + }, + { + "word": "just", + "start": 13.62, + "end": 13.78 + }, + { + "word": "want", + "start": 13.78, + "end": 13.88 + }, + { + "word": "to", + "start": 13.88, + "end": 14.02 + }, + { + "word": "talk", + "start": 14.02, + "end": 14.14 + }, + { + "word": "about", + "start": 14.14, + "end": 14.48 + }, + { + "word": "CodeGen", + "start": 14.48, + "end": 15.0 + }, + { + "word": "with", + "start": 15.0, + "end": 15.28 + }, + { + "word": "Rust.", + "start": 15.28, + "end": 15.62 + }, + { + "word": "So", + "start": 16.96, + "end": 17.4 + }, + { + "word": "for", + "start": 17.4, + "end": 17.98 + }, + { + "word": "some", + "start": 17.98, + "end": 18.26 + }, + { + "word": "background", + "start": 18.26, + "end": 18.82 + } + ] + }, + { + "start": 18.82, + "end": 24.48, + "text": "about me, so I've been a software engineer for over a decade. I am the host of a podcast", + "words": [ + { + "word": "about", + "start": 18.82, + "end": 19.16 + }, + { + "word": "me,", + "start": 19.16, + "end": 19.56 + }, + { + "word": "so", + "start": 20.2, + "end": 20.66 + }, + { + "word": "I've", + "start": 20.66, + "end": 20.9 + }, + { + "word": "been", + "start": 20.9, + "end": 21.08 + }, + { + "word": "a", + "start": 21.08, + "end": 21.24 + }, + { + "word": "software", + "start": 21.24, + "end": 21.42 + }, + { + "word": "engineer", + "start": 21.42, + "end": 21.66 + }, + { + "word": "for", + "start": 21.66, + "end": 21.82 + }, + { + "word": "over", + "start": 21.82, + "end": 22.0 + }, + { + "word": "a", + "start": 22.0, + "end": 22.12 + }, + { + "word": "decade.", + "start": 22.12, + "end": 22.54 + }, + { + "word": "I", + "start": 23.16, + "end": 23.34 + }, + { + "word": "am", + "start": 23.34, + "end": 23.5 + }, + { + "word": "the", + "start": 23.5, + "end": 23.68 + }, + { + "word": "host", + "start": 23.68, + "end": 23.84 + }, + { + "word": "of", + "start": 23.84, + "end": 24.0 + }, + { + "word": "a", + "start": 24.0, + "end": 24.1 + }, + { + "word": "podcast", + "start": 24.1, + "end": 24.48 + } + ] + }, + { + "start": 24.48, + "end": 28.72, + "text": "called DevTools.fm, or co-host, I should say. I've been running that for about four years.", + "words": [ + { + "word": "called", + "start": 24.48, + "end": 24.7 + }, + { + "word": "DevTools", + "start": 24.7, + "end": 25.04 + }, + { + "word": ".fm,", + "start": 25.04, + "end": 25.56 + }, + { + "word": "or", + "start": 25.7, + "end": 25.9 + }, + { + "word": "co", + "start": 25.9, + "end": 26.08 + }, + { + "word": "-host,", + "start": 26.08, + "end": 26.22 + }, + { + "word": "I", + "start": 26.3, + "end": 26.34 + }, + { + "word": "should", + "start": 26.34, + "end": 26.5 + }, + { + "word": "say.", + "start": 26.5, + "end": 26.84 + }, + { + "word": "I've", + "start": 26.92, + "end": 27.12 + }, + { + "word": "been", + "start": 27.12, + "end": 27.24 + }, + { + "word": "running", + "start": 27.24, + "end": 27.46 + }, + { + "word": "that", + "start": 27.46, + "end": 27.7 + }, + { + "word": "for", + "start": 27.7, + "end": 27.86 + }, + { + "word": "about", + "start": 27.86, + "end": 28.16 + }, + { + "word": "four", + "start": 28.16, + "end": 28.4 + }, + { + "word": "years.", + "start": 28.4, + "end": 28.72 + } + ] + }, + { + "start": 28.72, + "end": 34.16, + "text": "I've had some people in here on the podcast. I am an alum of the Recurse Center. If you", + "words": [ + { + "word": "I've", + "start": 28.72, + "end": 28.88 + }, + { + "word": "had", + "start": 28.88, + "end": 29.2 + }, + { + "word": "some", + "start": 29.2, + "end": 29.56 + }, + { + "word": "people", + "start": 29.56, + "end": 29.76 + }, + { + "word": "in", + "start": 29.76, + "end": 29.94 + }, + { + "word": "here", + "start": 29.94, + "end": 30.08 + }, + { + "word": "on", + "start": 30.08, + "end": 30.22 + }, + { + "word": "the", + "start": 30.22, + "end": 30.36 + }, + { + "word": "podcast.", + "start": 30.36, + "end": 30.72 + }, + { + "word": "I", + "start": 32.02, + "end": 32.16 + }, + { + "word": "am", + "start": 32.16, + "end": 32.32 + }, + { + "word": "an", + "start": 32.32, + "end": 32.52 + }, + { + "word": "alum", + "start": 32.52, + "end": 32.74 + }, + { + "word": "of", + "start": 32.74, + "end": 33.12 + }, + { + "word": "the", + "start": 33.12, + "end": 33.3 + }, + { + "word": "Recurse", + "start": 33.3, + "end": 33.56 + }, + { + "word": "Center.", + "start": 33.56, + "end": 33.76 + }, + { + "word": "If", + "start": 33.88, + "end": 34.04 + }, + { + "word": "you", + "start": 34.04, + "end": 34.16 + } + ] + }, + { + "start": 34.16, + "end": 37.06, + "text": "haven't heard of the Recurse Center, you should definitely check it out. It is a fantastic", + "words": [ + { + "word": "haven't", + "start": 34.16, + "end": 34.32 + }, + { + "word": "heard", + "start": 34.32, + "end": 34.48 + }, + { + "word": "of", + "start": 34.48, + "end": 34.54 + }, + { + "word": "the", + "start": 34.54, + "end": 34.68 + }, + { + "word": "Recurse", + "start": 34.68, + "end": 34.9 + }, + { + "word": "Center,", + "start": 34.9, + "end": 35.1 + }, + { + "word": "you", + "start": 35.18, + "end": 35.22 + }, + { + "word": "should", + "start": 35.22, + "end": 35.4 + }, + { + "word": "definitely", + "start": 35.4, + "end": 35.64 + }, + { + "word": "check", + "start": 35.64, + "end": 35.82 + }, + { + "word": "it", + "start": 35.82, + "end": 35.98 + }, + { + "word": "out.", + "start": 35.98, + "end": 36.14 + }, + { + "word": "It", + "start": 36.2, + "end": 36.26 + }, + { + "word": "is", + "start": 36.26, + "end": 36.42 + }, + { + "word": "a", + "start": 36.42, + "end": 36.52 + }, + { + "word": "fantastic", + "start": 36.52, + "end": 37.06 + } + ] + }, + { + "start": 38.26, + "end": 42.36, + "text": "organization for unstructured learning. So if you're in between jobs and you just like", + "words": [ + { + "word": "organization", + "start": 38.26, + "end": 38.62 + }, + { + "word": "for", + "start": 38.62, + "end": 38.98 + }, + { + "word": "unstructured", + "start": 38.98, + "end": 39.48 + }, + { + "word": "learning.", + "start": 39.48, + "end": 39.92 + }, + { + "word": "So", + "start": 40.18, + "end": 40.26 + }, + { + "word": "if", + "start": 40.26, + "end": 40.34 + }, + { + "word": "you're", + "start": 40.34, + "end": 40.68 + }, + { + "word": "in", + "start": 40.68, + "end": 40.9 + }, + { + "word": "between", + "start": 40.9, + "end": 41.12 + }, + { + "word": "jobs", + "start": 41.12, + "end": 41.64 + }, + { + "word": "and", + "start": 41.64, + "end": 41.8 + }, + { + "word": "you", + "start": 41.8, + "end": 41.94 + }, + { + "word": "just", + "start": 41.94, + "end": 42.14 + }, + { + "word": "like", + "start": 42.14, + "end": 42.36 + } + ] + }, + { + "start": 42.36, + "end": 45.86, + "text": "want to be a better programmer, this is a place to really check out. You can talk to", + "words": [ + { + "word": "want", + "start": 42.36, + "end": 42.5 + }, + { + "word": "to", + "start": 42.5, + "end": 42.72 + }, + { + "word": "be", + "start": 42.72, + "end": 42.86 + }, + { + "word": "a", + "start": 42.86, + "end": 42.98 + }, + { + "word": "better", + "start": 42.98, + "end": 43.18 + }, + { + "word": "programmer,", + "start": 43.18, + "end": 43.56 + }, + { + "word": "this", + "start": 43.64, + "end": 43.78 + }, + { + "word": "is", + "start": 43.78, + "end": 44.0 + }, + { + "word": "a", + "start": 44.0, + "end": 44.12 + }, + { + "word": "place", + "start": 44.12, + "end": 44.38 + }, + { + "word": "to", + "start": 44.38, + "end": 44.64 + }, + { + "word": "really", + "start": 44.64, + "end": 44.84 + }, + { + "word": "check", + "start": 44.84, + "end": 45.06 + }, + { + "word": "out.", + "start": 45.06, + "end": 45.32 + }, + { + "word": "You", + "start": 45.44, + "end": 45.5 + }, + { + "word": "can", + "start": 45.5, + "end": 45.62 + }, + { + "word": "talk", + "start": 45.62, + "end": 45.74 + }, + { + "word": "to", + "start": 45.74, + "end": 45.86 + } + ] + }, + { + "start": 45.86, + "end": 51.64, + "text": "me about it later. I'm also the host of a little meetup called Side Project Saturday.", + "words": [ + { + "word": "me", + "start": 45.86, + "end": 46.04 + }, + { + "word": "about", + "start": 46.04, + "end": 46.24 + }, + { + "word": "it", + "start": 46.24, + "end": 46.4 + }, + { + "word": "later.", + "start": 46.4, + "end": 46.66 + }, + { + "word": "I'm", + "start": 48.0, + "end": 48.36 + }, + { + "word": "also", + "start": 48.36, + "end": 48.68 + }, + { + "word": "the", + "start": 48.68, + "end": 48.94 + }, + { + "word": "host", + "start": 48.94, + "end": 49.28 + }, + { + "word": "of", + "start": 49.28, + "end": 49.74 + }, + { + "word": "a", + "start": 49.74, + "end": 49.94 + }, + { + "word": "little", + "start": 49.94, + "end": 50.1 + }, + { + "word": "meetup", + "start": 50.1, + "end": 50.44 + }, + { + "word": "called", + "start": 50.44, + "end": 50.72 + }, + { + "word": "Side", + "start": 50.72, + "end": 50.98 + }, + { + "word": "Project", + "start": 50.98, + "end": 51.24 + }, + { + "word": "Saturday.", + "start": 51.24, + "end": 51.64 + } + ] + }, + { + "start": 52.72, + "end": 56.38, + "text": "I will give a link to that later. It's just a place where you can come work on your side", + "words": [ + { + "word": "I", + "start": 52.72, + "end": 53.02 + }, + { + "word": "will", + "start": 53.02, + "end": 53.24 + }, + { + "word": "give", + "start": 53.24, + "end": 53.38 + }, + { + "word": "a", + "start": 53.38, + "end": 53.48 + }, + { + "word": "link", + "start": 53.48, + "end": 53.56 + }, + { + "word": "to", + "start": 53.56, + "end": 53.72 + }, + { + "word": "that", + "start": 53.72, + "end": 53.84 + }, + { + "word": "later.", + "start": 53.84, + "end": 54.2 + }, + { + "word": "It's", + "start": 54.36, + "end": 54.52 + }, + { + "word": "just", + "start": 54.52, + "end": 54.7 + }, + { + "word": "a", + "start": 54.7, + "end": 54.94 + }, + { + "word": "place", + "start": 54.94, + "end": 55.08 + }, + { + "word": "where", + "start": 55.08, + "end": 55.24 + }, + { + "word": "you", + "start": 55.24, + "end": 55.32 + }, + { + "word": "can", + "start": 55.32, + "end": 55.62 + }, + { + "word": "come", + "start": 55.62, + "end": 55.8 + }, + { + "word": "work", + "start": 55.8, + "end": 55.94 + }, + { + "word": "on", + "start": 55.94, + "end": 56.08 + }, + { + "word": "your", + "start": 56.08, + "end": 56.24 + }, + { + "word": "side", + "start": 56.24, + "end": 56.38 + } + ] + }, + { + "start": 56.38, + "end": 61.76, + "text": "projects every Saturday morning. And I am a former engineer at Oxide Computer Company.", + "words": [ + { + "word": "projects", + "start": 56.38, + "end": 56.64 + }, + { + "word": "every", + "start": 56.64, + "end": 56.86 + }, + { + "word": "Saturday", + "start": 56.86, + "end": 57.14 + }, + { + "word": "morning.", + "start": 57.14, + "end": 57.58 + }, + { + "word": "And", + "start": 58.44, + "end": 58.8 + }, + { + "word": "I", + "start": 58.8, + "end": 58.92 + }, + { + "word": "am", + "start": 58.92, + "end": 59.08 + }, + { + "word": "a", + "start": 59.08, + "end": 59.28 + }, + { + "word": "former", + "start": 59.28, + "end": 59.66 + }, + { + "word": "engineer", + "start": 59.66, + "end": 60.16 + }, + { + "word": "at", + "start": 60.16, + "end": 60.7 + }, + { + "word": "Oxide", + "start": 60.7, + "end": 61.04 + }, + { + "word": "Computer", + "start": 61.04, + "end": 61.36 + }, + { + "word": "Company.", + "start": 61.36, + "end": 61.76 + } + ] + }, + { + "start": 62.62, + "end": 67.18, + "text": "A lot of what I'm going to talk about today comes from what I learned there and what I", + "words": [ + { + "word": "A", + "start": 62.62, + "end": 62.74 + }, + { + "word": "lot", + "start": 62.74, + "end": 63.0 + }, + { + "word": "of", + "start": 63.0, + "end": 63.26 + }, + { + "word": "what", + "start": 63.26, + "end": 63.4 + }, + { + "word": "I'm", + "start": 63.4, + "end": 63.48 + }, + { + "word": "going", + "start": 63.48, + "end": 63.58 + }, + { + "word": "to", + "start": 63.58, + "end": 63.7 + }, + { + "word": "talk", + "start": 63.7, + "end": 63.84 + }, + { + "word": "about", + "start": 63.84, + "end": 64.12 + }, + { + "word": "today", + "start": 64.12, + "end": 64.7 + }, + { + "word": "comes", + "start": 64.7, + "end": 65.58 + }, + { + "word": "from", + "start": 65.58, + "end": 66.02 + }, + { + "word": "what", + "start": 66.02, + "end": 66.24 + }, + { + "word": "I", + "start": 66.24, + "end": 66.44 + }, + { + "word": "learned", + "start": 66.44, + "end": 66.6 + }, + { + "word": "there", + "start": 66.6, + "end": 66.84 + }, + { + "word": "and", + "start": 66.84, + "end": 66.9 + }, + { + "word": "what", + "start": 66.9, + "end": 67.06 + }, + { + "word": "I", + "start": 67.06, + "end": 67.18 + } + ] + }, + { + "start": 67.18, + "end": 73.02, + "text": "directly worked on there. And I've had the great experience to work on a lot of interesting", + "words": [ + { + "word": "directly", + "start": 67.18, + "end": 67.38 + }, + { + "word": "worked", + "start": 67.38, + "end": 67.58 + }, + { + "word": "on", + "start": 67.58, + "end": 67.76 + }, + { + "word": "there.", + "start": 67.76, + "end": 68.16 + }, + { + "word": "And", + "start": 68.64, + "end": 69.02 + }, + { + "word": "I've", + "start": 69.02, + "end": 69.62 + }, + { + "word": "had", + "start": 69.62, + "end": 69.84 + }, + { + "word": "the", + "start": 69.84, + "end": 71.02 + }, + { + "word": "great", + "start": 71.02, + "end": 71.18 + }, + { + "word": "experience", + "start": 71.18, + "end": 71.58 + }, + { + "word": "to", + "start": 71.58, + "end": 71.72 + }, + { + "word": "work", + "start": 71.72, + "end": 71.84 + }, + { + "word": "on", + "start": 71.84, + "end": 71.96 + }, + { + "word": "a", + "start": 71.96, + "end": 72.02 + }, + { + "word": "lot", + "start": 72.02, + "end": 72.22 + }, + { + "word": "of", + "start": 72.22, + "end": 72.6 + }, + { + "word": "interesting", + "start": 72.6, + "end": 73.02 + } + ] + }, + { + "start": 73.02, + "end": 78.58, + "text": "projects. So I was a front-end architect for the Discovery, essentially, who owned Food", + "words": [ + { + "word": "projects.", + "start": 73.02, + "end": 73.52 + }, + { + "word": "So", + "start": 73.68, + "end": 73.86 + }, + { + "word": "I", + "start": 73.86, + "end": 73.92 + }, + { + "word": "was", + "start": 73.92, + "end": 74.04 + }, + { + "word": "a", + "start": 74.04, + "end": 74.18 + }, + { + "word": "front", + "start": 74.18, + "end": 74.32 + }, + { + "word": "-end", + "start": 74.32, + "end": 74.5 + }, + { + "word": "architect", + "start": 74.5, + "end": 75.02 + }, + { + "word": "for", + "start": 75.02, + "end": 75.42 + }, + { + "word": "the", + "start": 75.42, + "end": 76.18 + }, + { + "word": "Discovery,", + "start": 76.18, + "end": 76.54 + }, + { + "word": "essentially,", + "start": 76.7, + "end": 77.04 + }, + { + "word": "who", + "start": 77.82, + "end": 77.82 + }, + { + "word": "owned", + "start": 77.82, + "end": 78.24 + }, + { + "word": "Food", + "start": 78.24, + "end": 78.58 + } + ] + }, + { + "start": 78.58, + "end": 82.72, + "text": "Network and Httv and Travel Channel, got to work on those directly. I was an engineer", + "words": [ + { + "word": "Network", + "start": 78.58, + "end": 78.9 + }, + { + "word": "and", + "start": 78.9, + "end": 79.1 + }, + { + "word": "Httv", + "start": 79.1, + "end": 79.52 + }, + { + "word": "and", + "start": 79.52, + "end": 79.6 + }, + { + "word": "Travel", + "start": 79.6, + "end": 79.82 + }, + { + "word": "Channel,", + "start": 79.82, + "end": 80.08 + }, + { + "word": "got", + "start": 80.2, + "end": 80.3 + }, + { + "word": "to", + "start": 80.3, + "end": 80.46 + }, + { + "word": "work", + "start": 80.46, + "end": 80.58 + }, + { + "word": "on", + "start": 80.58, + "end": 80.66 + }, + { + "word": "those", + "start": 80.66, + "end": 80.84 + }, + { + "word": "directly.", + "start": 80.84, + "end": 81.32 + }, + { + "word": "I", + "start": 81.82, + "end": 81.86 + }, + { + "word": "was", + "start": 81.86, + "end": 82.38 + }, + { + "word": "an", + "start": 82.38, + "end": 82.52 + }, + { + "word": "engineer", + "start": 82.52, + "end": 82.72 + } + ] + }, + { + "start": 82.72, + "end": 87.22, + "text": "focused on open source software for a long time at Artsy and then most recently an engineer", + "words": [ + { + "word": "focused", + "start": 82.72, + "end": 83.06 + }, + { + "word": "on", + "start": 83.06, + "end": 83.38 + }, + { + "word": "open", + "start": 83.38, + "end": 83.6 + }, + { + "word": "source", + "start": 83.6, + "end": 83.82 + }, + { + "word": "software", + "start": 83.82, + "end": 84.08 + }, + { + "word": "for", + "start": 84.08, + "end": 84.32 + }, + { + "word": "a", + "start": 84.32, + "end": 84.32 + }, + { + "word": "long", + "start": 84.32, + "end": 84.5 + }, + { + "word": "time", + "start": 84.5, + "end": 84.62 + }, + { + "word": "at", + "start": 84.62, + "end": 84.78 + }, + { + "word": "Artsy", + "start": 84.78, + "end": 85.38 + }, + { + "word": "and", + "start": 85.38, + "end": 85.96 + }, + { + "word": "then", + "start": 85.96, + "end": 86.1 + }, + { + "word": "most", + "start": 86.1, + "end": 86.32 + }, + { + "word": "recently", + "start": 86.32, + "end": 86.76 + }, + { + "word": "an", + "start": 86.76, + "end": 87.02 + }, + { + "word": "engineer", + "start": 87.02, + "end": 87.22 + } + ] + }, + { + "start": 87.22, + "end": 93.72, + "text": "at Oxide. And so here's a brief outline of what I'm going to talk about today. So just", + "words": [ + { + "word": "at", + "start": 87.22, + "end": 87.42 + }, + { + "word": "Oxide.", + "start": 87.42, + "end": 87.72 + }, + { + "word": "And", + "start": 89.76, + "end": 90.1 + }, + { + "word": "so", + "start": 90.1, + "end": 90.34 + }, + { + "word": "here's", + "start": 90.34, + "end": 90.52 + }, + { + "word": "a", + "start": 90.52, + "end": 90.96 + }, + { + "word": "brief", + "start": 90.96, + "end": 91.16 + }, + { + "word": "outline", + "start": 91.16, + "end": 91.52 + }, + { + "word": "of", + "start": 91.52, + "end": 91.62 + }, + { + "word": "what", + "start": 91.62, + "end": 91.72 + }, + { + "word": "I'm", + "start": 91.72, + "end": 91.86 + }, + { + "word": "going", + "start": 91.86, + "end": 91.86 + }, + { + "word": "to", + "start": 91.86, + "end": 91.98 + }, + { + "word": "talk", + "start": 91.98, + "end": 92.08 + }, + { + "word": "about", + "start": 92.08, + "end": 92.22 + }, + { + "word": "today.", + "start": 92.22, + "end": 92.54 + }, + { + "word": "So", + "start": 93.36, + "end": 93.36 + }, + { + "word": "just", + "start": 93.36, + "end": 93.72 + } + ] + }, + { + "start": 93.72, + "end": 99.82, + "text": "like what I mean by co-gen, because the definition of what that means has changed a lot, I'm", + "words": [ + { + "word": "like", + "start": 93.72, + "end": 93.88 + }, + { + "word": "what", + "start": 93.88, + "end": 94.02 + }, + { + "word": "I", + "start": 94.02, + "end": 94.22 + }, + { + "word": "mean", + "start": 94.22, + "end": 94.32 + }, + { + "word": "by", + "start": 94.32, + "end": 94.56 + }, + { + "word": "co", + "start": 94.56, + "end": 94.74 + }, + { + "word": "-gen,", + "start": 94.74, + "end": 94.9 + }, + { + "word": "because", + "start": 95.0, + "end": 95.32 + }, + { + "word": "the", + "start": 95.32, + "end": 95.96 + }, + { + "word": "definition", + "start": 95.96, + "end": 96.58 + }, + { + "word": "of", + "start": 96.58, + "end": 96.88 + }, + { + "word": "what", + "start": 96.88, + "end": 97.02 + }, + { + "word": "that", + "start": 97.02, + "end": 97.26 + }, + { + "word": "means", + "start": 97.26, + "end": 97.42 + }, + { + "word": "has", + "start": 97.42, + "end": 97.68 + }, + { + "word": "changed", + "start": 97.68, + "end": 97.96 + }, + { + "word": "a", + "start": 97.96, + "end": 98.14 + }, + { + "word": "lot,", + "start": 98.14, + "end": 98.36 + }, + { + "word": "I'm", + "start": 99.28, + "end": 99.82 + } + ] + }, + { + "start": 99.82, + "end": 105.08, + "text": "going to talk about some of how Oxide actually does co-gen for their code base, how they", + "words": [ + { + "word": "going", + "start": 99.82, + "end": 99.88 + }, + { + "word": "to", + "start": 99.88, + "end": 100.0 + }, + { + "word": "talk", + "start": 100.0, + "end": 100.1 + }, + { + "word": "about", + "start": 100.1, + "end": 100.58 + }, + { + "word": "some", + "start": 100.58, + "end": 100.92 + }, + { + "word": "of", + "start": 100.92, + "end": 101.2 + }, + { + "word": "how", + "start": 101.2, + "end": 101.52 + }, + { + "word": "Oxide", + "start": 101.52, + "end": 102.18 + }, + { + "word": "actually", + "start": 102.18, + "end": 102.72 + }, + { + "word": "does", + "start": 102.72, + "end": 103.16 + }, + { + "word": "co", + "start": 103.16, + "end": 103.42 + }, + { + "word": "-gen", + "start": 103.42, + "end": 103.66 + }, + { + "word": "for", + "start": 103.66, + "end": 103.86 + }, + { + "word": "their", + "start": 103.86, + "end": 104.08 + }, + { + "word": "code", + "start": 104.08, + "end": 104.28 + }, + { + "word": "base,", + "start": 104.28, + "end": 104.58 + }, + { + "word": "how", + "start": 104.64, + "end": 104.92 + }, + { + "word": "they", + "start": 104.92, + "end": 105.08 + } + ] + }, + { + "start": 105.08, + "end": 111.1, + "text": "generate their SDKs from open API specs. I am going to talk about a project that I did", + "words": [ + { + "word": "generate", + "start": 105.08, + "end": 105.4 + }, + { + "word": "their", + "start": 105.4, + "end": 106.06 + }, + { + "word": "SDKs", + "start": 106.06, + "end": 106.68 + }, + { + "word": "from", + "start": 106.68, + "end": 106.92 + }, + { + "word": "open", + "start": 106.92, + "end": 107.14 + }, + { + "word": "API", + "start": 107.14, + "end": 107.38 + }, + { + "word": "specs.", + "start": 107.38, + "end": 107.76 + }, + { + "word": "I", + "start": 109.24, + "end": 109.72 + }, + { + "word": "am", + "start": 109.72, + "end": 109.86 + }, + { + "word": "going", + "start": 109.86, + "end": 109.94 + }, + { + "word": "to", + "start": 109.94, + "end": 110.04 + }, + { + "word": "talk", + "start": 110.04, + "end": 110.14 + }, + { + "word": "about", + "start": 110.14, + "end": 110.28 + }, + { + "word": "a", + "start": 110.28, + "end": 110.52 + }, + { + "word": "project", + "start": 110.52, + "end": 110.74 + }, + { + "word": "that", + "start": 110.74, + "end": 110.88 + }, + { + "word": "I", + "start": 110.88, + "end": 111.0 + }, + { + "word": "did", + "start": 111.0, + "end": 111.1 + } + ] + }, + { + "start": 111.1, + "end": 118.42, + "text": "at Recurse Center to build a scriptable WebView framework. So if you wanted electron but scriptable,", + "words": [ + { + "word": "at", + "start": 111.1, + "end": 111.1 + }, + { + "word": "Recurse", + "start": 111.1, + "end": 111.6 + }, + { + "word": "Center", + "start": 111.6, + "end": 112.0 + }, + { + "word": "to", + "start": 112.0, + "end": 113.14 + }, + { + "word": "build", + "start": 113.14, + "end": 113.52 + }, + { + "word": "a", + "start": 113.52, + "end": 113.82 + }, + { + "word": "scriptable", + "start": 113.82, + "end": 114.5 + }, + { + "word": "WebView", + "start": 114.5, + "end": 115.06 + }, + { + "word": "framework.", + "start": 115.06, + "end": 115.6 + }, + { + "word": "So", + "start": 115.8, + "end": 115.94 + }, + { + "word": "if", + "start": 115.94, + "end": 116.0 + }, + { + "word": "you", + "start": 116.0, + "end": 116.18 + }, + { + "word": "wanted", + "start": 116.18, + "end": 116.42 + }, + { + "word": "electron", + "start": 116.42, + "end": 117.16 + }, + { + "word": "but", + "start": 117.16, + "end": 117.94 + }, + { + "word": "scriptable,", + "start": 117.94, + "end": 118.42 + } + ] + }, + { + "start": 118.52, + "end": 123.42, + "text": "what would that look like? And then scattered throughout the talk, there's going to be some", + "words": [ + { + "word": "what", + "start": 118.52, + "end": 118.64 + }, + { + "word": "would", + "start": 118.64, + "end": 118.74 + }, + { + "word": "that", + "start": 118.74, + "end": 118.94 + }, + { + "word": "look", + "start": 118.94, + "end": 119.04 + }, + { + "word": "like?", + "start": 119.04, + "end": 119.5 + }, + { + "word": "And", + "start": 119.86, + "end": 120.0 + }, + { + "word": "then", + "start": 120.0, + "end": 120.98 + }, + { + "word": "scattered", + "start": 120.98, + "end": 121.28 + }, + { + "word": "throughout", + "start": 121.28, + "end": 121.56 + }, + { + "word": "the", + "start": 121.56, + "end": 121.78 + }, + { + "word": "talk,", + "start": 121.78, + "end": 121.98 + }, + { + "word": "there's", + "start": 122.04, + "end": 122.22 + }, + { + "word": "going", + "start": 122.22, + "end": 122.34 + }, + { + "word": "to", + "start": 122.34, + "end": 122.46 + }, + { + "word": "be", + "start": 122.46, + "end": 122.74 + }, + { + "word": "some", + "start": 122.74, + "end": 123.42 + } + ] + }, + { + "start": 124.32, + "end": 129.8, + "text": "tips and hard-learned tricks of just things that you need to keep in mind if you're doing", + "words": [ + { + "word": "tips", + "start": 124.32, + "end": 124.8 + }, + { + "word": "and", + "start": 124.8, + "end": 125.28 + }, + { + "word": "hard", + "start": 125.28, + "end": 125.72 + }, + { + "word": "-learned", + "start": 125.72, + "end": 126.32 + }, + { + "word": "tricks", + "start": 126.32, + "end": 126.64 + }, + { + "word": "of", + "start": 126.64, + "end": 127.74 + }, + { + "word": "just", + "start": 127.74, + "end": 128.14 + }, + { + "word": "things", + "start": 128.14, + "end": 128.3 + }, + { + "word": "that", + "start": 128.3, + "end": 128.46 + }, + { + "word": "you", + "start": 128.46, + "end": 128.62 + }, + { + "word": "need", + "start": 128.62, + "end": 128.7 + }, + { + "word": "to", + "start": 128.7, + "end": 128.8 + }, + { + "word": "keep", + "start": 128.8, + "end": 128.88 + }, + { + "word": "in", + "start": 128.88, + "end": 129.06 + }, + { + "word": "mind", + "start": 129.06, + "end": 129.28 + }, + { + "word": "if", + "start": 129.28, + "end": 129.42 + }, + { + "word": "you're", + "start": 129.42, + "end": 129.58 + }, + { + "word": "doing", + "start": 129.58, + "end": 129.8 + } + ] + }, + { + "start": 129.8, + "end": 137.26, + "text": "co-gen. Okay. So what do I mean? There are kind of like two kinds of categories of co-gen", + "words": [ + { + "word": "co", + "start": 129.8, + "end": 130.04 + }, + { + "word": "-gen.", + "start": 130.04, + "end": 130.24 + }, + { + "word": "Okay.", + "start": 131.82, + "end": 132.18 + }, + { + "word": "So", + "start": 132.26, + "end": 132.6 + }, + { + "word": "what", + "start": 132.6, + "end": 132.7 + }, + { + "word": "do", + "start": 132.7, + "end": 132.86 + }, + { + "word": "I", + "start": 132.86, + "end": 132.86 + }, + { + "word": "mean?", + "start": 132.86, + "end": 133.1 + }, + { + "word": "There", + "start": 134.04, + "end": 134.28 + }, + { + "word": "are", + "start": 134.28, + "end": 134.54 + }, + { + "word": "kind", + "start": 134.54, + "end": 134.66 + }, + { + "word": "of", + "start": 134.66, + "end": 134.84 + }, + { + "word": "like", + "start": 134.84, + "end": 135.1 + }, + { + "word": "two", + "start": 135.1, + "end": 135.8 + }, + { + "word": "kinds", + "start": 135.8, + "end": 136.14 + }, + { + "word": "of", + "start": 136.14, + "end": 136.36 + }, + { + "word": "categories", + "start": 136.36, + "end": 136.84 + }, + { + "word": "of", + "start": 136.84, + "end": 137.02 + }, + { + "word": "co", + "start": 137.02, + "end": 137.14 + }, + { + "word": "-gen", + "start": 137.14, + "end": 137.26 + } + ] + }, + { + "start": 137.26, + "end": 141.88, + "text": "that I think about these days. One is modeled after this company that's a New York company", + "words": [ + { + "word": "that", + "start": 137.26, + "end": 137.38 + }, + { + "word": "I", + "start": 137.38, + "end": 137.52 + }, + { + "word": "think", + "start": 137.52, + "end": 137.62 + }, + { + "word": "about", + "start": 137.62, + "end": 137.78 + }, + { + "word": "these", + "start": 137.78, + "end": 138.0 + }, + { + "word": "days.", + "start": 138.0, + "end": 138.4 + }, + { + "word": "One", + "start": 138.7, + "end": 139.1 + }, + { + "word": "is", + "start": 139.1, + "end": 139.72 + }, + { + "word": "modeled", + "start": 139.72, + "end": 140.08 + }, + { + "word": "after", + "start": 140.08, + "end": 140.4 + }, + { + "word": "this", + "start": 140.4, + "end": 140.64 + }, + { + "word": "company", + "start": 140.64, + "end": 140.9 + }, + { + "word": "that's", + "start": 140.9, + "end": 141.42 + }, + { + "word": "a", + "start": 141.42, + "end": 141.54 + }, + { + "word": "New", + "start": 141.54, + "end": 141.56 + }, + { + "word": "York", + "start": 141.56, + "end": 141.7 + }, + { + "word": "company", + "start": 141.7, + "end": 141.88 + } + ] + }, + { + "start": 141.88, + "end": 148.3, + "text": "called Stainless. So Stainless takes your open API spec and some configuration and generates", + "words": [ + { + "word": "called", + "start": 141.88, + "end": 142.06 + }, + { + "word": "Stainless.", + "start": 142.06, + "end": 142.66 + }, + { + "word": "So", + "start": 143.36, + "end": 143.6 + }, + { + "word": "Stainless", + "start": 143.6, + "end": 144.16 + }, + { + "word": "takes", + "start": 144.16, + "end": 145.1 + }, + { + "word": "your", + "start": 145.1, + "end": 145.36 + }, + { + "word": "open", + "start": 145.36, + "end": 145.56 + }, + { + "word": "API", + "start": 145.56, + "end": 145.84 + }, + { + "word": "spec", + "start": 145.84, + "end": 146.26 + }, + { + "word": "and", + "start": 146.26, + "end": 146.92 + }, + { + "word": "some", + "start": 146.92, + "end": 147.14 + }, + { + "word": "configuration", + "start": 147.14, + "end": 147.68 + }, + { + "word": "and", + "start": 147.68, + "end": 148.0 + }, + { + "word": "generates", + "start": 148.0, + "end": 148.3 + } + ] + }, + { + "start": 148.3, + "end": 153.82, + "text": "some high quality SDKs for you. They're a fantastic company and a lot of products that", + "words": [ + { + "word": "some", + "start": 148.3, + "end": 148.56 + }, + { + "word": "high", + "start": 148.56, + "end": 148.7 + }, + { + "word": "quality", + "start": 148.7, + "end": 149.02 + }, + { + "word": "SDKs", + "start": 149.02, + "end": 149.5 + }, + { + "word": "for", + "start": 149.5, + "end": 149.7 + }, + { + "word": "you.", + "start": 149.7, + "end": 149.94 + }, + { + "word": "They're", + "start": 150.14, + "end": 150.42 + }, + { + "word": "a", + "start": 150.42, + "end": 150.54 + }, + { + "word": "fantastic", + "start": 150.54, + "end": 150.66 + }, + { + "word": "company", + "start": 150.66, + "end": 151.2 + }, + { + "word": "and", + "start": 151.2, + "end": 151.8 + }, + { + "word": "a", + "start": 151.8, + "end": 152.04 + }, + { + "word": "lot", + "start": 152.04, + "end": 152.32 + }, + { + "word": "of", + "start": 152.32, + "end": 153.14 + }, + { + "word": "products", + "start": 153.14, + "end": 153.48 + }, + { + "word": "that", + "start": 153.48, + "end": 153.82 + } + ] + }, + { + "start": 153.82, + "end": 158.8, + "text": "you may know and may use them. So Cloudflare uses them to generate their SDKs. Open AI", + "words": [ + { + "word": "you", + "start": 153.82, + "end": 154.04 + }, + { + "word": "may", + "start": 154.04, + "end": 154.18 + }, + { + "word": "know", + "start": 154.18, + "end": 154.4 + }, + { + "word": "and", + "start": 154.4, + "end": 154.58 + }, + { + "word": "may", + "start": 154.58, + "end": 154.9 + }, + { + "word": "use", + "start": 154.9, + "end": 155.24 + }, + { + "word": "them.", + "start": 155.24, + "end": 155.5 + }, + { + "word": "So", + "start": 155.68, + "end": 155.82 + }, + { + "word": "Cloudflare", + "start": 155.82, + "end": 156.58 + }, + { + "word": "uses", + "start": 156.58, + "end": 156.88 + }, + { + "word": "them", + "start": 156.88, + "end": 157.06 + }, + { + "word": "to", + "start": 157.06, + "end": 157.26 + }, + { + "word": "generate", + "start": 157.26, + "end": 157.44 + }, + { + "word": "their", + "start": 157.44, + "end": 157.66 + }, + { + "word": "SDKs.", + "start": 157.66, + "end": 158.18 + }, + { + "word": "Open", + "start": 158.24, + "end": 158.44 + }, + { + "word": "AI", + "start": 158.44, + "end": 158.8 + } + ] + }, + { + "start": 158.8, + "end": 164.78, + "text": "uses them to generate their SDKs. So they're very successful. And then there's like the", + "words": [ + { + "word": "uses", + "start": 158.8, + "end": 159.08 + }, + { + "word": "them", + "start": 159.08, + "end": 159.28 + }, + { + "word": "to", + "start": 159.28, + "end": 159.44 + }, + { + "word": "generate", + "start": 159.44, + "end": 159.62 + }, + { + "word": "their", + "start": 159.62, + "end": 159.84 + }, + { + "word": "SDKs.", + "start": 159.84, + "end": 160.32 + }, + { + "word": "So", + "start": 160.34, + "end": 160.86 + }, + { + "word": "they're", + "start": 160.86, + "end": 161.66 + }, + { + "word": "very", + "start": 161.66, + "end": 162.02 + }, + { + "word": "successful.", + "start": 162.02, + "end": 162.62 + }, + { + "word": "And", + "start": 163.52, + "end": 163.94 + }, + { + "word": "then", + "start": 163.94, + "end": 164.08 + }, + { + "word": "there's", + "start": 164.08, + "end": 164.44 + }, + { + "word": "like", + "start": 164.44, + "end": 164.64 + }, + { + "word": "the", + "start": 164.64, + "end": 164.78 + } + ] + }, + { + "start": 165.24, + "end": 171.16, + "text": "more new age co-gen. So there is a company called co-gen, who knew? And they do what", + "words": [ + { + "word": "more", + "start": 165.24, + "end": 165.64 + }, + { + "word": "new", + "start": 165.64, + "end": 166.0 + }, + { + "word": "age", + "start": 166.0, + "end": 166.38 + }, + { + "word": "co", + "start": 166.38, + "end": 166.68 + }, + { + "word": "-gen.", + "start": 166.68, + "end": 166.98 + }, + { + "word": "So", + "start": 167.46, + "end": 167.54 + }, + { + "word": "there", + "start": 167.54, + "end": 167.66 + }, + { + "word": "is", + "start": 167.66, + "end": 167.82 + }, + { + "word": "a", + "start": 167.82, + "end": 167.84 + }, + { + "word": "company", + "start": 167.84, + "end": 168.12 + }, + { + "word": "called", + "start": 168.12, + "end": 168.36 + }, + { + "word": "co", + "start": 168.36, + "end": 168.56 + }, + { + "word": "-gen,", + "start": 168.56, + "end": 168.72 + }, + { + "word": "who", + "start": 168.8, + "end": 168.88 + }, + { + "word": "knew?", + "start": 168.88, + "end": 169.1 + }, + { + "word": "And", + "start": 170.16, + "end": 170.56 + }, + { + "word": "they", + "start": 170.56, + "end": 170.84 + }, + { + "word": "do", + "start": 170.84, + "end": 171.04 + }, + { + "word": "what", + "start": 171.04, + "end": 171.16 + } + ] + }, + { + "start": 171.16, + "end": 175.36, + "text": "you would expect. You ask an LLM agent to generate you some stuff and it does that.", + "words": [ + { + "word": "you", + "start": 171.16, + "end": 171.28 + }, + { + "word": "would", + "start": 171.28, + "end": 171.48 + }, + { + "word": "expect.", + "start": 171.48, + "end": 171.74 + }, + { + "word": "You", + "start": 171.78, + "end": 172.06 + }, + { + "word": "ask", + "start": 172.06, + "end": 172.44 + }, + { + "word": "an", + "start": 172.44, + "end": 172.7 + }, + { + "word": "LLM", + "start": 172.7, + "end": 172.96 + }, + { + "word": "agent", + "start": 172.96, + "end": 173.22 + }, + { + "word": "to", + "start": 173.22, + "end": 173.62 + }, + { + "word": "generate", + "start": 173.62, + "end": 173.86 + }, + { + "word": "you", + "start": 173.86, + "end": 174.02 + }, + { + "word": "some", + "start": 174.02, + "end": 174.2 + }, + { + "word": "stuff", + "start": 174.2, + "end": 174.4 + }, + { + "word": "and", + "start": 174.4, + "end": 174.58 + }, + { + "word": "it", + "start": 174.58, + "end": 174.82 + }, + { + "word": "does", + "start": 174.82, + "end": 175.02 + }, + { + "word": "that.", + "start": 175.02, + "end": 175.36 + } + ] + }, + { + "start": 175.78, + "end": 179.54, + "text": "I'll talk a little bit more about that at the end. I think there's obviously a lot of", + "words": [ + { + "word": "I'll", + "start": 175.78, + "end": 176.06 + }, + { + "word": "talk", + "start": 176.06, + "end": 176.2 + }, + { + "word": "a", + "start": 176.2, + "end": 176.28 + }, + { + "word": "little", + "start": 176.28, + "end": 176.48 + }, + { + "word": "bit", + "start": 176.48, + "end": 176.62 + }, + { + "word": "more", + "start": 176.62, + "end": 176.8 + }, + { + "word": "about", + "start": 176.8, + "end": 176.94 + }, + { + "word": "that", + "start": 176.94, + "end": 177.18 + }, + { + "word": "at", + "start": 177.18, + "end": 177.38 + }, + { + "word": "the", + "start": 177.38, + "end": 177.4 + }, + { + "word": "end.", + "start": 177.4, + "end": 177.74 + }, + { + "word": "I", + "start": 177.86, + "end": 178.18 + }, + { + "word": "think", + "start": 178.18, + "end": 178.38 + }, + { + "word": "there's", + "start": 178.38, + "end": 178.66 + }, + { + "word": "obviously", + "start": 178.66, + "end": 179.06 + }, + { + "word": "a", + "start": 179.06, + "end": 179.18 + }, + { + "word": "lot", + "start": 179.18, + "end": 179.34 + }, + { + "word": "of", + "start": 179.34, + "end": 179.54 + } + ] + }, + { + "start": 179.54, + "end": 184.0, + "text": "interesting things and we can't ignore this. But I do want to emphasize the sort of more", + "words": [ + { + "word": "interesting", + "start": 179.54, + "end": 179.8 + }, + { + "word": "things", + "start": 179.8, + "end": 180.1 + }, + { + "word": "and", + "start": 180.1, + "end": 180.22 + }, + { + "word": "we", + "start": 180.22, + "end": 180.34 + }, + { + "word": "can't", + "start": 180.34, + "end": 180.64 + }, + { + "word": "ignore", + "start": 180.64, + "end": 180.98 + }, + { + "word": "this.", + "start": 180.98, + "end": 181.38 + }, + { + "word": "But", + "start": 181.6, + "end": 182.0 + }, + { + "word": "I", + "start": 182.0, + "end": 182.48 + }, + { + "word": "do", + "start": 182.48, + "end": 182.68 + }, + { + "word": "want", + "start": 182.68, + "end": 182.84 + }, + { + "word": "to", + "start": 182.84, + "end": 183.02 + }, + { + "word": "emphasize", + "start": 183.02, + "end": 183.38 + }, + { + "word": "the", + "start": 183.38, + "end": 183.58 + }, + { + "word": "sort", + "start": 183.58, + "end": 183.68 + }, + { + "word": "of", + "start": 183.68, + "end": 183.8 + }, + { + "word": "more", + "start": 183.8, + "end": 184.0 + } + ] + }, + { + "start": 184.0, + "end": 188.52, + "text": "traditional aspect of writing code to generate code because I'm a nerd and that's what I", + "words": [ + { + "word": "traditional", + "start": 184.0, + "end": 184.68 + }, + { + "word": "aspect", + "start": 184.68, + "end": 185.16 + }, + { + "word": "of", + "start": 185.16, + "end": 185.36 + }, + { + "word": "writing", + "start": 185.36, + "end": 185.64 + }, + { + "word": "code", + "start": 185.64, + "end": 185.86 + }, + { + "word": "to", + "start": 185.86, + "end": 186.08 + }, + { + "word": "generate", + "start": 186.08, + "end": 186.36 + }, + { + "word": "code", + "start": 186.36, + "end": 186.84 + }, + { + "word": "because", + "start": 186.84, + "end": 187.7 + }, + { + "word": "I'm", + "start": 187.7, + "end": 187.9 + }, + { + "word": "a", + "start": 187.9, + "end": 187.98 + }, + { + "word": "nerd", + "start": 187.98, + "end": 188.1 + }, + { + "word": "and", + "start": 188.1, + "end": 188.14 + }, + { + "word": "that's", + "start": 188.14, + "end": 188.28 + }, + { + "word": "what", + "start": 188.28, + "end": 188.4 + }, + { + "word": "I", + "start": 188.4, + "end": 188.52 + } + ] + }, + { + "start": 188.52, + "end": 195.62, + "text": "like. So I'm going to talk a little bit about how Oxide uses co-gen. So if you've never", + "words": [ + { + "word": "like.", + "start": 188.52, + "end": 188.7 + }, + { + "word": "So", + "start": 190.68, + "end": 191.04 + }, + { + "word": "I'm", + "start": 191.04, + "end": 191.4 + }, + { + "word": "going", + "start": 191.4, + "end": 191.5 + }, + { + "word": "to", + "start": 191.5, + "end": 191.54 + }, + { + "word": "talk", + "start": 191.54, + "end": 191.68 + }, + { + "word": "a", + "start": 191.68, + "end": 191.78 + }, + { + "word": "little", + "start": 191.78, + "end": 191.86 + }, + { + "word": "bit", + "start": 191.86, + "end": 192.04 + }, + { + "word": "about", + "start": 192.04, + "end": 192.22 + }, + { + "word": "how", + "start": 192.22, + "end": 192.5 + }, + { + "word": "Oxide", + "start": 192.5, + "end": 192.96 + }, + { + "word": "uses", + "start": 192.96, + "end": 193.6 + }, + { + "word": "co", + "start": 193.6, + "end": 193.84 + }, + { + "word": "-gen.", + "start": 193.84, + "end": 194.12 + }, + { + "word": "So", + "start": 195.0, + "end": 195.22 + }, + { + "word": "if", + "start": 195.22, + "end": 195.36 + }, + { + "word": "you've", + "start": 195.36, + "end": 195.48 + }, + { + "word": "never", + "start": 195.48, + "end": 195.62 + } + ] + }, + { + "start": 195.62, + "end": 199.68, + "text": "heard of Oxide computer company, I like to think of them as like the Apple of servers.", + "words": [ + { + "word": "heard", + "start": 195.62, + "end": 195.76 + }, + { + "word": "of", + "start": 195.76, + "end": 195.82 + }, + { + "word": "Oxide", + "start": 195.82, + "end": 196.12 + }, + { + "word": "computer", + "start": 196.12, + "end": 196.46 + }, + { + "word": "company,", + "start": 196.46, + "end": 196.76 + }, + { + "word": "I", + "start": 197.22, + "end": 197.3 + }, + { + "word": "like", + "start": 197.3, + "end": 197.46 + }, + { + "word": "to", + "start": 197.46, + "end": 197.62 + }, + { + "word": "think", + "start": 197.62, + "end": 197.72 + }, + { + "word": "of", + "start": 197.72, + "end": 197.76 + }, + { + "word": "them", + "start": 197.76, + "end": 198.06 + }, + { + "word": "as", + "start": 198.06, + "end": 198.34 + }, + { + "word": "like", + "start": 198.34, + "end": 198.5 + }, + { + "word": "the", + "start": 198.5, + "end": 198.7 + }, + { + "word": "Apple", + "start": 198.7, + "end": 199.0 + }, + { + "word": "of", + "start": 199.0, + "end": 199.28 + }, + { + "word": "servers.", + "start": 199.28, + "end": 199.68 + } + ] + }, + { + "start": 200.66, + "end": 205.36, + "text": "Someone told me once the Apple is the Apple of servers, which you know, fair. But so Oxide", + "words": [ + { + "word": "Someone", + "start": 200.66, + "end": 200.9 + }, + { + "word": "told", + "start": 200.9, + "end": 201.24 + }, + { + "word": "me", + "start": 201.24, + "end": 201.44 + }, + { + "word": "once", + "start": 201.44, + "end": 201.64 + }, + { + "word": "the", + "start": 201.64, + "end": 201.84 + }, + { + "word": "Apple", + "start": 201.84, + "end": 202.04 + }, + { + "word": "is", + "start": 202.04, + "end": 202.2 + }, + { + "word": "the", + "start": 202.2, + "end": 202.34 + }, + { + "word": "Apple", + "start": 202.34, + "end": 202.52 + }, + { + "word": "of", + "start": 202.52, + "end": 202.72 + }, + { + "word": "servers,", + "start": 202.72, + "end": 202.96 + }, + { + "word": "which", + "start": 203.1, + "end": 203.32 + }, + { + "word": "you", + "start": 203.32, + "end": 203.42 + }, + { + "word": "know,", + "start": 203.42, + "end": 203.68 + }, + { + "word": "fair.", + "start": 203.74, + "end": 203.88 + }, + { + "word": "But", + "start": 204.54, + "end": 204.56 + }, + { + "word": "so", + "start": 204.56, + "end": 205.0 + }, + { + "word": "Oxide", + "start": 205.0, + "end": 205.36 + } + ] + }, + { + "start": 205.36, + "end": 209.94, + "text": "makes this beautiful machine. It is an all in one EC2 in a box. You can kind of think", + "words": [ + { + "word": "makes", + "start": 205.36, + "end": 205.56 + }, + { + "word": "this", + "start": 205.56, + "end": 205.84 + }, + { + "word": "beautiful", + "start": 205.84, + "end": 206.3 + }, + { + "word": "machine.", + "start": 206.3, + "end": 206.78 + }, + { + "word": "It", + "start": 206.9, + "end": 207.02 + }, + { + "word": "is", + "start": 207.02, + "end": 207.42 + }, + { + "word": "an", + "start": 207.42, + "end": 207.64 + }, + { + "word": "all", + "start": 207.64, + "end": 207.82 + }, + { + "word": "in", + "start": 207.82, + "end": 208.0 + }, + { + "word": "one", + "start": 208.0, + "end": 208.18 + }, + { + "word": "EC2", + "start": 208.18, + "end": 208.58 + }, + { + "word": "in", + "start": 208.58, + "end": 208.74 + }, + { + "word": "a", + "start": 208.74, + "end": 208.84 + }, + { + "word": "box.", + "start": 208.84, + "end": 209.06 + }, + { + "word": "You", + "start": 209.2, + "end": 209.2 + }, + { + "word": "can", + "start": 209.2, + "end": 209.38 + }, + { + "word": "kind", + "start": 209.38, + "end": 209.54 + }, + { + "word": "of", + "start": 209.54, + "end": 209.68 + }, + { + "word": "think", + "start": 209.68, + "end": 209.94 + } + ] + }, + { + "start": 209.94, + "end": 214.06, + "text": "you just like order it and it comes in this massive crate and you uncrate it and you", + "words": [ + { + "word": "you", + "start": 209.94, + "end": 210.38 + }, + { + "word": "just", + "start": 210.38, + "end": 210.56 + }, + { + "word": "like", + "start": 210.56, + "end": 210.82 + }, + { + "word": "order", + "start": 210.82, + "end": 211.0 + }, + { + "word": "it", + "start": 211.0, + "end": 211.5 + }, + { + "word": "and", + "start": 211.5, + "end": 211.64 + }, + { + "word": "it", + "start": 211.64, + "end": 211.76 + }, + { + "word": "comes", + "start": 211.76, + "end": 211.88 + }, + { + "word": "in", + "start": 211.88, + "end": 211.98 + }, + { + "word": "this", + "start": 211.98, + "end": 212.36 + }, + { + "word": "massive", + "start": 212.36, + "end": 212.82 + }, + { + "word": "crate", + "start": 212.82, + "end": 213.1 + }, + { + "word": "and", + "start": 213.1, + "end": 213.3 + }, + { + "word": "you", + "start": 213.3, + "end": 213.38 + }, + { + "word": "uncrate", + "start": 213.38, + "end": 213.66 + }, + { + "word": "it", + "start": 213.66, + "end": 213.86 + }, + { + "word": "and", + "start": 213.86, + "end": 213.9 + }, + { + "word": "you", + "start": 213.9, + "end": 214.06 + } + ] + }, + { + "start": 214.06, + "end": 216.98, + "text": "roll it in your data center and you plug it in. And in a few hours you can like deploy", + "words": [ + { + "word": "roll", + "start": 214.06, + "end": 214.16 + }, + { + "word": "it", + "start": 214.16, + "end": 214.24 + }, + { + "word": "in", + "start": 214.24, + "end": 214.3 + }, + { + "word": "your", + "start": 214.3, + "end": 214.44 + }, + { + "word": "data", + "start": 214.44, + "end": 214.58 + }, + { + "word": "center", + "start": 214.58, + "end": 214.7 + }, + { + "word": "and", + "start": 214.7, + "end": 214.84 + }, + { + "word": "you", + "start": 214.84, + "end": 214.94 + }, + { + "word": "plug", + "start": 214.94, + "end": 215.04 + }, + { + "word": "it", + "start": 215.04, + "end": 215.24 + }, + { + "word": "in.", + "start": 215.24, + "end": 215.36 + }, + { + "word": "And", + "start": 215.38, + "end": 215.48 + }, + { + "word": "in", + "start": 215.48, + "end": 215.58 + }, + { + "word": "a", + "start": 215.58, + "end": 215.7 + }, + { + "word": "few", + "start": 215.7, + "end": 215.8 + }, + { + "word": "hours", + "start": 215.8, + "end": 216.18 + }, + { + "word": "you", + "start": 216.18, + "end": 216.34 + }, + { + "word": "can", + "start": 216.34, + "end": 216.52 + }, + { + "word": "like", + "start": 216.52, + "end": 216.66 + }, + { + "word": "deploy", + "start": 216.66, + "end": 216.98 + } + ] + }, + { + "start": 216.98, + "end": 225.04, + "text": "VMs to it and it's fantastic, magical piece of hardware and software. And the API is the", + "words": [ + { + "word": "VMs", + "start": 216.98, + "end": 217.32 + }, + { + "word": "to", + "start": 217.32, + "end": 217.46 + }, + { + "word": "it", + "start": 217.46, + "end": 217.58 + }, + { + "word": "and", + "start": 217.58, + "end": 217.72 + }, + { + "word": "it's", + "start": 217.72, + "end": 218.12 + }, + { + "word": "fantastic,", + "start": 218.12, + "end": 218.74 + }, + { + "word": "magical", + "start": 218.76, + "end": 219.16 + }, + { + "word": "piece", + "start": 219.16, + "end": 219.48 + }, + { + "word": "of", + "start": 219.48, + "end": 219.96 + }, + { + "word": "hardware", + "start": 219.96, + "end": 220.3 + }, + { + "word": "and", + "start": 220.3, + "end": 220.66 + }, + { + "word": "software.", + "start": 220.66, + "end": 221.06 + }, + { + "word": "And", + "start": 222.38, + "end": 222.9 + }, + { + "word": "the", + "start": 222.9, + "end": 223.22 + }, + { + "word": "API", + "start": 223.22, + "end": 223.6 + }, + { + "word": "is", + "start": 223.6, + "end": 224.6 + }, + { + "word": "the", + "start": 224.6, + "end": 225.04 + } + ] + }, + { + "start": 225.04, + "end": 229.32, + "text": "like primary interface for interacting with this thing. Like that is the front door of", + "words": [ + { + "word": "like", + "start": 225.04, + "end": 225.34 + }, + { + "word": "primary", + "start": 225.34, + "end": 225.62 + }, + { + "word": "interface", + "start": 225.62, + "end": 226.12 + }, + { + "word": "for", + "start": 226.12, + "end": 226.4 + }, + { + "word": "interacting", + "start": 226.4, + "end": 226.72 + }, + { + "word": "with", + "start": 226.72, + "end": 226.92 + }, + { + "word": "this", + "start": 226.92, + "end": 227.14 + }, + { + "word": "thing.", + "start": 227.14, + "end": 227.4 + }, + { + "word": "Like", + "start": 227.42, + "end": 227.84 + }, + { + "word": "that", + "start": 227.84, + "end": 228.0 + }, + { + "word": "is", + "start": 228.0, + "end": 228.32 + }, + { + "word": "the", + "start": 228.32, + "end": 228.54 + }, + { + "word": "front", + "start": 228.54, + "end": 228.74 + }, + { + "word": "door", + "start": 228.74, + "end": 229.08 + }, + { + "word": "of", + "start": 229.08, + "end": 229.32 + } + ] + }, + { + "start": 229.32, + "end": 234.34, + "text": "the product. So you like want to create a virtual disk. You just like send the disk", + "words": [ + { + "word": "the", + "start": 229.32, + "end": 229.5 + }, + { + "word": "product.", + "start": 229.5, + "end": 229.82 + }, + { + "word": "So", + "start": 229.96, + "end": 230.48 + }, + { + "word": "you", + "start": 230.48, + "end": 231.04 + }, + { + "word": "like", + "start": 231.04, + "end": 231.38 + }, + { + "word": "want", + "start": 231.38, + "end": 231.52 + }, + { + "word": "to", + "start": 231.52, + "end": 231.74 + }, + { + "word": "create", + "start": 231.74, + "end": 231.9 + }, + { + "word": "a", + "start": 231.9, + "end": 232.12 + }, + { + "word": "virtual", + "start": 232.12, + "end": 232.4 + }, + { + "word": "disk.", + "start": 232.4, + "end": 232.74 + }, + { + "word": "You", + "start": 232.82, + "end": 233.0 + }, + { + "word": "just", + "start": 233.0, + "end": 233.16 + }, + { + "word": "like", + "start": 233.16, + "end": 233.58 + }, + { + "word": "send", + "start": 233.58, + "end": 233.92 + }, + { + "word": "the", + "start": 233.92, + "end": 234.14 + }, + { + "word": "disk", + "start": 234.14, + "end": 234.34 + } + ] + }, + { + "start": 234.34, + "end": 238.64, + "text": "create API call with like a payload and like lo and behold, it like shows up on your dashboard.", + "words": [ + { + "word": "create", + "start": 234.34, + "end": 234.56 + }, + { + "word": "API", + "start": 234.56, + "end": 234.96 + }, + { + "word": "call", + "start": 234.96, + "end": 235.26 + }, + { + "word": "with", + "start": 235.26, + "end": 235.42 + }, + { + "word": "like", + "start": 235.42, + "end": 235.58 + }, + { + "word": "a", + "start": 235.58, + "end": 235.76 + }, + { + "word": "payload", + "start": 235.76, + "end": 236.06 + }, + { + "word": "and", + "start": 236.06, + "end": 236.56 + }, + { + "word": "like", + "start": 236.56, + "end": 236.82 + }, + { + "word": "lo", + "start": 236.82, + "end": 236.98 + }, + { + "word": "and", + "start": 236.98, + "end": 237.06 + }, + { + "word": "behold,", + "start": 237.06, + "end": 237.32 + }, + { + "word": "it", + "start": 237.36, + "end": 237.5 + }, + { + "word": "like", + "start": 237.5, + "end": 237.66 + }, + { + "word": "shows", + "start": 237.66, + "end": 237.86 + }, + { + "word": "up", + "start": 237.86, + "end": 238.02 + }, + { + "word": "on", + "start": 238.02, + "end": 238.1 + }, + { + "word": "your", + "start": 238.1, + "end": 238.24 + }, + { + "word": "dashboard.", + "start": 238.24, + "end": 238.64 + } + ] + }, + { + "start": 239.8, + "end": 244.8, + "text": "And I think like Oxide is really special in that they really treat their API like it's", + "words": [ + { + "word": "And", + "start": 239.8, + "end": 240.32 + }, + { + "word": "I", + "start": 240.32, + "end": 240.46 + }, + { + "word": "think", + "start": 240.46, + "end": 240.6 + }, + { + "word": "like", + "start": 240.6, + "end": 240.8 + }, + { + "word": "Oxide", + "start": 240.8, + "end": 241.02 + }, + { + "word": "is", + "start": 241.02, + "end": 241.16 + }, + { + "word": "really", + "start": 241.16, + "end": 241.38 + }, + { + "word": "special", + "start": 241.38, + "end": 241.86 + }, + { + "word": "in", + "start": 241.86, + "end": 242.14 + }, + { + "word": "that", + "start": 242.14, + "end": 242.24 + }, + { + "word": "they", + "start": 242.24, + "end": 242.5 + }, + { + "word": "really", + "start": 242.5, + "end": 242.96 + }, + { + "word": "treat", + "start": 242.96, + "end": 243.24 + }, + { + "word": "their", + "start": 243.24, + "end": 243.5 + }, + { + "word": "API", + "start": 243.5, + "end": 244.02 + }, + { + "word": "like", + "start": 244.02, + "end": 244.6 + }, + { + "word": "it's", + "start": 244.6, + "end": 244.86 + } + ] + }, + { + "start": 244.86, + "end": 249.58, + "text": "a like first class product interface. Like they think a lot about the quality of the", + "words": [ + { + "word": "a", + "start": 244.86, + "end": 245.44 + }, + { + "word": "like", + "start": 245.44, + "end": 245.76 + }, + { + "word": "first", + "start": 245.76, + "end": 246.08 + }, + { + "word": "class", + "start": 246.08, + "end": 246.44 + }, + { + "word": "product", + "start": 246.44, + "end": 247.04 + }, + { + "word": "interface.", + "start": 247.04, + "end": 247.6 + }, + { + "word": "Like", + "start": 247.62, + "end": 247.88 + }, + { + "word": "they", + "start": 247.88, + "end": 248.04 + }, + { + "word": "think", + "start": 248.04, + "end": 248.2 + }, + { + "word": "a", + "start": 248.2, + "end": 248.42 + }, + { + "word": "lot", + "start": 248.42, + "end": 248.58 + }, + { + "word": "about", + "start": 248.58, + "end": 248.76 + }, + { + "word": "the", + "start": 248.76, + "end": 248.98 + }, + { + "word": "quality", + "start": 248.98, + "end": 249.26 + }, + { + "word": "of", + "start": 249.26, + "end": 249.44 + }, + { + "word": "the", + "start": 249.44, + "end": 249.58 + } + ] + }, + { + "start": 249.58, + "end": 255.26, + "text": "API because everything else is like downstream of that. The API is bad. Any SDKs are bad", + "words": [ + { + "word": "API", + "start": 249.58, + "end": 249.88 + }, + { + "word": "because", + "start": 249.88, + "end": 250.54 + }, + { + "word": "everything", + "start": 250.54, + "end": 251.16 + }, + { + "word": "else", + "start": 251.16, + "end": 251.52 + }, + { + "word": "is", + "start": 251.52, + "end": 251.72 + }, + { + "word": "like", + "start": 251.72, + "end": 251.94 + }, + { + "word": "downstream", + "start": 251.94, + "end": 252.28 + }, + { + "word": "of", + "start": 252.28, + "end": 252.58 + }, + { + "word": "that.", + "start": 252.58, + "end": 252.84 + }, + { + "word": "The", + "start": 253.06, + "end": 253.28 + }, + { + "word": "API", + "start": 253.28, + "end": 253.52 + }, + { + "word": "is", + "start": 253.52, + "end": 253.74 + }, + { + "word": "bad.", + "start": 253.74, + "end": 254.06 + }, + { + "word": "Any", + "start": 254.14, + "end": 254.44 + }, + { + "word": "SDKs", + "start": 254.44, + "end": 254.88 + }, + { + "word": "are", + "start": 254.88, + "end": 255.04 + }, + { + "word": "bad", + "start": 255.04, + "end": 255.26 + } + ] + }, + { + "start": 255.26, + "end": 259.8, + "text": "because they generate everything from the API and they take this like very seriously.", + "words": [ + { + "word": "because", + "start": 255.26, + "end": 255.5 + }, + { + "word": "they", + "start": 255.5, + "end": 255.76 + }, + { + "word": "generate", + "start": 255.76, + "end": 256.06 + }, + { + "word": "everything", + "start": 256.06, + "end": 256.5 + }, + { + "word": "from", + "start": 256.5, + "end": 256.76 + }, + { + "word": "the", + "start": 256.76, + "end": 257.0 + }, + { + "word": "API", + "start": 257.0, + "end": 257.38 + }, + { + "word": "and", + "start": 257.38, + "end": 258.02 + }, + { + "word": "they", + "start": 258.02, + "end": 258.18 + }, + { + "word": "take", + "start": 258.18, + "end": 258.28 + }, + { + "word": "this", + "start": 258.28, + "end": 258.5 + }, + { + "word": "like", + "start": 258.5, + "end": 258.82 + }, + { + "word": "very", + "start": 258.82, + "end": 259.24 + }, + { + "word": "seriously.", + "start": 259.24, + "end": 259.8 + } + ] + }, + { + "start": 260.64, + "end": 265.04, + "text": "So I've been architecture diagram here. I know this is like all way too small. I used", + "words": [ + { + "word": "So", + "start": 260.64, + "end": 261.1 + }, + { + "word": "I've", + "start": 261.1, + "end": 261.26 + }, + { + "word": "been", + "start": 261.26, + "end": 261.34 + }, + { + "word": "architecture", + "start": 261.34, + "end": 261.74 + }, + { + "word": "diagram", + "start": 261.74, + "end": 262.04 + }, + { + "word": "here.", + "start": 262.04, + "end": 262.36 + }, + { + "word": "I", + "start": 262.36, + "end": 262.56 + }, + { + "word": "know", + "start": 262.56, + "end": 262.68 + }, + { + "word": "this", + "start": 262.68, + "end": 262.86 + }, + { + "word": "is", + "start": 262.86, + "end": 263.0 + }, + { + "word": "like", + "start": 263.0, + "end": 263.12 + }, + { + "word": "all", + "start": 263.12, + "end": 263.38 + }, + { + "word": "way", + "start": 263.38, + "end": 263.52 + }, + { + "word": "too", + "start": 263.52, + "end": 263.78 + }, + { + "word": "small.", + "start": 263.78, + "end": 264.12 + }, + { + "word": "I", + "start": 264.24, + "end": 264.7 + }, + { + "word": "used", + "start": 264.7, + "end": 265.04 + } + ] + }, + { + "start": 265.04, + "end": 269.1, + "text": "a deep wiki to get this, which is like a fantastic tool by the dev and team to like generate", + "words": [ + { + "word": "a", + "start": 265.04, + "end": 265.38 + }, + { + "word": "deep", + "start": 265.38, + "end": 265.5 + }, + { + "word": "wiki", + "start": 265.5, + "end": 265.7 + }, + { + "word": "to", + "start": 265.7, + "end": 265.92 + }, + { + "word": "get", + "start": 265.92, + "end": 266.02 + }, + { + "word": "this,", + "start": 266.02, + "end": 266.32 + }, + { + "word": "which", + "start": 266.34, + "end": 266.48 + }, + { + "word": "is", + "start": 266.48, + "end": 266.6 + }, + { + "word": "like", + "start": 266.6, + "end": 266.72 + }, + { + "word": "a", + "start": 266.72, + "end": 266.88 + }, + { + "word": "fantastic", + "start": 266.88, + "end": 267.18 + }, + { + "word": "tool", + "start": 267.18, + "end": 267.38 + }, + { + "word": "by", + "start": 267.38, + "end": 267.54 + }, + { + "word": "the", + "start": 267.54, + "end": 267.68 + }, + { + "word": "dev", + "start": 267.68, + "end": 267.76 + }, + { + "word": "and", + "start": 267.76, + "end": 267.94 + }, + { + "word": "team", + "start": 267.94, + "end": 268.14 + }, + { + "word": "to", + "start": 268.14, + "end": 268.34 + }, + { + "word": "like", + "start": 268.34, + "end": 268.6 + }, + { + "word": "generate", + "start": 268.6, + "end": 269.1 + } + ] + }, + { + "start": 270.16, + "end": 276.46, + "text": "documentation for repos. And I might be able to zoom in on this. I can't zoom in on it.", + "words": [ + { + "word": "documentation", + "start": 270.16, + "end": 270.56 + }, + { + "word": "for", + "start": 270.56, + "end": 270.96 + }, + { + "word": "repos.", + "start": 270.96, + "end": 272.02 + }, + { + "word": "And", + "start": 273.04, + "end": 273.44 + }, + { + "word": "I", + "start": 273.44, + "end": 273.58 + }, + { + "word": "might", + "start": 273.58, + "end": 273.82 + }, + { + "word": "be", + "start": 273.82, + "end": 274.02 + }, + { + "word": "able", + "start": 274.02, + "end": 274.2 + }, + { + "word": "to", + "start": 274.2, + "end": 274.36 + }, + { + "word": "zoom", + "start": 274.36, + "end": 274.5 + }, + { + "word": "in", + "start": 274.5, + "end": 274.64 + }, + { + "word": "on", + "start": 274.64, + "end": 274.84 + }, + { + "word": "this.", + "start": 274.84, + "end": 275.16 + }, + { + "word": "I", + "start": 275.6, + "end": 275.78 + }, + { + "word": "can't", + "start": 275.78, + "end": 276.04 + }, + { + "word": "zoom", + "start": 276.04, + "end": 276.14 + }, + { + "word": "in", + "start": 276.14, + "end": 276.26 + }, + { + "word": "on", + "start": 276.26, + "end": 276.34 + }, + { + "word": "it.", + "start": 276.34, + "end": 276.46 + } + ] + }, + { + "start": 276.46, + "end": 280.86, + "text": "It's fine. There's like a whole lot of stuff here that I'm not going to talk about. The", + "words": [ + { + "word": "It's", + "start": 276.46, + "end": 276.56 + }, + { + "word": "fine.", + "start": 276.56, + "end": 276.76 + }, + { + "word": "There's", + "start": 277.72, + "end": 278.12 + }, + { + "word": "like", + "start": 278.12, + "end": 278.34 + }, + { + "word": "a", + "start": 278.34, + "end": 278.34 + }, + { + "word": "whole", + "start": 278.34, + "end": 278.48 + }, + { + "word": "lot", + "start": 278.48, + "end": 278.58 + }, + { + "word": "of", + "start": 278.58, + "end": 278.68 + }, + { + "word": "stuff", + "start": 278.68, + "end": 278.78 + }, + { + "word": "here", + "start": 278.78, + "end": 279.12 + }, + { + "word": "that", + "start": 279.12, + "end": 279.66 + }, + { + "word": "I'm", + "start": 279.66, + "end": 279.96 + }, + { + "word": "not", + "start": 279.96, + "end": 280.1 + }, + { + "word": "going", + "start": 280.1, + "end": 280.2 + }, + { + "word": "to", + "start": 280.2, + "end": 280.3 + }, + { + "word": "talk", + "start": 280.3, + "end": 280.42 + }, + { + "word": "about.", + "start": 280.42, + "end": 280.66 + }, + { + "word": "The", + "start": 280.74, + "end": 280.86 + } + ] + }, + { + "start": 280.86, + "end": 285.34, + "text": "only thing that I'm really focused on is like this top piece here. So Oxide's control plane,", + "words": [ + { + "word": "only", + "start": 280.86, + "end": 281.06 + }, + { + "word": "thing", + "start": 281.06, + "end": 281.16 + }, + { + "word": "that", + "start": 281.16, + "end": 281.3 + }, + { + "word": "I'm", + "start": 281.3, + "end": 281.42 + }, + { + "word": "really", + "start": 281.42, + "end": 281.6 + }, + { + "word": "focused", + "start": 281.6, + "end": 281.92 + }, + { + "word": "on", + "start": 281.92, + "end": 282.26 + }, + { + "word": "is", + "start": 282.26, + "end": 282.48 + }, + { + "word": "like", + "start": 282.48, + "end": 282.66 + }, + { + "word": "this", + "start": 282.66, + "end": 282.8 + }, + { + "word": "top", + "start": 282.8, + "end": 283.04 + }, + { + "word": "piece", + "start": 283.04, + "end": 283.24 + }, + { + "word": "here.", + "start": 283.24, + "end": 283.56 + }, + { + "word": "So", + "start": 284.12, + "end": 284.24 + }, + { + "word": "Oxide's", + "start": 284.24, + "end": 284.88 + }, + { + "word": "control", + "start": 284.88, + "end": 285.06 + }, + { + "word": "plane,", + "start": 285.06, + "end": 285.34 + } + ] + }, + { + "start": 285.4, + "end": 289.6, + "text": "the thing that like organizes everything in the rack, like where VMs are deployed and", + "words": [ + { + "word": "the", + "start": 285.4, + "end": 285.58 + }, + { + "word": "thing", + "start": 285.58, + "end": 285.7 + }, + { + "word": "that", + "start": 285.7, + "end": 285.9 + }, + { + "word": "like", + "start": 285.9, + "end": 286.16 + }, + { + "word": "organizes", + "start": 286.16, + "end": 286.66 + }, + { + "word": "everything", + "start": 286.66, + "end": 287.12 + }, + { + "word": "in", + "start": 287.12, + "end": 287.3 + }, + { + "word": "the", + "start": 287.3, + "end": 287.48 + }, + { + "word": "rack,", + "start": 287.48, + "end": 287.74 + }, + { + "word": "like", + "start": 287.92, + "end": 288.14 + }, + { + "word": "where", + "start": 288.14, + "end": 288.38 + }, + { + "word": "VMs", + "start": 288.38, + "end": 288.78 + }, + { + "word": "are", + "start": 288.78, + "end": 288.9 + }, + { + "word": "deployed", + "start": 288.9, + "end": 289.4 + }, + { + "word": "and", + "start": 289.4, + "end": 289.6 + } + ] + }, + { + "start": 289.6, + "end": 294.42, + "text": "how storage is managed and like what the hypervisor does and everything. It's all controlled by", + "words": [ + { + "word": "how", + "start": 289.6, + "end": 289.86 + }, + { + "word": "storage", + "start": 289.86, + "end": 290.12 + }, + { + "word": "is", + "start": 290.12, + "end": 290.38 + }, + { + "word": "managed", + "start": 290.38, + "end": 290.8 + }, + { + "word": "and", + "start": 290.8, + "end": 290.98 + }, + { + "word": "like", + "start": 290.98, + "end": 291.08 + }, + { + "word": "what", + "start": 291.08, + "end": 291.2 + }, + { + "word": "the", + "start": 291.2, + "end": 291.32 + }, + { + "word": "hypervisor", + "start": 291.32, + "end": 291.7 + }, + { + "word": "does", + "start": 291.7, + "end": 291.98 + }, + { + "word": "and", + "start": 291.98, + "end": 292.18 + }, + { + "word": "everything.", + "start": 292.18, + "end": 292.56 + }, + { + "word": "It's", + "start": 292.9, + "end": 293.04 + }, + { + "word": "all", + "start": 293.04, + "end": 293.28 + }, + { + "word": "controlled", + "start": 293.28, + "end": 293.84 + }, + { + "word": "by", + "start": 293.84, + "end": 294.42 + } + ] + }, + { + "start": 294.42, + "end": 300.58, + "text": "the external API. And all the clients that come into the external API are generated", + "words": [ + { + "word": "the", + "start": 294.42, + "end": 294.64 + }, + { + "word": "external", + "start": 294.64, + "end": 294.92 + }, + { + "word": "API.", + "start": 294.92, + "end": 295.38 + }, + { + "word": "And", + "start": 297.12, + "end": 297.6 + }, + { + "word": "all", + "start": 297.6, + "end": 298.08 + }, + { + "word": "the", + "start": 298.08, + "end": 298.28 + }, + { + "word": "clients", + "start": 298.28, + "end": 298.52 + }, + { + "word": "that", + "start": 298.52, + "end": 298.72 + }, + { + "word": "come", + "start": 298.72, + "end": 298.84 + }, + { + "word": "into", + "start": 298.84, + "end": 299.0 + }, + { + "word": "the", + "start": 299.0, + "end": 299.2 + }, + { + "word": "external", + "start": 299.2, + "end": 299.52 + }, + { + "word": "API", + "start": 299.52, + "end": 299.92 + }, + { + "word": "are", + "start": 299.92, + "end": 300.18 + }, + { + "word": "generated", + "start": 300.18, + "end": 300.58 + } + ] + }, + { + "start": 300.58, + "end": 305.6, + "text": "downstream of that. So getting that interface right is critically important. And it's also", + "words": [ + { + "word": "downstream", + "start": 300.58, + "end": 300.96 + }, + { + "word": "of", + "start": 300.96, + "end": 301.18 + }, + { + "word": "that.", + "start": 301.18, + "end": 301.46 + }, + { + "word": "So", + "start": 302.44, + "end": 302.48 + }, + { + "word": "getting", + "start": 302.48, + "end": 302.68 + }, + { + "word": "that", + "start": 302.68, + "end": 302.92 + }, + { + "word": "interface", + "start": 302.92, + "end": 303.24 + }, + { + "word": "right", + "start": 303.24, + "end": 303.48 + }, + { + "word": "is", + "start": 303.48, + "end": 303.8 + }, + { + "word": "critically", + "start": 303.8, + "end": 304.26 + }, + { + "word": "important.", + "start": 304.26, + "end": 304.84 + }, + { + "word": "And", + "start": 304.92, + "end": 305.24 + }, + { + "word": "it's", + "start": 305.24, + "end": 305.42 + }, + { + "word": "also", + "start": 305.42, + "end": 305.6 + } + ] + }, + { + "start": 305.6, + "end": 310.32, + "text": "critically important that it stays up to date because imagine you were trying to use EC2", + "words": [ + { + "word": "critically", + "start": 305.6, + "end": 305.88 + }, + { + "word": "important", + "start": 305.88, + "end": 306.16 + }, + { + "word": "that", + "start": 306.16, + "end": 306.3 + }, + { + "word": "it", + "start": 306.3, + "end": 306.54 + }, + { + "word": "stays", + "start": 306.54, + "end": 306.7 + }, + { + "word": "up", + "start": 306.7, + "end": 306.9 + }, + { + "word": "to", + "start": 306.9, + "end": 307.06 + }, + { + "word": "date", + "start": 307.06, + "end": 307.36 + }, + { + "word": "because", + "start": 307.36, + "end": 307.88 + }, + { + "word": "imagine", + "start": 307.88, + "end": 308.62 + }, + { + "word": "you", + "start": 308.62, + "end": 308.9 + }, + { + "word": "were", + "start": 308.9, + "end": 309.06 + }, + { + "word": "trying", + "start": 309.06, + "end": 309.18 + }, + { + "word": "to", + "start": 309.18, + "end": 309.36 + }, + { + "word": "use", + "start": 309.36, + "end": 309.7 + }, + { + "word": "EC2", + "start": 309.7, + "end": 310.32 + } + ] + }, + { + "start": 310.32, + "end": 314.88, + "text": "at AWS and like you just didn't have the capability to do something that you needed to do. Terrible", + "words": [ + { + "word": "at", + "start": 310.32, + "end": 310.52 + }, + { + "word": "AWS", + "start": 310.52, + "end": 310.84 + }, + { + "word": "and", + "start": 310.84, + "end": 311.2 + }, + { + "word": "like", + "start": 311.2, + "end": 311.6 + }, + { + "word": "you", + "start": 311.6, + "end": 311.72 + }, + { + "word": "just", + "start": 311.72, + "end": 312.06 + }, + { + "word": "didn't", + "start": 312.06, + "end": 312.22 + }, + { + "word": "have", + "start": 312.22, + "end": 312.44 + }, + { + "word": "the", + "start": 312.44, + "end": 312.58 + }, + { + "word": "capability", + "start": 312.58, + "end": 313.0 + }, + { + "word": "to", + "start": 313.0, + "end": 313.22 + }, + { + "word": "do", + "start": 313.22, + "end": 313.36 + }, + { + "word": "something", + "start": 313.36, + "end": 313.6 + }, + { + "word": "that", + "start": 313.6, + "end": 313.76 + }, + { + "word": "you", + "start": 313.76, + "end": 313.86 + }, + { + "word": "needed", + "start": 313.86, + "end": 313.98 + }, + { + "word": "to", + "start": 313.98, + "end": 314.18 + }, + { + "word": "do.", + "start": 314.18, + "end": 314.36 + }, + { + "word": "Terrible", + "start": 314.56, + "end": 314.88 + } + ] + }, + { + "start": 314.88, + "end": 319.36, + "text": "experience. But if you're trying to maintain a lot of SDKs across a lot of different languages,", + "words": [ + { + "word": "experience.", + "start": 314.88, + "end": 315.38 + }, + { + "word": "But", + "start": 315.92, + "end": 316.12 + }, + { + "word": "if", + "start": 316.12, + "end": 316.24 + }, + { + "word": "you're", + "start": 316.24, + "end": 316.42 + }, + { + "word": "trying", + "start": 316.42, + "end": 316.56 + }, + { + "word": "to", + "start": 316.56, + "end": 316.8 + }, + { + "word": "maintain", + "start": 316.8, + "end": 317.08 + }, + { + "word": "a", + "start": 317.08, + "end": 317.32 + }, + { + "word": "lot", + "start": 317.32, + "end": 317.62 + }, + { + "word": "of", + "start": 317.62, + "end": 317.86 + }, + { + "word": "SDKs", + "start": 317.86, + "end": 318.32 + }, + { + "word": "across", + "start": 318.32, + "end": 318.52 + }, + { + "word": "a", + "start": 318.52, + "end": 318.6 + }, + { + "word": "lot", + "start": 318.6, + "end": 318.72 + }, + { + "word": "of", + "start": 318.72, + "end": 318.86 + }, + { + "word": "different", + "start": 318.86, + "end": 319.04 + }, + { + "word": "languages,", + "start": 319.04, + "end": 319.36 + } + ] + }, + { + "start": 319.36, + "end": 325.54, + "text": "it'd be really easy for those to lag behind. So Oxide went full into a co-gen first approach", + "words": [ + { + "word": "it'd", + "start": 319.36, + "end": 319.62 + }, + { + "word": "be", + "start": 319.62, + "end": 319.78 + }, + { + "word": "really", + "start": 319.78, + "end": 320.12 + }, + { + "word": "easy", + "start": 320.12, + "end": 320.36 + }, + { + "word": "for", + "start": 320.36, + "end": 320.5 + }, + { + "word": "those", + "start": 320.5, + "end": 320.7 + }, + { + "word": "to", + "start": 320.7, + "end": 320.92 + }, + { + "word": "lag", + "start": 320.92, + "end": 321.02 + }, + { + "word": "behind.", + "start": 321.02, + "end": 321.5 + }, + { + "word": "So", + "start": 322.08, + "end": 322.26 + }, + { + "word": "Oxide", + "start": 322.26, + "end": 322.48 + }, + { + "word": "went", + "start": 322.48, + "end": 322.8 + }, + { + "word": "full", + "start": 322.8, + "end": 323.24 + }, + { + "word": "into", + "start": 323.24, + "end": 323.96 + }, + { + "word": "a", + "start": 323.96, + "end": 324.4 + }, + { + "word": "co", + "start": 324.4, + "end": 324.56 + }, + { + "word": "-gen", + "start": 324.56, + "end": 324.74 + }, + { + "word": "first", + "start": 324.74, + "end": 325.08 + }, + { + "word": "approach", + "start": 325.08, + "end": 325.54 + } + ] + }, + { + "start": 325.54, + "end": 332.24, + "text": "where they wanted the API schemas to be generated from the actual implementation. So it's like", + "words": [ + { + "word": "where", + "start": 325.54, + "end": 326.28 + }, + { + "word": "they", + "start": 326.28, + "end": 327.28 + }, + { + "word": "wanted", + "start": 327.28, + "end": 327.66 + }, + { + "word": "the", + "start": 327.66, + "end": 328.7 + }, + { + "word": "API", + "start": 328.7, + "end": 329.08 + }, + { + "word": "schemas", + "start": 329.08, + "end": 329.6 + }, + { + "word": "to", + "start": 329.6, + "end": 329.78 + }, + { + "word": "be", + "start": 329.78, + "end": 330.02 + }, + { + "word": "generated", + "start": 330.02, + "end": 330.4 + }, + { + "word": "from", + "start": 330.4, + "end": 330.58 + }, + { + "word": "the", + "start": 330.58, + "end": 330.78 + }, + { + "word": "actual", + "start": 330.78, + "end": 331.0 + }, + { + "word": "implementation.", + "start": 331.0, + "end": 331.52 + }, + { + "word": "So", + "start": 331.74, + "end": 331.86 + }, + { + "word": "it's", + "start": 331.86, + "end": 332.04 + }, + { + "word": "like", + "start": 332.04, + "end": 332.24 + } + ] + }, + { + "start": 332.24, + "end": 339.34, + "text": "always up to date all the way downstream to the SDKs that are generated. I have some repositories", + "words": [ + { + "word": "always", + "start": 332.24, + "end": 332.68 + }, + { + "word": "up", + "start": 332.68, + "end": 332.88 + }, + { + "word": "to", + "start": 332.88, + "end": 333.04 + }, + { + "word": "date", + "start": 333.04, + "end": 333.22 + }, + { + "word": "all", + "start": 333.22, + "end": 333.46 + }, + { + "word": "the", + "start": 333.46, + "end": 333.56 + }, + { + "word": "way", + "start": 333.56, + "end": 333.7 + }, + { + "word": "downstream", + "start": 333.7, + "end": 334.1 + }, + { + "word": "to", + "start": 334.1, + "end": 334.32 + }, + { + "word": "the", + "start": 334.32, + "end": 334.5 + }, + { + "word": "SDKs", + "start": 334.5, + "end": 334.92 + }, + { + "word": "that", + "start": 334.92, + "end": 334.96 + }, + { + "word": "are", + "start": 334.96, + "end": 335.1 + }, + { + "word": "generated.", + "start": 335.1, + "end": 335.52 + }, + { + "word": "I", + "start": 337.44, + "end": 337.92 + }, + { + "word": "have", + "start": 337.92, + "end": 338.2 + }, + { + "word": "some", + "start": 338.2, + "end": 338.78 + }, + { + "word": "repositories", + "start": 338.78, + "end": 339.34 + } + ] + }, + { + "start": 339.34, + "end": 343.6, + "text": "here that you can take pictures of if you're interested. Oxide is like the vast majority", + "words": [ + { + "word": "here", + "start": 339.34, + "end": 339.6 + }, + { + "word": "that", + "start": 339.6, + "end": 339.74 + }, + { + "word": "you", + "start": 339.74, + "end": 339.86 + }, + { + "word": "can", + "start": 339.86, + "end": 340.02 + }, + { + "word": "take", + "start": 340.02, + "end": 340.14 + }, + { + "word": "pictures", + "start": 340.14, + "end": 340.4 + }, + { + "word": "of", + "start": 340.4, + "end": 340.58 + }, + { + "word": "if", + "start": 340.58, + "end": 340.7 + }, + { + "word": "you're", + "start": 340.7, + "end": 340.86 + }, + { + "word": "interested.", + "start": 340.86, + "end": 341.3 + }, + { + "word": "Oxide", + "start": 341.6, + "end": 341.94 + }, + { + "word": "is", + "start": 341.94, + "end": 342.24 + }, + { + "word": "like", + "start": 342.24, + "end": 342.88 + }, + { + "word": "the", + "start": 342.88, + "end": 343.16 + }, + { + "word": "vast", + "start": 343.16, + "end": 343.3 + }, + { + "word": "majority", + "start": 343.3, + "end": 343.6 + } + ] + }, + { + "start": 343.6, + "end": 349.26, + "text": "of it is open source, which is like very rare for a hardware company. So the top repo Omicron", + "words": [ + { + "word": "of", + "start": 343.6, + "end": 343.74 + }, + { + "word": "it", + "start": 343.74, + "end": 343.8 + }, + { + "word": "is", + "start": 343.8, + "end": 343.96 + }, + { + "word": "open", + "start": 343.96, + "end": 344.12 + }, + { + "word": "source,", + "start": 344.12, + "end": 344.52 + }, + { + "word": "which", + "start": 344.54, + "end": 344.7 + }, + { + "word": "is", + "start": 344.7, + "end": 344.9 + }, + { + "word": "like", + "start": 344.9, + "end": 345.22 + }, + { + "word": "very", + "start": 345.22, + "end": 345.48 + }, + { + "word": "rare", + "start": 345.48, + "end": 345.74 + }, + { + "word": "for", + "start": 345.74, + "end": 345.96 + }, + { + "word": "a", + "start": 345.96, + "end": 346.06 + }, + { + "word": "hardware", + "start": 346.06, + "end": 346.28 + }, + { + "word": "company.", + "start": 346.28, + "end": 346.7 + }, + { + "word": "So", + "start": 347.16, + "end": 347.64 + }, + { + "word": "the", + "start": 347.64, + "end": 348.16 + }, + { + "word": "top", + "start": 348.16, + "end": 348.38 + }, + { + "word": "repo", + "start": 348.38, + "end": 348.74 + }, + { + "word": "Omicron", + "start": 348.74, + "end": 349.26 + } + ] + }, + { + "start": 349.26, + "end": 353.26, + "text": "is their entire control plane. So everything that I'm talking about today, you can actually", + "words": [ + { + "word": "is", + "start": 349.26, + "end": 349.58 + }, + { + "word": "their", + "start": 349.58, + "end": 349.94 + }, + { + "word": "entire", + "start": 349.94, + "end": 350.46 + }, + { + "word": "control", + "start": 350.46, + "end": 350.82 + }, + { + "word": "plane.", + "start": 350.82, + "end": 351.06 + }, + { + "word": "So", + "start": 351.38, + "end": 351.44 + }, + { + "word": "everything", + "start": 351.44, + "end": 351.76 + }, + { + "word": "that", + "start": 351.76, + "end": 351.88 + }, + { + "word": "I'm", + "start": 351.88, + "end": 351.96 + }, + { + "word": "talking", + "start": 351.96, + "end": 352.2 + }, + { + "word": "about", + "start": 352.2, + "end": 352.38 + }, + { + "word": "today,", + "start": 352.38, + "end": 352.68 + }, + { + "word": "you", + "start": 352.7, + "end": 352.8 + }, + { + "word": "can", + "start": 352.8, + "end": 353.02 + }, + { + "word": "actually", + "start": 353.02, + "end": 353.26 + } + ] + }, + { + "start": 353.26, + "end": 359.9, + "text": "see the source of it. Dropshot is their HTTP server. That's the thing that they use to", + "words": [ + { + "word": "see", + "start": 353.26, + "end": 353.5 + }, + { + "word": "the", + "start": 353.5, + "end": 353.7 + }, + { + "word": "source", + "start": 353.7, + "end": 353.88 + }, + { + "word": "of", + "start": 353.88, + "end": 354.04 + }, + { + "word": "it.", + "start": 354.04, + "end": 355.14 + }, + { + "word": "Dropshot", + "start": 356.12, + "end": 356.52 + }, + { + "word": "is", + "start": 356.52, + "end": 356.82 + }, + { + "word": "their", + "start": 356.82, + "end": 357.08 + }, + { + "word": "HTTP", + "start": 357.08, + "end": 357.4 + }, + { + "word": "server.", + "start": 357.4, + "end": 357.84 + }, + { + "word": "That's", + "start": 358.02, + "end": 358.34 + }, + { + "word": "the", + "start": 358.34, + "end": 358.54 + }, + { + "word": "thing", + "start": 358.54, + "end": 358.94 + }, + { + "word": "that", + "start": 358.94, + "end": 359.34 + }, + { + "word": "they", + "start": 359.34, + "end": 359.56 + }, + { + "word": "use", + "start": 359.56, + "end": 359.7 + }, + { + "word": "to", + "start": 359.7, + "end": 359.9 + } + ] + }, + { + "start": 359.9, + "end": 365.52, + "text": "implement the REST API endpoints and actually generates open API specs from the implementation.", + "words": [ + { + "word": "implement", + "start": 359.9, + "end": 360.06 + }, + { + "word": "the", + "start": 360.06, + "end": 360.22 + }, + { + "word": "REST", + "start": 360.22, + "end": 360.4 + }, + { + "word": "API", + "start": 360.4, + "end": 361.08 + }, + { + "word": "endpoints", + "start": 361.08, + "end": 361.58 + }, + { + "word": "and", + "start": 361.58, + "end": 362.12 + }, + { + "word": "actually", + "start": 362.12, + "end": 362.44 + }, + { + "word": "generates", + "start": 362.44, + "end": 362.8 + }, + { + "word": "open", + "start": 362.8, + "end": 363.08 + }, + { + "word": "API", + "start": 363.08, + "end": 363.38 + }, + { + "word": "specs", + "start": 363.38, + "end": 363.74 + }, + { + "word": "from", + "start": 363.74, + "end": 364.64 + }, + { + "word": "the", + "start": 364.64, + "end": 365.02 + }, + { + "word": "implementation.", + "start": 365.02, + "end": 365.52 + } + ] + }, + { + "start": 366.46, + "end": 371.6, + "text": "Progenitor is their co-gen library. So they use Progenitor to take an open API spec and", + "words": [ + { + "word": "Progenitor", + "start": 366.46, + "end": 366.9 + }, + { + "word": "is", + "start": 366.9, + "end": 367.14 + }, + { + "word": "their", + "start": 367.14, + "end": 367.3 + }, + { + "word": "co", + "start": 367.3, + "end": 367.52 + }, + { + "word": "-gen", + "start": 367.52, + "end": 367.64 + }, + { + "word": "library.", + "start": 367.64, + "end": 368.14 + }, + { + "word": "So", + "start": 368.22, + "end": 368.46 + }, + { + "word": "they", + "start": 368.46, + "end": 368.94 + }, + { + "word": "use", + "start": 368.94, + "end": 369.22 + }, + { + "word": "Progenitor", + "start": 369.22, + "end": 369.72 + }, + { + "word": "to", + "start": 369.72, + "end": 370.04 + }, + { + "word": "take", + "start": 370.04, + "end": 370.18 + }, + { + "word": "an", + "start": 370.18, + "end": 370.38 + }, + { + "word": "open", + "start": 370.38, + "end": 370.58 + }, + { + "word": "API", + "start": 370.58, + "end": 370.86 + }, + { + "word": "spec", + "start": 370.86, + "end": 371.18 + }, + { + "word": "and", + "start": 371.18, + "end": 371.6 + } + ] + }, + { + "start": 371.6, + "end": 377.06, + "text": "generate a REST SDK from it. And then they have Oxide RS repo, which is like where their", + "words": [ + { + "word": "generate", + "start": 371.6, + "end": 371.98 + }, + { + "word": "a", + "start": 371.98, + "end": 372.22 + }, + { + "word": "REST", + "start": 372.22, + "end": 372.44 + }, + { + "word": "SDK", + "start": 372.44, + "end": 372.8 + }, + { + "word": "from", + "start": 372.8, + "end": 373.04 + }, + { + "word": "it.", + "start": 373.04, + "end": 373.86 + }, + { + "word": "And", + "start": 373.92, + "end": 374.44 + }, + { + "word": "then", + "start": 374.44, + "end": 374.54 + }, + { + "word": "they", + "start": 374.54, + "end": 374.74 + }, + { + "word": "have", + "start": 374.74, + "end": 375.1 + }, + { + "word": "Oxide", + "start": 375.1, + "end": 375.46 + }, + { + "word": "RS", + "start": 375.46, + "end": 375.72 + }, + { + "word": "repo,", + "start": 375.72, + "end": 376.12 + }, + { + "word": "which", + "start": 376.2, + "end": 376.32 + }, + { + "word": "is", + "start": 376.32, + "end": 376.5 + }, + { + "word": "like", + "start": 376.5, + "end": 376.68 + }, + { + "word": "where", + "start": 376.68, + "end": 376.88 + }, + { + "word": "their", + "start": 376.88, + "end": 377.06 + } + ] + }, + { + "start": 377.06, + "end": 382.42, + "text": "REST SDK and CLI are. And then an Oxide TS repo, which I worked on, which is where the", + "words": [ + { + "word": "REST", + "start": 377.06, + "end": 377.3 + }, + { + "word": "SDK", + "start": 377.3, + "end": 377.68 + }, + { + "word": "and", + "start": 377.68, + "end": 377.9 + }, + { + "word": "CLI", + "start": 377.9, + "end": 378.3 + }, + { + "word": "are.", + "start": 378.3, + "end": 378.56 + }, + { + "word": "And", + "start": 378.88, + "end": 378.98 + }, + { + "word": "then", + "start": 378.98, + "end": 379.42 + }, + { + "word": "an", + "start": 379.42, + "end": 379.58 + }, + { + "word": "Oxide", + "start": 379.58, + "end": 379.88 + }, + { + "word": "TS", + "start": 379.88, + "end": 380.14 + }, + { + "word": "repo,", + "start": 380.14, + "end": 380.48 + }, + { + "word": "which", + "start": 380.52, + "end": 380.62 + }, + { + "word": "I", + "start": 380.62, + "end": 380.8 + }, + { + "word": "worked", + "start": 380.8, + "end": 380.9 + }, + { + "word": "on,", + "start": 380.9, + "end": 381.48 + }, + { + "word": "which", + "start": 381.56, + "end": 382.02 + }, + { + "word": "is", + "start": 382.02, + "end": 382.18 + }, + { + "word": "where", + "start": 382.18, + "end": 382.28 + }, + { + "word": "the", + "start": 382.28, + "end": 382.42 + } + ] + }, + { + "start": 382.42, + "end": 390.32, + "text": "generated TypeScript SDK is. So earlier I showed a little demo of like, oh, like here's", + "words": [ + { + "word": "generated", + "start": 382.42, + "end": 382.9 + }, + { + "word": "TypeScript", + "start": 382.9, + "end": 383.28 + }, + { + "word": "SDK", + "start": 383.28, + "end": 383.64 + }, + { + "word": "is.", + "start": 383.64, + "end": 384.1 + }, + { + "word": "So", + "start": 386.48, + "end": 386.48 + }, + { + "word": "earlier", + "start": 386.48, + "end": 387.12 + }, + { + "word": "I", + "start": 387.12, + "end": 387.58 + }, + { + "word": "showed", + "start": 387.58, + "end": 387.84 + }, + { + "word": "a", + "start": 387.84, + "end": 388.1 + }, + { + "word": "little", + "start": 388.1, + "end": 388.28 + }, + { + "word": "demo", + "start": 388.28, + "end": 388.6 + }, + { + "word": "of", + "start": 388.6, + "end": 388.88 + }, + { + "word": "like,", + "start": 388.88, + "end": 389.18 + }, + { + "word": "oh,", + "start": 389.28, + "end": 389.48 + }, + { + "word": "like", + "start": 389.5, + "end": 389.94 + }, + { + "word": "here's", + "start": 389.94, + "end": 390.32 + } + ] + }, + { + "start": 390.32, + "end": 396.54, + "text": "what it looks like to create a disk. So this is the actual definition inside of Nexus of", + "words": [ + { + "word": "what", + "start": 390.32, + "end": 390.46 + }, + { + "word": "it", + "start": 390.46, + "end": 390.58 + }, + { + "word": "looks", + "start": 390.58, + "end": 390.7 + }, + { + "word": "like", + "start": 390.7, + "end": 390.86 + }, + { + "word": "to", + "start": 390.86, + "end": 391.12 + }, + { + "word": "create", + "start": 391.12, + "end": 391.36 + }, + { + "word": "a", + "start": 391.36, + "end": 391.92 + }, + { + "word": "disk.", + "start": 391.92, + "end": 392.2 + }, + { + "word": "So", + "start": 392.3, + "end": 392.72 + }, + { + "word": "this", + "start": 392.72, + "end": 393.1 + }, + { + "word": "is", + "start": 393.1, + "end": 393.28 + }, + { + "word": "the", + "start": 393.28, + "end": 393.52 + }, + { + "word": "actual", + "start": 393.52, + "end": 394.24 + }, + { + "word": "definition", + "start": 394.24, + "end": 395.04 + }, + { + "word": "inside", + "start": 395.04, + "end": 395.46 + }, + { + "word": "of", + "start": 395.46, + "end": 395.66 + }, + { + "word": "Nexus", + "start": 395.66, + "end": 396.04 + }, + { + "word": "of", + "start": 396.04, + "end": 396.54 + } + ] + }, + { + "start": 396.54, + "end": 402.7, + "text": "like the interface for disk creation. So async function disk create has a request context", + "words": [ + { + "word": "like", + "start": 396.54, + "end": 397.2 + }, + { + "word": "the", + "start": 397.2, + "end": 397.48 + }, + { + "word": "interface", + "start": 397.48, + "end": 397.98 + }, + { + "word": "for", + "start": 397.98, + "end": 398.24 + }, + { + "word": "disk", + "start": 398.24, + "end": 398.5 + }, + { + "word": "creation.", + "start": 398.5, + "end": 398.88 + }, + { + "word": "So", + "start": 399.92, + "end": 400.12 + }, + { + "word": "async", + "start": 400.12, + "end": 400.56 + }, + { + "word": "function", + "start": 400.56, + "end": 400.9 + }, + { + "word": "disk", + "start": 400.9, + "end": 401.18 + }, + { + "word": "create", + "start": 401.18, + "end": 401.42 + }, + { + "word": "has", + "start": 401.42, + "end": 401.86 + }, + { + "word": "a", + "start": 401.86, + "end": 402.08 + }, + { + "word": "request", + "start": 402.08, + "end": 402.26 + }, + { + "word": "context", + "start": 402.26, + "end": 402.7 + } + ] + }, + { + "start": 402.7, + "end": 408.32, + "text": "and query parameters and the disk parameters for whatever disk that you're creating. So", + "words": [ + { + "word": "and", + "start": 402.7, + "end": 403.04 + }, + { + "word": "query", + "start": 403.04, + "end": 403.04 + }, + { + "word": "parameters", + "start": 403.04, + "end": 403.54 + }, + { + "word": "and", + "start": 403.54, + "end": 404.06 + }, + { + "word": "the", + "start": 404.06, + "end": 404.28 + }, + { + "word": "disk", + "start": 404.28, + "end": 404.48 + }, + { + "word": "parameters", + "start": 404.48, + "end": 404.92 + }, + { + "word": "for", + "start": 404.92, + "end": 405.4 + }, + { + "word": "whatever", + "start": 405.4, + "end": 405.64 + }, + { + "word": "disk", + "start": 405.64, + "end": 405.86 + }, + { + "word": "that", + "start": 405.86, + "end": 405.96 + }, + { + "word": "you're", + "start": 405.96, + "end": 406.1 + }, + { + "word": "creating.", + "start": 406.1, + "end": 406.42 + }, + { + "word": "So", + "start": 407.94, + "end": 408.32 + } + ] + }, + { + "start": 408.32, + "end": 415.02, + "text": "this little piece down here is just like how you standard, how you define a Dropshot HTTP", + "words": [ + { + "word": "this", + "start": 408.32, + "end": 408.74 + }, + { + "word": "little", + "start": 408.74, + "end": 409.28 + }, + { + "word": "piece", + "start": 409.28, + "end": 409.52 + }, + { + "word": "down", + "start": 409.52, + "end": 409.78 + }, + { + "word": "here", + "start": 409.78, + "end": 410.0 + }, + { + "word": "is", + "start": 410.0, + "end": 410.14 + }, + { + "word": "just", + "start": 410.14, + "end": 410.36 + }, + { + "word": "like", + "start": 410.36, + "end": 410.82 + }, + { + "word": "how", + "start": 410.82, + "end": 411.14 + }, + { + "word": "you", + "start": 411.14, + "end": 411.34 + }, + { + "word": "standard,", + "start": 411.34, + "end": 411.82 + }, + { + "word": "how", + "start": 412.04, + "end": 412.2 + }, + { + "word": "you", + "start": 412.2, + "end": 412.56 + }, + { + "word": "define", + "start": 412.56, + "end": 413.12 + }, + { + "word": "a", + "start": 413.12, + "end": 413.56 + }, + { + "word": "Dropshot", + "start": 413.56, + "end": 414.22 + }, + { + "word": "HTTP", + "start": 414.22, + "end": 415.02 + } + ] + }, + { + "start": 415.02, + "end": 420.18, + "text": "endpoint. This is very typical if you've used any of the other REST-based HTTP frameworks.", + "words": [ + { + "word": "endpoint.", + "start": 415.02, + "end": 415.36 + }, + { + "word": "This", + "start": 415.42, + "end": 415.58 + }, + { + "word": "is", + "start": 415.58, + "end": 416.18 + }, + { + "word": "very", + "start": 416.18, + "end": 416.72 + }, + { + "word": "typical", + "start": 416.72, + "end": 417.22 + }, + { + "word": "if", + "start": 417.22, + "end": 417.52 + }, + { + "word": "you've", + "start": 417.52, + "end": 417.8 + }, + { + "word": "used", + "start": 417.8, + "end": 417.98 + }, + { + "word": "any", + "start": 417.98, + "end": 418.24 + }, + { + "word": "of", + "start": 418.24, + "end": 418.38 + }, + { + "word": "the", + "start": 418.38, + "end": 418.44 + }, + { + "word": "other", + "start": 418.44, + "end": 418.84 + }, + { + "word": "REST", + "start": 418.84, + "end": 419.04 + }, + { + "word": "-based", + "start": 419.04, + "end": 419.4 + }, + { + "word": "HTTP", + "start": 419.4, + "end": 419.78 + }, + { + "word": "frameworks.", + "start": 419.78, + "end": 420.18 + } + ] + }, + { + "start": 421.46, + "end": 426.14, + "text": "The piece up here is like kind of interesting. So this is a macro. If you don't know about", + "words": [ + { + "word": "The", + "start": 421.46, + "end": 421.62 + }, + { + "word": "piece", + "start": 421.62, + "end": 421.74 + }, + { + "word": "up", + "start": 421.74, + "end": 421.92 + }, + { + "word": "here", + "start": 421.92, + "end": 422.16 + }, + { + "word": "is", + "start": 422.16, + "end": 422.46 + }, + { + "word": "like", + "start": 422.46, + "end": 422.62 + }, + { + "word": "kind", + "start": 422.62, + "end": 422.72 + }, + { + "word": "of", + "start": 422.72, + "end": 422.88 + }, + { + "word": "interesting.", + "start": 422.88, + "end": 423.26 + }, + { + "word": "So", + "start": 423.64, + "end": 423.78 + }, + { + "word": "this", + "start": 423.78, + "end": 423.92 + }, + { + "word": "is", + "start": 423.92, + "end": 424.08 + }, + { + "word": "a", + "start": 424.08, + "end": 424.24 + }, + { + "word": "macro.", + "start": 424.24, + "end": 424.58 + }, + { + "word": "If", + "start": 425.12, + "end": 425.32 + }, + { + "word": "you", + "start": 425.32, + "end": 425.48 + }, + { + "word": "don't", + "start": 425.48, + "end": 425.66 + }, + { + "word": "know", + "start": 425.66, + "end": 425.84 + }, + { + "word": "about", + "start": 425.84, + "end": 426.14 + } + ] + }, + { + "start": 426.14, + "end": 429.4, + "text": "macros, I'm sorry, go read about them later. I don't really have time to dig into that,", + "words": [ + { + "word": "macros,", + "start": 426.14, + "end": 426.48 + }, + { + "word": "I'm", + "start": 426.5, + "end": 426.72 + }, + { + "word": "sorry,", + "start": 426.72, + "end": 426.98 + }, + { + "word": "go", + "start": 427.08, + "end": 427.16 + }, + { + "word": "read", + "start": 427.16, + "end": 427.3 + }, + { + "word": "about", + "start": 427.3, + "end": 427.44 + }, + { + "word": "them", + "start": 427.44, + "end": 427.62 + }, + { + "word": "later.", + "start": 427.62, + "end": 427.86 + }, + { + "word": "I", + "start": 427.88, + "end": 427.96 + }, + { + "word": "don't", + "start": 427.96, + "end": 428.14 + }, + { + "word": "really", + "start": 428.14, + "end": 428.42 + }, + { + "word": "have", + "start": 428.42, + "end": 428.62 + }, + { + "word": "time", + "start": 428.62, + "end": 428.78 + }, + { + "word": "to", + "start": 428.78, + "end": 428.94 + }, + { + "word": "dig", + "start": 428.94, + "end": 429.06 + }, + { + "word": "into", + "start": 429.06, + "end": 429.2 + }, + { + "word": "that,", + "start": 429.2, + "end": 429.4 + } + ] + }, + { + "start": 429.4, + "end": 435.34, + "text": "but it is core to any code gen and REST for sure. But this macro gives the metadata that", + "words": [ + { + "word": "but", + "start": 429.4, + "end": 429.52 + }, + { + "word": "it", + "start": 429.52, + "end": 429.74 + }, + { + "word": "is", + "start": 429.74, + "end": 430.26 + }, + { + "word": "core", + "start": 430.26, + "end": 430.58 + }, + { + "word": "to", + "start": 430.58, + "end": 430.96 + }, + { + "word": "any", + "start": 430.96, + "end": 431.18 + }, + { + "word": "code", + "start": 431.18, + "end": 431.46 + }, + { + "word": "gen", + "start": 431.46, + "end": 431.62 + }, + { + "word": "and", + "start": 431.62, + "end": 431.84 + }, + { + "word": "REST", + "start": 431.84, + "end": 431.98 + }, + { + "word": "for", + "start": 431.98, + "end": 432.22 + }, + { + "word": "sure.", + "start": 432.22, + "end": 432.58 + }, + { + "word": "But", + "start": 433.24, + "end": 433.38 + }, + { + "word": "this", + "start": 433.38, + "end": 433.6 + }, + { + "word": "macro", + "start": 433.6, + "end": 433.86 + }, + { + "word": "gives", + "start": 433.86, + "end": 434.08 + }, + { + "word": "the", + "start": 434.08, + "end": 434.38 + }, + { + "word": "metadata", + "start": 434.38, + "end": 434.84 + }, + { + "word": "that", + "start": 434.84, + "end": 435.34 + } + ] + }, + { + "start": 435.34, + "end": 443.82, + "text": "is needed to fully generate out the open API spec. So these two pieces together, inferring", + "words": [ + { + "word": "is", + "start": 435.34, + "end": 435.64 + }, + { + "word": "needed", + "start": 435.64, + "end": 436.08 + }, + { + "word": "to", + "start": 436.08, + "end": 437.02 + }, + { + "word": "fully", + "start": 437.02, + "end": 437.44 + }, + { + "word": "generate", + "start": 437.44, + "end": 438.08 + }, + { + "word": "out", + "start": 438.08, + "end": 438.56 + }, + { + "word": "the", + "start": 438.56, + "end": 438.78 + }, + { + "word": "open", + "start": 438.78, + "end": 438.94 + }, + { + "word": "API", + "start": 438.94, + "end": 439.24 + }, + { + "word": "spec.", + "start": 439.24, + "end": 439.54 + }, + { + "word": "So", + "start": 440.22, + "end": 440.72 + }, + { + "word": "these", + "start": 440.72, + "end": 441.12 + }, + { + "word": "two", + "start": 441.12, + "end": 441.32 + }, + { + "word": "pieces", + "start": 441.32, + "end": 441.64 + }, + { + "word": "together,", + "start": 441.64, + "end": 442.62 + }, + { + "word": "inferring", + "start": 443.46, + "end": 443.82 + } + ] + }, + { + "start": 443.82, + "end": 449.46, + "text": "the implementation and the types inside the interface and getting extra metadata from", + "words": [ + { + "word": "the", + "start": 443.82, + "end": 444.06 + }, + { + "word": "implementation", + "start": 444.06, + "end": 444.62 + }, + { + "word": "and", + "start": 444.62, + "end": 444.96 + }, + { + "word": "the", + "start": 444.96, + "end": 445.18 + }, + { + "word": "types", + "start": 445.18, + "end": 445.66 + }, + { + "word": "inside", + "start": 445.66, + "end": 446.4 + }, + { + "word": "the", + "start": 446.4, + "end": 446.66 + }, + { + "word": "interface", + "start": 446.66, + "end": 447.1 + }, + { + "word": "and", + "start": 447.1, + "end": 447.84 + }, + { + "word": "getting", + "start": 447.84, + "end": 448.2 + }, + { + "word": "extra", + "start": 448.2, + "end": 448.68 + }, + { + "word": "metadata", + "start": 448.68, + "end": 449.14 + }, + { + "word": "from", + "start": 449.14, + "end": 449.46 + } + ] + }, + { + "start": 449.46, + "end": 458.52, + "text": "the macro is what Oxide uses to actually generate their entire open API spec. So running that", + "words": [ + { + "word": "the", + "start": 449.46, + "end": 449.72 + }, + { + "word": "macro", + "start": 449.72, + "end": 450.14 + }, + { + "word": "is", + "start": 450.14, + "end": 450.64 + }, + { + "word": "what", + "start": 450.64, + "end": 452.04 + }, + { + "word": "Oxide", + "start": 452.04, + "end": 452.44 + }, + { + "word": "uses", + "start": 452.44, + "end": 452.84 + }, + { + "word": "to", + "start": 452.84, + "end": 453.14 + }, + { + "word": "actually", + "start": 453.14, + "end": 453.5 + }, + { + "word": "generate", + "start": 453.5, + "end": 453.82 + }, + { + "word": "their", + "start": 453.82, + "end": 454.04 + }, + { + "word": "entire", + "start": 454.04, + "end": 454.5 + }, + { + "word": "open", + "start": 454.5, + "end": 455.5 + }, + { + "word": "API", + "start": 455.5, + "end": 455.78 + }, + { + "word": "spec.", + "start": 455.78, + "end": 456.12 + }, + { + "word": "So", + "start": 457.12, + "end": 457.6 + }, + { + "word": "running", + "start": 457.6, + "end": 458.22 + }, + { + "word": "that", + "start": 458.22, + "end": 458.52 + } + ] + }, + { + "start": 458.52, + "end": 463.78, + "text": "through the generator, you would get something like this. So this JSON blob over here is", + "words": [ + { + "word": "through", + "start": 458.52, + "end": 458.64 + }, + { + "word": "the", + "start": 458.64, + "end": 458.78 + }, + { + "word": "generator,", + "start": 458.78, + "end": 459.12 + }, + { + "word": "you", + "start": 459.52, + "end": 459.56 + }, + { + "word": "would", + "start": 459.56, + "end": 459.84 + }, + { + "word": "get", + "start": 459.84, + "end": 460.0 + }, + { + "word": "something", + "start": 460.0, + "end": 460.48 + }, + { + "word": "like", + "start": 460.48, + "end": 460.86 + }, + { + "word": "this.", + "start": 460.86, + "end": 461.32 + }, + { + "word": "So", + "start": 461.54, + "end": 461.74 + }, + { + "word": "this", + "start": 461.74, + "end": 461.98 + }, + { + "word": "JSON", + "start": 461.98, + "end": 462.36 + }, + { + "word": "blob", + "start": 462.36, + "end": 462.62 + }, + { + "word": "over", + "start": 462.62, + "end": 462.88 + }, + { + "word": "here", + "start": 462.88, + "end": 463.26 + }, + { + "word": "is", + "start": 463.26, + "end": 463.78 + } + ] + }, + { + "start": 463.78, + "end": 471.44, + "text": "an open API spec, just kind of referencing like what it would look like to, or the like", + "words": [ + { + "word": "an", + "start": 463.78, + "end": 464.06 + }, + { + "word": "open", + "start": 464.06, + "end": 464.18 + }, + { + "word": "API", + "start": 464.18, + "end": 464.44 + }, + { + "word": "spec,", + "start": 464.44, + "end": 464.84 + }, + { + "word": "just", + "start": 466.3, + "end": 466.32 + }, + { + "word": "kind", + "start": 466.32, + "end": 466.54 + }, + { + "word": "of", + "start": 466.54, + "end": 466.98 + }, + { + "word": "referencing", + "start": 466.98, + "end": 467.34 + }, + { + "word": "like", + "start": 467.34, + "end": 467.64 + }, + { + "word": "what", + "start": 467.64, + "end": 467.7 + }, + { + "word": "it", + "start": 467.7, + "end": 467.88 + }, + { + "word": "would", + "start": 467.88, + "end": 467.98 + }, + { + "word": "look", + "start": 467.98, + "end": 468.18 + }, + { + "word": "like", + "start": 468.18, + "end": 469.44 + }, + { + "word": "to,", + "start": 469.44, + "end": 470.4 + }, + { + "word": "or", + "start": 470.86, + "end": 470.88 + }, + { + "word": "the", + "start": 470.88, + "end": 471.24 + }, + { + "word": "like", + "start": 471.24, + "end": 471.44 + } + ] + }, + { + "start": 471.44, + "end": 476.64, + "text": "shape of a disk. So the interesting thing is I said that the API is like the product", + "words": [ + { + "word": "shape", + "start": 471.44, + "end": 471.56 + }, + { + "word": "of", + "start": 471.56, + "end": 471.74 + }, + { + "word": "a", + "start": 471.74, + "end": 471.86 + }, + { + "word": "disk.", + "start": 471.86, + "end": 472.14 + }, + { + "word": "So", + "start": 472.58, + "end": 473.02 + }, + { + "word": "the", + "start": 473.02, + "end": 473.26 + }, + { + "word": "interesting", + "start": 473.26, + "end": 473.54 + }, + { + "word": "thing", + "start": 473.54, + "end": 473.78 + }, + { + "word": "is", + "start": 473.78, + "end": 474.04 + }, + { + "word": "I", + "start": 474.04, + "end": 474.3 + }, + { + "word": "said", + "start": 474.3, + "end": 474.6 + }, + { + "word": "that", + "start": 474.6, + "end": 474.92 + }, + { + "word": "the", + "start": 474.92, + "end": 475.14 + }, + { + "word": "API", + "start": 475.14, + "end": 475.48 + }, + { + "word": "is", + "start": 475.48, + "end": 475.8 + }, + { + "word": "like", + "start": 475.8, + "end": 476.1 + }, + { + "word": "the", + "start": 476.1, + "end": 476.34 + }, + { + "word": "product", + "start": 476.34, + "end": 476.64 + } + ] + }, + { + "start": 476.64, + "end": 481.96, + "text": "interface. It's the front door to the product. In some ways, the open API spec is like the", + "words": [ + { + "word": "interface.", + "start": 476.64, + "end": 477.1 + }, + { + "word": "It's", + "start": 477.22, + "end": 477.32 + }, + { + "word": "the", + "start": 477.32, + "end": 477.52 + }, + { + "word": "front", + "start": 477.52, + "end": 477.68 + }, + { + "word": "door", + "start": 477.68, + "end": 477.94 + }, + { + "word": "to", + "start": 477.94, + "end": 478.44 + }, + { + "word": "the", + "start": 478.44, + "end": 478.54 + }, + { + "word": "product.", + "start": 478.54, + "end": 478.98 + }, + { + "word": "In", + "start": 479.38, + "end": 479.5 + }, + { + "word": "some", + "start": 479.5, + "end": 479.74 + }, + { + "word": "ways,", + "start": 479.74, + "end": 479.94 + }, + { + "word": "the", + "start": 480.12, + "end": 480.14 + }, + { + "word": "open", + "start": 480.14, + "end": 480.6 + }, + { + "word": "API", + "start": 480.6, + "end": 480.98 + }, + { + "word": "spec", + "start": 480.98, + "end": 481.34 + }, + { + "word": "is", + "start": 481.34, + "end": 481.6 + }, + { + "word": "like", + "start": 481.6, + "end": 481.8 + }, + { + "word": "the", + "start": 481.8, + "end": 481.96 + } + ] + }, + { + "start": 481.96, + "end": 487.12, + "text": "front door to the product because everything else is generated from that. And open API,", + "words": [ + { + "word": "front", + "start": 481.96, + "end": 482.1 + }, + { + "word": "door", + "start": 482.1, + "end": 482.24 + }, + { + "word": "to", + "start": 482.24, + "end": 482.38 + }, + { + "word": "the", + "start": 482.38, + "end": 482.54 + }, + { + "word": "product", + "start": 482.54, + "end": 482.74 + }, + { + "word": "because", + "start": 482.74, + "end": 483.0 + }, + { + "word": "everything", + "start": 483.0, + "end": 483.4 + }, + { + "word": "else", + "start": 483.4, + "end": 483.7 + }, + { + "word": "is", + "start": 483.7, + "end": 483.94 + }, + { + "word": "generated", + "start": 483.94, + "end": 484.28 + }, + { + "word": "from", + "start": 484.28, + "end": 484.64 + }, + { + "word": "that.", + "start": 484.64, + "end": 485.08 + }, + { + "word": "And", + "start": 485.9, + "end": 486.42 + }, + { + "word": "open", + "start": 486.42, + "end": 486.58 + }, + { + "word": "API,", + "start": 486.58, + "end": 487.12 + } + ] + }, + { + "start": 487.12, + "end": 494.24, + "text": "it's good. It's not great. And it's not super expressive. Rust is much more expressive than", + "words": [ + { + "word": "it's", + "start": 487.12, + "end": 487.68 + }, + { + "word": "good.", + "start": 487.68, + "end": 488.04 + }, + { + "word": "It's", + "start": 488.42, + "end": 488.82 + }, + { + "word": "not", + "start": 488.82, + "end": 489.04 + }, + { + "word": "great.", + "start": 489.04, + "end": 489.46 + }, + { + "word": "And", + "start": 489.82, + "end": 490.24 + }, + { + "word": "it's", + "start": 490.24, + "end": 490.42 + }, + { + "word": "not", + "start": 490.42, + "end": 490.78 + }, + { + "word": "super", + "start": 490.78, + "end": 491.1 + }, + { + "word": "expressive.", + "start": 491.1, + "end": 491.66 + }, + { + "word": "Rust", + "start": 491.96, + "end": 492.1 + }, + { + "word": "is", + "start": 492.1, + "end": 492.84 + }, + { + "word": "much", + "start": 492.84, + "end": 493.1 + }, + { + "word": "more", + "start": 493.1, + "end": 493.34 + }, + { + "word": "expressive", + "start": 493.34, + "end": 493.94 + }, + { + "word": "than", + "start": 493.94, + "end": 494.24 + } + ] + }, + { + "start": 494.24, + "end": 498.42, + "text": "open API can be. So it is like a fundamental constraining force. And there are things that", + "words": [ + { + "word": "open", + "start": 494.24, + "end": 494.48 + }, + { + "word": "API", + "start": 494.48, + "end": 494.76 + }, + { + "word": "can", + "start": 494.76, + "end": 494.96 + }, + { + "word": "be.", + "start": 494.96, + "end": 495.14 + }, + { + "word": "So", + "start": 495.22, + "end": 495.3 + }, + { + "word": "it", + "start": 495.3, + "end": 495.38 + }, + { + "word": "is", + "start": 495.38, + "end": 495.56 + }, + { + "word": "like", + "start": 495.56, + "end": 495.72 + }, + { + "word": "a", + "start": 495.72, + "end": 495.9 + }, + { + "word": "fundamental", + "start": 495.9, + "end": 496.48 + }, + { + "word": "constraining", + "start": 496.48, + "end": 497.24 + }, + { + "word": "force.", + "start": 497.24, + "end": 497.58 + }, + { + "word": "And", + "start": 497.58, + "end": 497.76 + }, + { + "word": "there", + "start": 497.76, + "end": 497.88 + }, + { + "word": "are", + "start": 497.88, + "end": 498.02 + }, + { + "word": "things", + "start": 498.02, + "end": 498.26 + }, + { + "word": "that", + "start": 498.26, + "end": 498.42 + } + ] + }, + { + "start": 498.42, + "end": 504.34, + "text": "you can and can't do because of the constraints of what you're generating to. So going from", + "words": [ + { + "word": "you", + "start": 498.42, + "end": 498.62 + }, + { + "word": "can", + "start": 498.62, + "end": 498.8 + }, + { + "word": "and", + "start": 498.8, + "end": 498.98 + }, + { + "word": "can't", + "start": 498.98, + "end": 499.3 + }, + { + "word": "do", + "start": 499.3, + "end": 499.98 + }, + { + "word": "because", + "start": 499.98, + "end": 500.96 + }, + { + "word": "of", + "start": 500.96, + "end": 501.22 + }, + { + "word": "the", + "start": 501.22, + "end": 501.44 + }, + { + "word": "constraints", + "start": 501.44, + "end": 501.7 + }, + { + "word": "of", + "start": 501.7, + "end": 501.86 + }, + { + "word": "what", + "start": 501.86, + "end": 502.0 + }, + { + "word": "you're", + "start": 502.0, + "end": 502.2 + }, + { + "word": "generating", + "start": 502.2, + "end": 502.56 + }, + { + "word": "to.", + "start": 502.56, + "end": 502.88 + }, + { + "word": "So", + "start": 503.4, + "end": 503.52 + }, + { + "word": "going", + "start": 503.52, + "end": 503.98 + }, + { + "word": "from", + "start": 503.98, + "end": 504.34 + } + ] + }, + { + "start": 504.34, + "end": 510.14, + "text": "Rust to open API spec to Rust again is a fundamentally lossy operation. There are just like some", + "words": [ + { + "word": "Rust", + "start": 504.34, + "end": 504.82 + }, + { + "word": "to", + "start": 504.82, + "end": 505.42 + }, + { + "word": "open", + "start": 505.42, + "end": 505.64 + }, + { + "word": "API", + "start": 505.64, + "end": 505.96 + }, + { + "word": "spec", + "start": 505.96, + "end": 506.26 + }, + { + "word": "to", + "start": 506.26, + "end": 506.5 + }, + { + "word": "Rust", + "start": 506.5, + "end": 506.7 + }, + { + "word": "again", + "start": 506.7, + "end": 507.18 + }, + { + "word": "is", + "start": 507.18, + "end": 507.46 + }, + { + "word": "a", + "start": 507.46, + "end": 507.66 + }, + { + "word": "fundamentally", + "start": 507.66, + "end": 508.02 + }, + { + "word": "lossy", + "start": 508.02, + "end": 508.62 + }, + { + "word": "operation.", + "start": 508.62, + "end": 509.04 + }, + { + "word": "There", + "start": 509.26, + "end": 509.36 + }, + { + "word": "are", + "start": 509.36, + "end": 509.4 + }, + { + "word": "just", + "start": 509.4, + "end": 509.58 + }, + { + "word": "like", + "start": 509.58, + "end": 509.9 + }, + { + "word": "some", + "start": 509.9, + "end": 510.14 + } + ] + }, + { + "start": 510.14, + "end": 515.26, + "text": "things that just won't generate correctly. And I think that's kind of one of the main", + "words": [ + { + "word": "things", + "start": 510.14, + "end": 510.44 + }, + { + "word": "that", + "start": 510.44, + "end": 510.68 + }, + { + "word": "just", + "start": 510.68, + "end": 511.08 + }, + { + "word": "won't", + "start": 511.08, + "end": 511.3 + }, + { + "word": "generate", + "start": 511.3, + "end": 511.68 + }, + { + "word": "correctly.", + "start": 511.68, + "end": 512.18 + }, + { + "word": "And", + "start": 512.66, + "end": 512.8 + }, + { + "word": "I", + "start": 512.8, + "end": 512.9 + }, + { + "word": "think", + "start": 512.9, + "end": 513.1 + }, + { + "word": "that's", + "start": 513.1, + "end": 513.5 + }, + { + "word": "kind", + "start": 513.5, + "end": 513.76 + }, + { + "word": "of", + "start": 513.76, + "end": 514.54 + }, + { + "word": "one", + "start": 514.54, + "end": 514.86 + }, + { + "word": "of", + "start": 514.86, + "end": 514.96 + }, + { + "word": "the", + "start": 514.96, + "end": 515.08 + }, + { + "word": "main", + "start": 515.08, + "end": 515.26 + } + ] + }, + { + "start": 515.26, + "end": 525.52, + "text": "points that I want to make in this whole talk is that translation is lossy. So here's", + "words": [ + { + "word": "points", + "start": 515.26, + "end": 515.66 + }, + { + "word": "that", + "start": 515.66, + "end": 515.94 + }, + { + "word": "I", + "start": 515.94, + "end": 516.04 + }, + { + "word": "want", + "start": 516.04, + "end": 516.18 + }, + { + "word": "to", + "start": 516.18, + "end": 516.38 + }, + { + "word": "make", + "start": 516.38, + "end": 517.04 + }, + { + "word": "in", + "start": 517.04, + "end": 517.6 + }, + { + "word": "this", + "start": 517.6, + "end": 518.18 + }, + { + "word": "whole", + "start": 518.18, + "end": 518.48 + }, + { + "word": "talk", + "start": 518.48, + "end": 518.84 + }, + { + "word": "is", + "start": 518.84, + "end": 519.28 + }, + { + "word": "that", + "start": 519.28, + "end": 521.04 + }, + { + "word": "translation", + "start": 521.04, + "end": 521.76 + }, + { + "word": "is", + "start": 521.76, + "end": 522.12 + }, + { + "word": "lossy.", + "start": 522.12, + "end": 522.6 + }, + { + "word": "So", + "start": 523.8, + "end": 524.26 + }, + { + "word": "here's", + "start": 524.26, + "end": 525.52 + } + ] + }, + { + "start": 525.52, + "end": 535.1, + "text": "a sort of a further example. On this side, on your left side, there's a progenitor API", + "words": [ + { + "word": "a", + "start": 525.52, + "end": 525.68 + }, + { + "word": "sort", + "start": 525.68, + "end": 525.72 + }, + { + "word": "of", + "start": 525.72, + "end": 525.92 + }, + { + "word": "a", + "start": 525.92, + "end": 526.1 + }, + { + "word": "further", + "start": 526.1, + "end": 526.28 + }, + { + "word": "example.", + "start": 526.28, + "end": 527.0 + }, + { + "word": "On", + "start": 528.14, + "end": 528.56 + }, + { + "word": "this", + "start": 528.56, + "end": 528.94 + }, + { + "word": "side,", + "start": 528.94, + "end": 529.38 + }, + { + "word": "on", + "start": 530.5, + "end": 530.92 + }, + { + "word": "your", + "start": 530.92, + "end": 531.16 + }, + { + "word": "left", + "start": 531.16, + "end": 531.34 + }, + { + "word": "side,", + "start": 531.34, + "end": 531.76 + }, + { + "word": "there's", + "start": 532.12, + "end": 532.9 + }, + { + "word": "a", + "start": 532.9, + "end": 533.22 + }, + { + "word": "progenitor", + "start": 533.22, + "end": 534.34 + }, + { + "word": "API", + "start": 534.34, + "end": 535.1 + } + ] + }, + { + "start": 535.1, + "end": 540.0, + "text": "to, or it's like this macro call where you'd give it an open API spec. And that would", + "words": [ + { + "word": "to,", + "start": 535.1, + "end": 535.98 + }, + { + "word": "or", + "start": 536.04, + "end": 536.12 + }, + { + "word": "it's", + "start": 536.12, + "end": 536.24 + }, + { + "word": "like", + "start": 536.24, + "end": 536.36 + }, + { + "word": "this", + "start": 536.36, + "end": 536.54 + }, + { + "word": "macro", + "start": 536.54, + "end": 536.84 + }, + { + "word": "call", + "start": 536.84, + "end": 537.18 + }, + { + "word": "where", + "start": 537.18, + "end": 537.42 + }, + { + "word": "you'd", + "start": 537.42, + "end": 537.74 + }, + { + "word": "give", + "start": 537.74, + "end": 537.84 + }, + { + "word": "it", + "start": 537.84, + "end": 538.06 + }, + { + "word": "an", + "start": 538.06, + "end": 538.22 + }, + { + "word": "open", + "start": 538.22, + "end": 538.36 + }, + { + "word": "API", + "start": 538.36, + "end": 538.66 + }, + { + "word": "spec.", + "start": 538.66, + "end": 539.1 + }, + { + "word": "And", + "start": 539.38, + "end": 539.7 + }, + { + "word": "that", + "start": 539.7, + "end": 539.86 + }, + { + "word": "would", + "start": 539.86, + "end": 540.0 + } + ] + }, + { + "start": 540.0, + "end": 544.76, + "text": "essentially generate the out of the Rust SDK. And here on the right is an example of like", + "words": [ + { + "word": "essentially", + "start": 540.0, + "end": 540.34 + }, + { + "word": "generate", + "start": 540.34, + "end": 540.78 + }, + { + "word": "the", + "start": 540.78, + "end": 541.06 + }, + { + "word": "out", + "start": 541.06, + "end": 541.08 + }, + { + "word": "of", + "start": 541.08, + "end": 541.18 + }, + { + "word": "the", + "start": 541.18, + "end": 541.2 + }, + { + "word": "Rust", + "start": 541.2, + "end": 541.34 + }, + { + "word": "SDK.", + "start": 541.34, + "end": 541.74 + }, + { + "word": "And", + "start": 542.0, + "end": 542.2 + }, + { + "word": "here", + "start": 542.2, + "end": 542.4 + }, + { + "word": "on", + "start": 542.4, + "end": 542.94 + }, + { + "word": "the", + "start": 542.94, + "end": 543.12 + }, + { + "word": "right", + "start": 543.12, + "end": 543.36 + }, + { + "word": "is", + "start": 543.36, + "end": 543.7 + }, + { + "word": "an", + "start": 543.7, + "end": 543.98 + }, + { + "word": "example", + "start": 543.98, + "end": 544.36 + }, + { + "word": "of", + "start": 544.36, + "end": 544.56 + }, + { + "word": "like", + "start": 544.56, + "end": 544.76 + } + ] + }, + { + "start": 544.76, + "end": 548.94, + "text": "what the generated SDK might look like. And again, this is just the Rust example, but", + "words": [ + { + "word": "what", + "start": 544.76, + "end": 544.84 + }, + { + "word": "the", + "start": 544.84, + "end": 545.0 + }, + { + "word": "generated", + "start": 545.0, + "end": 545.4 + }, + { + "word": "SDK", + "start": 545.4, + "end": 545.92 + }, + { + "word": "might", + "start": 545.92, + "end": 546.28 + }, + { + "word": "look", + "start": 546.28, + "end": 546.52 + }, + { + "word": "like.", + "start": 546.52, + "end": 546.84 + }, + { + "word": "And", + "start": 547.06, + "end": 547.2 + }, + { + "word": "again,", + "start": 547.2, + "end": 547.3 + }, + { + "word": "this", + "start": 547.3, + "end": 547.5 + }, + { + "word": "is", + "start": 547.5, + "end": 547.74 + }, + { + "word": "just", + "start": 547.74, + "end": 547.98 + }, + { + "word": "the", + "start": 547.98, + "end": 548.12 + }, + { + "word": "Rust", + "start": 548.12, + "end": 548.24 + }, + { + "word": "example,", + "start": 548.24, + "end": 548.72 + }, + { + "word": "but", + "start": 548.76, + "end": 548.94 + } + ] + }, + { + "start": 548.94, + "end": 556.98, + "text": "they generate for each language, well, each major language. I will say there's like no", + "words": [ + { + "word": "they", + "start": 548.94, + "end": 549.18 + }, + { + "word": "generate", + "start": 549.18, + "end": 549.56 + }, + { + "word": "for", + "start": 549.56, + "end": 550.0 + }, + { + "word": "each", + "start": 550.0, + "end": 550.86 + }, + { + "word": "language,", + "start": 550.86, + "end": 551.46 + }, + { + "word": "well,", + "start": 551.82, + "end": 552.14 + }, + { + "word": "each", + "start": 552.4, + "end": 552.76 + }, + { + "word": "major", + "start": 552.76, + "end": 553.04 + }, + { + "word": "language.", + "start": 553.04, + "end": 553.48 + }, + { + "word": "I", + "start": 555.42, + "end": 555.9 + }, + { + "word": "will", + "start": 555.9, + "end": 556.14 + }, + { + "word": "say", + "start": 556.14, + "end": 556.26 + }, + { + "word": "there's", + "start": 556.26, + "end": 556.54 + }, + { + "word": "like", + "start": 556.54, + "end": 556.8 + }, + { + "word": "no", + "start": 556.8, + "end": 556.98 + } + ] + }, + { + "start": 556.98, + "end": 561.16, + "text": "one size fits all in cogen. If you think you're going to npm install your way out of a cogen", + "words": [ + { + "word": "one", + "start": 556.98, + "end": 557.24 + }, + { + "word": "size", + "start": 557.24, + "end": 557.5 + }, + { + "word": "fits", + "start": 557.5, + "end": 557.76 + }, + { + "word": "all", + "start": 557.76, + "end": 557.94 + }, + { + "word": "in", + "start": 557.94, + "end": 558.1 + }, + { + "word": "cogen.", + "start": 558.1, + "end": 558.42 + }, + { + "word": "If", + "start": 558.6, + "end": 558.72 + }, + { + "word": "you", + "start": 558.72, + "end": 558.86 + }, + { + "word": "think", + "start": 558.86, + "end": 558.96 + }, + { + "word": "you're", + "start": 558.96, + "end": 559.16 + }, + { + "word": "going", + "start": 559.16, + "end": 559.34 + }, + { + "word": "to", + "start": 559.34, + "end": 559.56 + }, + { + "word": "npm", + "start": 559.56, + "end": 559.84 + }, + { + "word": "install", + "start": 559.84, + "end": 560.22 + }, + { + "word": "your", + "start": 560.22, + "end": 560.46 + }, + { + "word": "way", + "start": 560.46, + "end": 560.6 + }, + { + "word": "out", + "start": 560.6, + "end": 560.7 + }, + { + "word": "of", + "start": 560.7, + "end": 560.8 + }, + { + "word": "a", + "start": 560.8, + "end": 560.92 + }, + { + "word": "cogen", + "start": 560.92, + "end": 561.16 + } + ] + }, + { + "start": 561.16, + "end": 566.86, + "text": "problem, you're sorely mistaken. There's a lot of community stuff that's built around", + "words": [ + { + "word": "problem,", + "start": 561.16, + "end": 561.5 + }, + { + "word": "you're", + "start": 561.66, + "end": 562.18 + }, + { + "word": "sorely", + "start": 562.18, + "end": 562.56 + }, + { + "word": "mistaken.", + "start": 562.56, + "end": 562.9 + }, + { + "word": "There's", + "start": 564.02, + "end": 564.5 + }, + { + "word": "a", + "start": 564.5, + "end": 564.68 + }, + { + "word": "lot", + "start": 564.68, + "end": 564.88 + }, + { + "word": "of", + "start": 564.88, + "end": 565.1 + }, + { + "word": "community", + "start": 565.1, + "end": 565.46 + }, + { + "word": "stuff", + "start": 565.46, + "end": 565.9 + }, + { + "word": "that's", + "start": 565.9, + "end": 566.42 + }, + { + "word": "built", + "start": 566.42, + "end": 566.56 + }, + { + "word": "around", + "start": 566.56, + "end": 566.86 + } + ] + }, + { + "start": 566.86, + "end": 571.12, + "text": "like open API specs or swagger or whatever. And not to disparage any of the work that", + "words": [ + { + "word": "like", + "start": 566.86, + "end": 567.1 + }, + { + "word": "open", + "start": 567.1, + "end": 567.26 + }, + { + "word": "API", + "start": 567.26, + "end": 567.56 + }, + { + "word": "specs", + "start": 567.56, + "end": 568.02 + }, + { + "word": "or", + "start": 568.02, + "end": 568.24 + }, + { + "word": "swagger", + "start": 568.24, + "end": 568.74 + }, + { + "word": "or", + "start": 568.74, + "end": 568.94 + }, + { + "word": "whatever.", + "start": 568.94, + "end": 569.22 + }, + { + "word": "And", + "start": 569.34, + "end": 569.76 + }, + { + "word": "not", + "start": 569.76, + "end": 569.98 + }, + { + "word": "to", + "start": 569.98, + "end": 570.14 + }, + { + "word": "disparage", + "start": 570.14, + "end": 570.46 + }, + { + "word": "any", + "start": 570.46, + "end": 570.66 + }, + { + "word": "of", + "start": 570.66, + "end": 570.74 + }, + { + "word": "the", + "start": 570.74, + "end": 570.86 + }, + { + "word": "work", + "start": 570.86, + "end": 571.02 + }, + { + "word": "that", + "start": 571.02, + "end": 571.12 + } + ] + }, + { + "start": 571.12, + "end": 576.76, + "text": "people do is fantastic. But there is no one size fits all. And I think one of the things", + "words": [ + { + "word": "people", + "start": 571.12, + "end": 571.4 + }, + { + "word": "do", + "start": 571.4, + "end": 571.64 + }, + { + "word": "is", + "start": 571.64, + "end": 571.82 + }, + { + "word": "fantastic.", + "start": 571.82, + "end": 572.58 + }, + { + "word": "But", + "start": 573.04, + "end": 573.42 + }, + { + "word": "there", + "start": 573.42, + "end": 573.76 + }, + { + "word": "is", + "start": 573.76, + "end": 573.94 + }, + { + "word": "no", + "start": 573.94, + "end": 574.18 + }, + { + "word": "one", + "start": 574.18, + "end": 574.4 + }, + { + "word": "size", + "start": 574.4, + "end": 574.8 + }, + { + "word": "fits", + "start": 574.8, + "end": 575.1 + }, + { + "word": "all.", + "start": 575.1, + "end": 575.28 + }, + { + "word": "And", + "start": 575.38, + "end": 575.4 + }, + { + "word": "I", + "start": 575.4, + "end": 575.5 + }, + { + "word": "think", + "start": 575.5, + "end": 575.8 + }, + { + "word": "one", + "start": 575.8, + "end": 575.98 + }, + { + "word": "of", + "start": 575.98, + "end": 576.1 + }, + { + "word": "the", + "start": 576.1, + "end": 576.22 + }, + { + "word": "things", + "start": 576.22, + "end": 576.76 + } + ] + }, + { + "start": 576.76, + "end": 582.68, + "text": "that companies in this space are doing is just trying to find clever ways to like help", + "words": [ + { + "word": "that", + "start": 576.76, + "end": 577.84 + }, + { + "word": "companies", + "start": 577.84, + "end": 578.72 + }, + { + "word": "in", + "start": 578.72, + "end": 578.94 + }, + { + "word": "this", + "start": 578.94, + "end": 579.12 + }, + { + "word": "space", + "start": 579.12, + "end": 579.32 + }, + { + "word": "are", + "start": 579.32, + "end": 579.6 + }, + { + "word": "doing", + "start": 579.6, + "end": 579.96 + }, + { + "word": "is", + "start": 579.96, + "end": 580.44 + }, + { + "word": "just", + "start": 580.44, + "end": 580.76 + }, + { + "word": "trying", + "start": 580.76, + "end": 580.88 + }, + { + "word": "to", + "start": 580.88, + "end": 581.06 + }, + { + "word": "find", + "start": 581.06, + "end": 581.24 + }, + { + "word": "clever", + "start": 581.24, + "end": 581.54 + }, + { + "word": "ways", + "start": 581.54, + "end": 581.96 + }, + { + "word": "to", + "start": 581.96, + "end": 582.22 + }, + { + "word": "like", + "start": 582.22, + "end": 582.52 + }, + { + "word": "help", + "start": 582.52, + "end": 582.68 + } + ] + }, + { + "start": 582.68, + "end": 589.14, + "text": "you make expressive APIs while embracing these restrictions. So like stainless has their", + "words": [ + { + "word": "you", + "start": 582.68, + "end": 583.24 + }, + { + "word": "make", + "start": 583.24, + "end": 583.42 + }, + { + "word": "expressive", + "start": 583.42, + "end": 583.84 + }, + { + "word": "APIs", + "start": 583.84, + "end": 584.38 + }, + { + "word": "while", + "start": 584.38, + "end": 585.22 + }, + { + "word": "embracing", + "start": 585.22, + "end": 585.66 + }, + { + "word": "these", + "start": 585.66, + "end": 586.54 + }, + { + "word": "restrictions.", + "start": 586.54, + "end": 587.02 + }, + { + "word": "So", + "start": 587.44, + "end": 587.44 + }, + { + "word": "like", + "start": 587.44, + "end": 587.78 + }, + { + "word": "stainless", + "start": 587.78, + "end": 588.06 + }, + { + "word": "has", + "start": 588.06, + "end": 588.44 + }, + { + "word": "their", + "start": 588.44, + "end": 589.14 + } + ] + }, + { + "start": 589.14, + "end": 595.4, + "text": "sidecar config that adds some expressiveness to your base open API spec. And that's like", + "words": [ + { + "word": "sidecar", + "start": 589.14, + "end": 589.88 + }, + { + "word": "config", + "start": 589.88, + "end": 590.48 + }, + { + "word": "that", + "start": 590.48, + "end": 591.2 + }, + { + "word": "adds", + "start": 591.2, + "end": 591.72 + }, + { + "word": "some", + "start": 591.72, + "end": 592.12 + }, + { + "word": "expressiveness", + "start": 592.12, + "end": 592.46 + }, + { + "word": "to", + "start": 592.46, + "end": 592.94 + }, + { + "word": "your", + "start": 592.94, + "end": 593.36 + }, + { + "word": "base", + "start": 593.36, + "end": 593.7 + }, + { + "word": "open", + "start": 593.7, + "end": 593.98 + }, + { + "word": "API", + "start": 593.98, + "end": 594.34 + }, + { + "word": "spec.", + "start": 594.34, + "end": 594.6 + }, + { + "word": "And", + "start": 594.66, + "end": 594.74 + }, + { + "word": "that's", + "start": 594.74, + "end": 594.96 + }, + { + "word": "like", + "start": 594.96, + "end": 595.4 + } + ] + }, + { + "start": 595.4, + "end": 605.02, + "text": "necessary to generate a good interface. So I'll switch gears a little bit and talk about", + "words": [ + { + "word": "necessary", + "start": 595.4, + "end": 595.94 + }, + { + "word": "to", + "start": 595.94, + "end": 596.44 + }, + { + "word": "generate", + "start": 596.44, + "end": 596.78 + }, + { + "word": "a", + "start": 596.78, + "end": 596.92 + }, + { + "word": "good", + "start": 596.92, + "end": 597.04 + }, + { + "word": "interface.", + "start": 597.04, + "end": 597.58 + }, + { + "word": "So", + "start": 600.96, + "end": 601.56 + }, + { + "word": "I'll", + "start": 601.56, + "end": 602.94 + }, + { + "word": "switch", + "start": 602.94, + "end": 603.38 + }, + { + "word": "gears", + "start": 603.38, + "end": 603.68 + }, + { + "word": "a", + "start": 603.68, + "end": 603.86 + }, + { + "word": "little", + "start": 603.86, + "end": 604.06 + }, + { + "word": "bit", + "start": 604.06, + "end": 604.3 + }, + { + "word": "and", + "start": 604.3, + "end": 604.52 + }, + { + "word": "talk", + "start": 604.52, + "end": 604.7 + }, + { + "word": "about", + "start": 604.7, + "end": 605.02 + } + ] + }, + { + "start": 605.02, + "end": 614.7, + "text": "my recurse project. I had like a basic premise here. I was like, can I build a simpler electron?", + "words": [ + { + "word": "my", + "start": 605.02, + "end": 605.46 + }, + { + "word": "recurse", + "start": 605.46, + "end": 605.88 + }, + { + "word": "project.", + "start": 605.88, + "end": 606.32 + }, + { + "word": "I", + "start": 608.54, + "end": 609.14 + }, + { + "word": "had", + "start": 609.14, + "end": 609.38 + }, + { + "word": "like", + "start": 609.38, + "end": 609.56 + }, + { + "word": "a", + "start": 609.56, + "end": 610.18 + }, + { + "word": "basic", + "start": 610.18, + "end": 610.66 + }, + { + "word": "premise", + "start": 610.66, + "end": 611.2 + }, + { + "word": "here.", + "start": 611.2, + "end": 611.6 + }, + { + "word": "I", + "start": 611.64, + "end": 611.74 + }, + { + "word": "was", + "start": 611.74, + "end": 611.88 + }, + { + "word": "like,", + "start": 611.88, + "end": 612.5 + }, + { + "word": "can", + "start": 613.0, + "end": 613.28 + }, + { + "word": "I", + "start": 613.28, + "end": 613.48 + }, + { + "word": "build", + "start": 613.48, + "end": 613.68 + }, + { + "word": "a", + "start": 613.68, + "end": 613.92 + }, + { + "word": "simpler", + "start": 613.92, + "end": 614.2 + }, + { + "word": "electron?", + "start": 614.2, + "end": 614.7 + } + ] + }, + { + "start": 615.0, + "end": 619.8, + "text": "I know we've all have a love-hate relationship with electron. It is a fantastic piece of", + "words": [ + { + "word": "I", + "start": 615.0, + "end": 615.26 + }, + { + "word": "know", + "start": 615.26, + "end": 615.5 + }, + { + "word": "we've", + "start": 615.5, + "end": 615.88 + }, + { + "word": "all", + "start": 615.88, + "end": 616.34 + }, + { + "word": "have", + "start": 616.34, + "end": 616.92 + }, + { + "word": "a", + "start": 616.92, + "end": 617.14 + }, + { + "word": "love", + "start": 617.14, + "end": 617.28 + }, + { + "word": "-hate", + "start": 617.28, + "end": 617.52 + }, + { + "word": "relationship", + "start": 617.52, + "end": 618.06 + }, + { + "word": "with", + "start": 618.06, + "end": 618.26 + }, + { + "word": "electron.", + "start": 618.26, + "end": 618.58 + }, + { + "word": "It", + "start": 618.74, + "end": 618.84 + }, + { + "word": "is", + "start": 618.84, + "end": 619.02 + }, + { + "word": "a", + "start": 619.02, + "end": 619.16 + }, + { + "word": "fantastic", + "start": 619.16, + "end": 619.56 + }, + { + "word": "piece", + "start": 619.56, + "end": 619.74 + }, + { + "word": "of", + "start": 619.74, + "end": 620.04 + } + ] + }, + { + "start": 620.04, + "end": 628.32, + "text": "engineering, but it is also a piece of engineering. And one of the things for me is like I really", + "words": [ + { + "word": "engineering,", + "start": 620.04, + "end": 620.32 + }, + { + "word": "but", + "start": 620.38, + "end": 620.44 + }, + { + "word": "it", + "start": 620.44, + "end": 620.56 + }, + { + "word": "is", + "start": 620.56, + "end": 620.78 + }, + { + "word": "also", + "start": 620.78, + "end": 621.98 + }, + { + "word": "a", + "start": 621.98, + "end": 623.18 + }, + { + "word": "piece", + "start": 623.18, + "end": 623.3 + }, + { + "word": "of", + "start": 623.3, + "end": 623.5 + }, + { + "word": "engineering.", + "start": 623.5, + "end": 623.86 + }, + { + "word": "And", + "start": 626.1, + "end": 626.46 + }, + { + "word": "one", + "start": 626.46, + "end": 627.0 + }, + { + "word": "of", + "start": 627.0, + "end": 627.1 + }, + { + "word": "the", + "start": 627.1, + "end": 627.16 + }, + { + "word": "things", + "start": 627.16, + "end": 627.32 + }, + { + "word": "for", + "start": 627.32, + "end": 627.5 + }, + { + "word": "me", + "start": 627.5, + "end": 627.66 + }, + { + "word": "is", + "start": 627.66, + "end": 627.82 + }, + { + "word": "like", + "start": 627.82, + "end": 627.98 + }, + { + "word": "I", + "start": 627.98, + "end": 628.06 + }, + { + "word": "really", + "start": 628.06, + "end": 628.32 + } + ] + }, + { + "start": 628.32, + "end": 632.58, + "text": "like to do rapid prototypes. And a lot of times I don't want to set up this whole thing,", + "words": [ + { + "word": "like", + "start": 628.32, + "end": 628.5 + }, + { + "word": "to", + "start": 628.5, + "end": 629.16 + }, + { + "word": "do", + "start": 629.16, + "end": 629.46 + }, + { + "word": "rapid", + "start": 629.46, + "end": 629.78 + }, + { + "word": "prototypes.", + "start": 629.78, + "end": 630.28 + }, + { + "word": "And", + "start": 630.3, + "end": 630.48 + }, + { + "word": "a", + "start": 630.48, + "end": 630.56 + }, + { + "word": "lot", + "start": 630.56, + "end": 630.64 + }, + { + "word": "of", + "start": 630.64, + "end": 630.76 + }, + { + "word": "times", + "start": 630.76, + "end": 630.94 + }, + { + "word": "I", + "start": 630.94, + "end": 631.06 + }, + { + "word": "don't", + "start": 631.06, + "end": 631.34 + }, + { + "word": "want", + "start": 631.34, + "end": 631.48 + }, + { + "word": "to", + "start": 631.48, + "end": 631.64 + }, + { + "word": "set", + "start": 631.64, + "end": 631.74 + }, + { + "word": "up", + "start": 631.74, + "end": 631.84 + }, + { + "word": "this", + "start": 631.84, + "end": 632.04 + }, + { + "word": "whole", + "start": 632.04, + "end": 632.28 + }, + { + "word": "thing,", + "start": 632.28, + "end": 632.58 + } + ] + }, + { + "start": 632.58, + "end": 638.72, + "text": "but I want to feel like what is the experience if this were a desktop app? Because it's like", + "words": [ + { + "word": "but", + "start": 632.58, + "end": 632.7 + }, + { + "word": "I", + "start": 632.7, + "end": 632.88 + }, + { + "word": "want", + "start": 632.88, + "end": 633.0 + }, + { + "word": "to", + "start": 633.0, + "end": 633.22 + }, + { + "word": "feel", + "start": 633.22, + "end": 633.38 + }, + { + "word": "like", + "start": 633.38, + "end": 633.98 + }, + { + "word": "what", + "start": 633.98, + "end": 634.08 + }, + { + "word": "is", + "start": 634.08, + "end": 634.32 + }, + { + "word": "the", + "start": 634.32, + "end": 635.86 + }, + { + "word": "experience", + "start": 635.86, + "end": 636.4 + }, + { + "word": "if", + "start": 636.4, + "end": 636.54 + }, + { + "word": "this", + "start": 636.54, + "end": 636.76 + }, + { + "word": "were", + "start": 636.76, + "end": 636.9 + }, + { + "word": "a", + "start": 636.9, + "end": 637.0 + }, + { + "word": "desktop", + "start": 637.0, + "end": 637.32 + }, + { + "word": "app?", + "start": 637.32, + "end": 637.66 + }, + { + "word": "Because", + "start": 637.78, + "end": 637.9 + }, + { + "word": "it's", + "start": 637.9, + "end": 638.2 + }, + { + "word": "like", + "start": 638.2, + "end": 638.72 + } + ] + }, + { + "start": 638.72, + "end": 643.62, + "text": "important for the learning process of just getting the UX right. So I just stood on that", + "words": [ + { + "word": "important", + "start": 638.72, + "end": 639.0 + }, + { + "word": "for", + "start": 639.0, + "end": 639.18 + }, + { + "word": "the", + "start": 639.18, + "end": 639.32 + }, + { + "word": "learning", + "start": 639.32, + "end": 639.54 + }, + { + "word": "process", + "start": 639.54, + "end": 639.98 + }, + { + "word": "of", + "start": 639.98, + "end": 640.12 + }, + { + "word": "just", + "start": 640.12, + "end": 640.3 + }, + { + "word": "getting", + "start": 640.3, + "end": 640.46 + }, + { + "word": "the", + "start": 640.46, + "end": 640.7 + }, + { + "word": "UX", + "start": 640.7, + "end": 640.9 + }, + { + "word": "right.", + "start": 640.9, + "end": 641.3 + }, + { + "word": "So", + "start": 642.28, + "end": 642.54 + }, + { + "word": "I", + "start": 642.54, + "end": 642.84 + }, + { + "word": "just", + "start": 642.84, + "end": 643.28 + }, + { + "word": "stood", + "start": 643.28, + "end": 643.38 + }, + { + "word": "on", + "start": 643.38, + "end": 643.5 + }, + { + "word": "that", + "start": 643.5, + "end": 643.62 + } + ] + }, + { + "start": 643.62, + "end": 649.56, + "text": "for a little bit. And I can show a demo real quick, which I was not set up for, but that's", + "words": [ + { + "word": "for", + "start": 643.62, + "end": 643.76 + }, + { + "word": "a", + "start": 643.76, + "end": 643.84 + }, + { + "word": "little", + "start": 643.84, + "end": 643.98 + }, + { + "word": "bit.", + "start": 643.98, + "end": 644.88 + }, + { + "word": "And", + "start": 645.44, + "end": 645.8 + }, + { + "word": "I", + "start": 645.8, + "end": 645.94 + }, + { + "word": "can", + "start": 645.94, + "end": 646.42 + }, + { + "word": "show", + "start": 646.42, + "end": 647.0 + }, + { + "word": "a", + "start": 647.0, + "end": 647.36 + }, + { + "word": "demo", + "start": 647.36, + "end": 647.54 + }, + { + "word": "real", + "start": 647.54, + "end": 647.8 + }, + { + "word": "quick,", + "start": 647.8, + "end": 647.96 + }, + { + "word": "which", + "start": 648.0, + "end": 648.12 + }, + { + "word": "I", + "start": 648.12, + "end": 648.32 + }, + { + "word": "was", + "start": 648.32, + "end": 648.48 + }, + { + "word": "not", + "start": 648.48, + "end": 648.6 + }, + { + "word": "set", + "start": 648.6, + "end": 648.72 + }, + { + "word": "up", + "start": 648.72, + "end": 648.88 + }, + { + "word": "for,", + "start": 648.88, + "end": 649.06 + }, + { + "word": "but", + "start": 649.18, + "end": 649.3 + }, + { + "word": "that's", + "start": 649.3, + "end": 649.56 + } + ] + }, + { + "start": 649.56, + "end": 662.6, + "text": "okay. Cool. So I am going to do a thing. So I'm going to show example of a desktop teal", + "words": [ + { + "word": "okay.", + "start": 649.56, + "end": 649.68 + }, + { + "word": "Cool.", + "start": 652.38, + "end": 652.98 + }, + { + "word": "So", + "start": 653.16, + "end": 653.6 + }, + { + "word": "I", + "start": 653.6, + "end": 653.94 + }, + { + "word": "am", + "start": 653.94, + "end": 654.3 + }, + { + "word": "going", + "start": 654.3, + "end": 654.76 + }, + { + "word": "to", + "start": 654.76, + "end": 655.54 + }, + { + "word": "do", + "start": 655.54, + "end": 656.16 + }, + { + "word": "a", + "start": 656.16, + "end": 656.42 + }, + { + "word": "thing.", + "start": 656.42, + "end": 656.74 + }, + { + "word": "So", + "start": 658.84, + "end": 659.44 + }, + { + "word": "I'm", + "start": 659.44, + "end": 659.64 + }, + { + "word": "going", + "start": 659.64, + "end": 659.68 + }, + { + "word": "to", + "start": 659.68, + "end": 659.8 + }, + { + "word": "show", + "start": 659.8, + "end": 660.08 + }, + { + "word": "example", + "start": 660.08, + "end": 660.64 + }, + { + "word": "of", + "start": 660.64, + "end": 661.22 + }, + { + "word": "a", + "start": 661.22, + "end": 661.52 + }, + { + "word": "desktop", + "start": 661.52, + "end": 662.2 + }, + { + "word": "teal", + "start": 662.2, + "end": 662.6 + } + ] + }, + { + "start": 662.6, + "end": 668.8, + "text": "draw application. So this is teal draw, the whiteboard. It's open source. And so I've just", + "words": [ + { + "word": "draw", + "start": 662.6, + "end": 662.72 + }, + { + "word": "application.", + "start": 662.72, + "end": 663.3 + }, + { + "word": "So", + "start": 663.98, + "end": 664.2 + }, + { + "word": "this", + "start": 664.2, + "end": 664.5 + }, + { + "word": "is", + "start": 664.5, + "end": 664.66 + }, + { + "word": "teal", + "start": 664.66, + "end": 664.84 + }, + { + "word": "draw,", + "start": 664.84, + "end": 665.02 + }, + { + "word": "the", + "start": 665.18, + "end": 665.48 + }, + { + "word": "whiteboard.", + "start": 665.48, + "end": 666.04 + }, + { + "word": "It's", + "start": 666.56, + "end": 667.16 + }, + { + "word": "open", + "start": 667.16, + "end": 667.36 + }, + { + "word": "source.", + "start": 667.36, + "end": 667.86 + }, + { + "word": "And", + "start": 668.0, + "end": 668.36 + }, + { + "word": "so", + "start": 668.36, + "end": 668.46 + }, + { + "word": "I've", + "start": 668.46, + "end": 668.58 + }, + { + "word": "just", + "start": 668.58, + "end": 668.8 + } + ] + }, + { + "start": 668.8, + "end": 675.94, + "text": "embedded it directly in this web view shell. So I mean, it is a regular app. I can move", + "words": [ + { + "word": "embedded", + "start": 668.8, + "end": 669.1 + }, + { + "word": "it", + "start": 669.1, + "end": 669.44 + }, + { + "word": "directly", + "start": 669.44, + "end": 669.9 + }, + { + "word": "in", + "start": 669.9, + "end": 671.12 + }, + { + "word": "this", + "start": 671.12, + "end": 671.76 + }, + { + "word": "web", + "start": 671.76, + "end": 672.04 + }, + { + "word": "view", + "start": 672.04, + "end": 672.32 + }, + { + "word": "shell.", + "start": 672.32, + "end": 672.66 + }, + { + "word": "So", + "start": 673.04, + "end": 673.64 + }, + { + "word": "I", + "start": 673.64, + "end": 673.76 + }, + { + "word": "mean,", + "start": 673.76, + "end": 673.84 + }, + { + "word": "it", + "start": 673.84, + "end": 673.98 + }, + { + "word": "is", + "start": 673.98, + "end": 674.16 + }, + { + "word": "a", + "start": 674.16, + "end": 674.5 + }, + { + "word": "regular", + "start": 674.5, + "end": 674.82 + }, + { + "word": "app.", + "start": 674.82, + "end": 675.18 + }, + { + "word": "I", + "start": 675.18, + "end": 675.28 + }, + { + "word": "can", + "start": 675.28, + "end": 675.72 + }, + { + "word": "move", + "start": 675.72, + "end": 675.94 + } + ] + }, + { + "start": 675.94, + "end": 680.74, + "text": "things around and draw and stuff like that. The nice thing is it persists on the back", + "words": [ + { + "word": "things", + "start": 675.94, + "end": 676.14 + }, + { + "word": "around", + "start": 676.14, + "end": 676.58 + }, + { + "word": "and", + "start": 676.58, + "end": 677.1 + }, + { + "word": "draw", + "start": 677.1, + "end": 677.36 + }, + { + "word": "and", + "start": 677.36, + "end": 677.56 + }, + { + "word": "stuff", + "start": 677.56, + "end": 677.64 + }, + { + "word": "like", + "start": 677.64, + "end": 677.86 + }, + { + "word": "that.", + "start": 677.86, + "end": 678.06 + }, + { + "word": "The", + "start": 678.3, + "end": 678.44 + }, + { + "word": "nice", + "start": 678.44, + "end": 678.6 + }, + { + "word": "thing", + "start": 678.6, + "end": 678.8 + }, + { + "word": "is", + "start": 678.8, + "end": 679.2 + }, + { + "word": "it", + "start": 679.2, + "end": 679.52 + }, + { + "word": "persists", + "start": 679.52, + "end": 680.18 + }, + { + "word": "on", + "start": 680.18, + "end": 680.4 + }, + { + "word": "the", + "start": 680.4, + "end": 680.54 + }, + { + "word": "back", + "start": 680.54, + "end": 680.74 + } + ] + }, + { + "start": 680.74, + "end": 687.16, + "text": "end to disk. And I didn't have to do anything to make that happen. It just magically happens.", + "words": [ + { + "word": "end", + "start": 680.74, + "end": 681.52 + }, + { + "word": "to", + "start": 681.52, + "end": 682.18 + }, + { + "word": "disk.", + "start": 682.18, + "end": 682.46 + }, + { + "word": "And", + "start": 682.62, + "end": 682.78 + }, + { + "word": "I", + "start": 682.78, + "end": 682.9 + }, + { + "word": "didn't", + "start": 682.9, + "end": 683.06 + }, + { + "word": "have", + "start": 683.06, + "end": 683.24 + }, + { + "word": "to", + "start": 683.24, + "end": 683.6 + }, + { + "word": "do", + "start": 683.6, + "end": 683.8 + }, + { + "word": "anything", + "start": 683.8, + "end": 684.14 + }, + { + "word": "to", + "start": 684.14, + "end": 684.4 + }, + { + "word": "make", + "start": 684.4, + "end": 684.58 + }, + { + "word": "that", + "start": 684.58, + "end": 684.94 + }, + { + "word": "happen.", + "start": 684.94, + "end": 685.3 + }, + { + "word": "It", + "start": 685.42, + "end": 685.62 + }, + { + "word": "just", + "start": 685.62, + "end": 686.1 + }, + { + "word": "magically", + "start": 686.1, + "end": 686.6 + }, + { + "word": "happens.", + "start": 686.6, + "end": 687.16 + } + ] + }, + { + "start": 688.5, + "end": 692.46, + "text": "The example code is here. I'll give you a link to this later. You can kind of look at", + "words": [ + { + "word": "The", + "start": 688.5, + "end": 688.76 + }, + { + "word": "example", + "start": 688.76, + "end": 688.96 + }, + { + "word": "code", + "start": 688.96, + "end": 689.14 + }, + { + "word": "is", + "start": 689.14, + "end": 689.38 + }, + { + "word": "here.", + "start": 689.38, + "end": 689.8 + }, + { + "word": "I'll", + "start": 690.04, + "end": 690.44 + }, + { + "word": "give", + "start": 690.44, + "end": 690.56 + }, + { + "word": "you", + "start": 690.56, + "end": 690.68 + }, + { + "word": "a", + "start": 690.68, + "end": 690.76 + }, + { + "word": "link", + "start": 690.76, + "end": 690.84 + }, + { + "word": "to", + "start": 690.84, + "end": 691.02 + }, + { + "word": "this", + "start": 691.02, + "end": 691.2 + }, + { + "word": "later.", + "start": 691.2, + "end": 691.58 + }, + { + "word": "You", + "start": 691.62, + "end": 691.78 + }, + { + "word": "can", + "start": 691.78, + "end": 691.98 + }, + { + "word": "kind", + "start": 691.98, + "end": 692.18 + }, + { + "word": "of", + "start": 692.18, + "end": 692.18 + }, + { + "word": "look", + "start": 692.18, + "end": 692.3 + }, + { + "word": "at", + "start": 692.3, + "end": 692.46 + } + ] + }, + { + "start": 692.46, + "end": 696.68, + "text": "it. I mean, this is only 60 lines of code. It's like not much. And most of it is just", + "words": [ + { + "word": "it.", + "start": 692.46, + "end": 692.7 + }, + { + "word": "I", + "start": 692.94, + "end": 692.96 + }, + { + "word": "mean,", + "start": 692.96, + "end": 693.08 + }, + { + "word": "this", + "start": 693.08, + "end": 693.22 + }, + { + "word": "is", + "start": 693.22, + "end": 693.38 + }, + { + "word": "only", + "start": 693.38, + "end": 694.04 + }, + { + "word": "60", + "start": 694.04, + "end": 694.44 + }, + { + "word": "lines", + "start": 694.44, + "end": 694.7 + }, + { + "word": "of", + "start": 694.7, + "end": 694.84 + }, + { + "word": "code.", + "start": 694.84, + "end": 695.08 + }, + { + "word": "It's", + "start": 695.2, + "end": 695.32 + }, + { + "word": "like", + "start": 695.32, + "end": 695.46 + }, + { + "word": "not", + "start": 695.46, + "end": 695.58 + }, + { + "word": "much.", + "start": 695.58, + "end": 695.86 + }, + { + "word": "And", + "start": 695.9, + "end": 696.04 + }, + { + "word": "most", + "start": 696.04, + "end": 696.16 + }, + { + "word": "of", + "start": 696.16, + "end": 696.28 + }, + { + "word": "it", + "start": 696.28, + "end": 696.4 + }, + { + "word": "is", + "start": 696.4, + "end": 696.62 + }, + { + "word": "just", + "start": 696.62, + "end": 696.68 + } + ] + }, + { + "start": 696.68, + "end": 703.04, + "text": "like weird JavaScript faffing. So yeah, I'll give you a link to that later. But the point", + "words": [ + { + "word": "like", + "start": 696.68, + "end": 696.86 + }, + { + "word": "weird", + "start": 696.86, + "end": 697.08 + }, + { + "word": "JavaScript", + "start": 697.08, + "end": 697.54 + }, + { + "word": "faffing.", + "start": 697.54, + "end": 698.18 + }, + { + "word": "So", + "start": 700.04, + "end": 700.44 + }, + { + "word": "yeah,", + "start": 700.44, + "end": 700.86 + }, + { + "word": "I'll", + "start": 701.08, + "end": 701.26 + }, + { + "word": "give", + "start": 701.26, + "end": 701.36 + }, + { + "word": "you", + "start": 701.36, + "end": 701.46 + }, + { + "word": "a", + "start": 701.46, + "end": 701.52 + }, + { + "word": "link", + "start": 701.52, + "end": 701.58 + }, + { + "word": "to", + "start": 701.58, + "end": 701.74 + }, + { + "word": "that", + "start": 701.74, + "end": 701.88 + }, + { + "word": "later.", + "start": 701.88, + "end": 702.14 + }, + { + "word": "But", + "start": 702.32, + "end": 702.46 + }, + { + "word": "the", + "start": 702.46, + "end": 702.8 + }, + { + "word": "point", + "start": 702.8, + "end": 703.04 + } + ] + }, + { + "start": 703.04, + "end": 711.88, + "text": "is I wanted to make it really, really simple to interact with it. Oh, no. Sorry. One second.", + "words": [ + { + "word": "is", + "start": 703.04, + "end": 703.44 + }, + { + "word": "I", + "start": 703.44, + "end": 703.88 + }, + { + "word": "wanted", + "start": 703.88, + "end": 704.12 + }, + { + "word": "to", + "start": 704.12, + "end": 704.26 + }, + { + "word": "make", + "start": 704.26, + "end": 704.34 + }, + { + "word": "it", + "start": 704.34, + "end": 704.54 + }, + { + "word": "really,", + "start": 704.54, + "end": 704.86 + }, + { + "word": "really", + "start": 704.86, + "end": 705.26 + }, + { + "word": "simple", + "start": 705.26, + "end": 705.76 + }, + { + "word": "to", + "start": 705.76, + "end": 706.54 + }, + { + "word": "interact", + "start": 706.54, + "end": 706.84 + }, + { + "word": "with", + "start": 706.84, + "end": 707.04 + }, + { + "word": "it.", + "start": 707.04, + "end": 707.98 + }, + { + "word": "Oh,", + "start": 708.74, + "end": 709.14 + }, + { + "word": "no.", + "start": 709.14, + "end": 709.78 + }, + { + "word": "Sorry.", + "start": 711.1, + "end": 711.36 + }, + { + "word": "One", + "start": 711.46, + "end": 711.52 + }, + { + "word": "second.", + "start": 711.52, + "end": 711.88 + } + ] + }, + { + "start": 714.24, + "end": 720.88, + "text": "Don't want to lose my slides. Cool. So let me give you an overview of the project. So", + "words": [ + { + "word": "Don't", + "start": 714.24, + "end": 714.46 + }, + { + "word": "want", + "start": 714.46, + "end": 714.6 + }, + { + "word": "to", + "start": 714.6, + "end": 714.7 + }, + { + "word": "lose", + "start": 714.7, + "end": 714.8 + }, + { + "word": "my", + "start": 714.8, + "end": 714.94 + }, + { + "word": "slides.", + "start": 714.94, + "end": 715.22 + }, + { + "word": "Cool.", + "start": 717.4, + "end": 717.6 + }, + { + "word": "So", + "start": 717.92, + "end": 718.22 + }, + { + "word": "let", + "start": 718.22, + "end": 718.34 + }, + { + "word": "me", + "start": 718.34, + "end": 718.44 + }, + { + "word": "give", + "start": 718.44, + "end": 718.52 + }, + { + "word": "you", + "start": 718.52, + "end": 718.6 + }, + { + "word": "an", + "start": 718.6, + "end": 718.78 + }, + { + "word": "overview", + "start": 718.78, + "end": 719.0 + }, + { + "word": "of", + "start": 719.0, + "end": 719.18 + }, + { + "word": "the", + "start": 719.18, + "end": 719.28 + }, + { + "word": "project.", + "start": 719.28, + "end": 719.68 + }, + { + "word": "So", + "start": 720.64, + "end": 720.88 + } + ] + }, + { + "start": 720.88, + "end": 728.18, + "text": "the core of the project is written in Rust. What I really wanted was like a layer to take", + "words": [ + { + "word": "the", + "start": 720.88, + "end": 721.08 + }, + { + "word": "core", + "start": 721.08, + "end": 721.42 + }, + { + "word": "of", + "start": 721.42, + "end": 721.62 + }, + { + "word": "the", + "start": 721.62, + "end": 721.84 + }, + { + "word": "project", + "start": 721.84, + "end": 722.26 + }, + { + "word": "is", + "start": 722.26, + "end": 722.76 + }, + { + "word": "written", + "start": 722.76, + "end": 722.92 + }, + { + "word": "in", + "start": 722.92, + "end": 723.1 + }, + { + "word": "Rust.", + "start": 723.1, + "end": 723.38 + }, + { + "word": "What", + "start": 724.08, + "end": 724.2 + }, + { + "word": "I", + "start": 724.2, + "end": 724.34 + }, + { + "word": "really", + "start": 724.34, + "end": 724.54 + }, + { + "word": "wanted", + "start": 724.54, + "end": 725.0 + }, + { + "word": "was", + "start": 725.0, + "end": 725.58 + }, + { + "word": "like", + "start": 725.58, + "end": 726.06 + }, + { + "word": "a", + "start": 726.06, + "end": 727.4 + }, + { + "word": "layer", + "start": 727.4, + "end": 727.72 + }, + { + "word": "to", + "start": 727.72, + "end": 728.0 + }, + { + "word": "take", + "start": 728.0, + "end": 728.18 + } + ] + }, + { + "start": 728.18, + "end": 734.68, + "text": "care of all the operating system interactions that was like tight and simple and easy to", + "words": [ + { + "word": "care", + "start": 728.18, + "end": 728.4 + }, + { + "word": "of", + "start": 728.4, + "end": 728.54 + }, + { + "word": "all", + "start": 728.54, + "end": 728.74 + }, + { + "word": "the", + "start": 728.74, + "end": 728.98 + }, + { + "word": "operating", + "start": 728.98, + "end": 729.34 + }, + { + "word": "system", + "start": 729.34, + "end": 729.72 + }, + { + "word": "interactions", + "start": 729.72, + "end": 730.4 + }, + { + "word": "that", + "start": 730.4, + "end": 731.36 + }, + { + "word": "was", + "start": 731.36, + "end": 732.48 + }, + { + "word": "like", + "start": 732.48, + "end": 732.7 + }, + { + "word": "tight", + "start": 732.7, + "end": 732.98 + }, + { + "word": "and", + "start": 732.98, + "end": 733.34 + }, + { + "word": "simple", + "start": 733.34, + "end": 733.7 + }, + { + "word": "and", + "start": 733.7, + "end": 734.0 + }, + { + "word": "easy", + "start": 734.0, + "end": 734.44 + }, + { + "word": "to", + "start": 734.44, + "end": 734.68 + } + ] + }, + { + "start": 734.68, + "end": 741.8, + "text": "reason about and that I could distribute very simply. And then on top of that, I could build", + "words": [ + { + "word": "reason", + "start": 734.68, + "end": 734.86 + }, + { + "word": "about", + "start": 734.86, + "end": 735.5 + }, + { + "word": "and", + "start": 735.5, + "end": 736.36 + }, + { + "word": "that", + "start": 736.36, + "end": 736.74 + }, + { + "word": "I", + "start": 736.74, + "end": 736.82 + }, + { + "word": "could", + "start": 736.82, + "end": 737.04 + }, + { + "word": "distribute", + "start": 737.04, + "end": 737.64 + }, + { + "word": "very", + "start": 737.64, + "end": 738.18 + }, + { + "word": "simply.", + "start": 738.18, + "end": 738.68 + }, + { + "word": "And", + "start": 739.3, + "end": 739.44 + }, + { + "word": "then", + "start": 739.44, + "end": 740.04 + }, + { + "word": "on", + "start": 740.04, + "end": 740.48 + }, + { + "word": "top", + "start": 740.48, + "end": 740.62 + }, + { + "word": "of", + "start": 740.62, + "end": 740.78 + }, + { + "word": "that,", + "start": 740.78, + "end": 740.98 + }, + { + "word": "I", + "start": 740.98, + "end": 741.08 + }, + { + "word": "could", + "start": 741.08, + "end": 741.26 + }, + { + "word": "build", + "start": 741.26, + "end": 741.8 + } + ] + }, + { + "start": 741.8, + "end": 746.46, + "text": "clients to interact with it. And I wanted this whole setup to be as simple as possible.", + "words": [ + { + "word": "clients", + "start": 741.8, + "end": 742.34 + }, + { + "word": "to", + "start": 742.34, + "end": 742.62 + }, + { + "word": "interact", + "start": 742.62, + "end": 742.88 + }, + { + "word": "with", + "start": 742.88, + "end": 743.04 + }, + { + "word": "it.", + "start": 743.04, + "end": 743.24 + }, + { + "word": "And", + "start": 743.24, + "end": 743.42 + }, + { + "word": "I", + "start": 743.42, + "end": 743.74 + }, + { + "word": "wanted", + "start": 743.74, + "end": 743.94 + }, + { + "word": "this", + "start": 743.94, + "end": 744.22 + }, + { + "word": "whole", + "start": 744.22, + "end": 744.42 + }, + { + "word": "setup", + "start": 744.42, + "end": 744.62 + }, + { + "word": "to", + "start": 744.62, + "end": 744.84 + }, + { + "word": "be", + "start": 744.84, + "end": 745.04 + }, + { + "word": "as", + "start": 745.04, + "end": 745.42 + }, + { + "word": "simple", + "start": 745.42, + "end": 745.74 + }, + { + "word": "as", + "start": 745.74, + "end": 746.1 + }, + { + "word": "possible.", + "start": 746.1, + "end": 746.46 + } + ] + }, + { + "start": 747.08, + "end": 751.64, + "text": "My dream for this is what if I could just write a desktop app in a bash shell? What", + "words": [ + { + "word": "My", + "start": 747.08, + "end": 747.56 + }, + { + "word": "dream", + "start": 747.56, + "end": 747.92 + }, + { + "word": "for", + "start": 747.92, + "end": 748.12 + }, + { + "word": "this", + "start": 748.12, + "end": 748.28 + }, + { + "word": "is", + "start": 748.28, + "end": 748.48 + }, + { + "word": "what", + "start": 748.48, + "end": 748.72 + }, + { + "word": "if", + "start": 748.72, + "end": 748.86 + }, + { + "word": "I", + "start": 748.86, + "end": 748.94 + }, + { + "word": "could", + "start": 748.94, + "end": 749.04 + }, + { + "word": "just", + "start": 749.04, + "end": 749.56 + }, + { + "word": "write", + "start": 749.56, + "end": 749.76 + }, + { + "word": "a", + "start": 749.76, + "end": 750.16 + }, + { + "word": "desktop", + "start": 750.16, + "end": 750.46 + }, + { + "word": "app", + "start": 750.46, + "end": 750.66 + }, + { + "word": "in", + "start": 750.66, + "end": 750.8 + }, + { + "word": "a", + "start": 750.8, + "end": 750.92 + }, + { + "word": "bash", + "start": 750.92, + "end": 751.12 + }, + { + "word": "shell?", + "start": 751.12, + "end": 751.34 + }, + { + "word": "What", + "start": 751.48, + "end": 751.64 + } + ] + }, + { + "start": 751.64, + "end": 759.82, + "text": "would that look like? Can I make it that easy? So the Rust binary uses these two crates called", + "words": [ + { + "word": "would", + "start": 751.64, + "end": 751.72 + }, + { + "word": "that", + "start": 751.72, + "end": 751.92 + }, + { + "word": "look", + "start": 751.92, + "end": 752.06 + }, + { + "word": "like?", + "start": 752.06, + "end": 752.32 + }, + { + "word": "Can", + "start": 752.44, + "end": 752.6 + }, + { + "word": "I", + "start": 752.6, + "end": 753.12 + }, + { + "word": "make", + "start": 753.12, + "end": 753.24 + }, + { + "word": "it", + "start": 753.24, + "end": 753.46 + }, + { + "word": "that", + "start": 753.46, + "end": 753.74 + }, + { + "word": "easy?", + "start": 753.74, + "end": 754.18 + }, + { + "word": "So", + "start": 755.64, + "end": 756.08 + }, + { + "word": "the", + "start": 756.08, + "end": 756.36 + }, + { + "word": "Rust", + "start": 756.36, + "end": 756.74 + }, + { + "word": "binary", + "start": 756.74, + "end": 757.38 + }, + { + "word": "uses", + "start": 757.38, + "end": 758.3 + }, + { + "word": "these", + "start": 758.3, + "end": 758.92 + }, + { + "word": "two", + "start": 758.92, + "end": 759.12 + }, + { + "word": "crates", + "start": 759.12, + "end": 759.42 + }, + { + "word": "called", + "start": 759.42, + "end": 759.82 + } + ] + }, + { + "start": 759.82, + "end": 763.82, + "text": "Rye and Tau. These are from the TauRe project. If you haven't heard of TauRe, definitely", + "words": [ + { + "word": "Rye", + "start": 759.82, + "end": 760.08 + }, + { + "word": "and", + "start": 760.08, + "end": 760.28 + }, + { + "word": "Tau.", + "start": 760.28, + "end": 760.44 + }, + { + "word": "These", + "start": 760.68, + "end": 760.92 + }, + { + "word": "are", + "start": 760.92, + "end": 761.0 + }, + { + "word": "from", + "start": 761.0, + "end": 761.18 + }, + { + "word": "the", + "start": 761.18, + "end": 761.34 + }, + { + "word": "TauRe", + "start": 761.34, + "end": 761.58 + }, + { + "word": "project.", + "start": 761.58, + "end": 762.06 + }, + { + "word": "If", + "start": 762.14, + "end": 762.24 + }, + { + "word": "you", + "start": 762.24, + "end": 762.36 + }, + { + "word": "haven't", + "start": 762.36, + "end": 762.48 + }, + { + "word": "heard", + "start": 762.48, + "end": 762.62 + }, + { + "word": "of", + "start": 762.62, + "end": 762.68 + }, + { + "word": "TauRe,", + "start": 762.68, + "end": 763.22 + }, + { + "word": "definitely", + "start": 763.58, + "end": 763.82 + } + ] + }, + { + "start": 763.82, + "end": 770.4, + "text": "check it out. It is the blessed electron alternative, I would say. And the Rust crowd will like", + "words": [ + { + "word": "check", + "start": 763.82, + "end": 764.0 + }, + { + "word": "it", + "start": 764.0, + "end": 764.18 + }, + { + "word": "out.", + "start": 764.18, + "end": 764.34 + }, + { + "word": "It", + "start": 764.36, + "end": 764.5 + }, + { + "word": "is", + "start": 764.5, + "end": 764.86 + }, + { + "word": "the", + "start": 764.86, + "end": 765.76 + }, + { + "word": "blessed", + "start": 765.76, + "end": 766.08 + }, + { + "word": "electron", + "start": 766.08, + "end": 766.88 + }, + { + "word": "alternative,", + "start": 766.88, + "end": 767.62 + }, + { + "word": "I", + "start": 767.62, + "end": 767.74 + }, + { + "word": "would", + "start": 767.74, + "end": 767.94 + }, + { + "word": "say.", + "start": 767.94, + "end": 768.72 + }, + { + "word": "And", + "start": 769.16, + "end": 769.58 + }, + { + "word": "the", + "start": 769.58, + "end": 769.74 + }, + { + "word": "Rust", + "start": 769.74, + "end": 769.88 + }, + { + "word": "crowd", + "start": 769.88, + "end": 770.1 + }, + { + "word": "will", + "start": 770.1, + "end": 770.3 + }, + { + "word": "like", + "start": 770.3, + "end": 770.4 + } + ] + }, + { + "start": 770.4, + "end": 777.06, + "text": "it. But they also have just really good primitives. So if you kind of want to do your own stuff", + "words": [ + { + "word": "it.", + "start": 770.4, + "end": 771.02 + }, + { + "word": "But", + "start": 771.96, + "end": 772.4 + }, + { + "word": "they", + "start": 772.4, + "end": 773.36 + }, + { + "word": "also", + "start": 773.36, + "end": 773.82 + }, + { + "word": "have", + "start": 773.82, + "end": 774.22 + }, + { + "word": "just", + "start": 774.22, + "end": 774.56 + }, + { + "word": "really", + "start": 774.56, + "end": 774.86 + }, + { + "word": "good", + "start": 774.86, + "end": 775.14 + }, + { + "word": "primitives.", + "start": 775.14, + "end": 775.58 + }, + { + "word": "So", + "start": 775.66, + "end": 775.8 + }, + { + "word": "if", + "start": 775.8, + "end": 775.88 + }, + { + "word": "you", + "start": 775.88, + "end": 776.0 + }, + { + "word": "kind", + "start": 776.0, + "end": 776.04 + }, + { + "word": "of", + "start": 776.04, + "end": 776.12 + }, + { + "word": "want", + "start": 776.12, + "end": 776.22 + }, + { + "word": "to", + "start": 776.22, + "end": 776.36 + }, + { + "word": "do", + "start": 776.36, + "end": 776.46 + }, + { + "word": "your", + "start": 776.46, + "end": 776.62 + }, + { + "word": "own", + "start": 776.62, + "end": 776.78 + }, + { + "word": "stuff", + "start": 776.78, + "end": 777.06 + } + ] + }, + { + "start": 777.06, + "end": 783.36, + "text": "and break out of the framework, these crates are fantastic. So Rye helps interact with", + "words": [ + { + "word": "and", + "start": 777.06, + "end": 777.24 + }, + { + "word": "break", + "start": 777.24, + "end": 777.56 + }, + { + "word": "out", + "start": 777.56, + "end": 777.68 + }, + { + "word": "of", + "start": 777.68, + "end": 777.78 + }, + { + "word": "the", + "start": 777.78, + "end": 777.9 + }, + { + "word": "framework,", + "start": 777.9, + "end": 778.14 + }, + { + "word": "these", + "start": 778.3, + "end": 778.52 + }, + { + "word": "crates", + "start": 778.52, + "end": 778.68 + }, + { + "word": "are", + "start": 778.68, + "end": 778.86 + }, + { + "word": "fantastic.", + "start": 778.86, + "end": 779.48 + }, + { + "word": "So", + "start": 780.34, + "end": 780.6 + }, + { + "word": "Rye", + "start": 780.6, + "end": 781.12 + }, + { + "word": "helps", + "start": 781.12, + "end": 782.12 + }, + { + "word": "interact", + "start": 782.12, + "end": 782.76 + }, + { + "word": "with", + "start": 782.76, + "end": 783.36 + } + ] + }, + { + "start": 783.36, + "end": 787.48, + "text": "the WebView, the native WebView binding for whatever operating system you're on. And Tau", + "words": [ + { + "word": "the", + "start": 783.36, + "end": 783.7 + }, + { + "word": "WebView,", + "start": 783.7, + "end": 784.16 + }, + { + "word": "the", + "start": 784.24, + "end": 784.48 + }, + { + "word": "native", + "start": 784.48, + "end": 784.7 + }, + { + "word": "WebView", + "start": 784.7, + "end": 785.02 + }, + { + "word": "binding", + "start": 785.02, + "end": 785.34 + }, + { + "word": "for", + "start": 785.34, + "end": 785.56 + }, + { + "word": "whatever", + "start": 785.56, + "end": 785.78 + }, + { + "word": "operating", + "start": 785.78, + "end": 786.12 + }, + { + "word": "system", + "start": 786.12, + "end": 786.36 + }, + { + "word": "you're", + "start": 786.36, + "end": 786.6 + }, + { + "word": "on.", + "start": 786.6, + "end": 786.86 + }, + { + "word": "And", + "start": 787.14, + "end": 787.34 + }, + { + "word": "Tau", + "start": 787.34, + "end": 787.48 + } + ] + }, + { + "start": 787.48, + "end": 794.1, + "text": "is a window manager. They're fantastic. So the clients, like the TypeScript client and", + "words": [ + { + "word": "is", + "start": 787.48, + "end": 787.6 + }, + { + "word": "a", + "start": 787.6, + "end": 787.76 + }, + { + "word": "window", + "start": 787.76, + "end": 787.96 + }, + { + "word": "manager.", + "start": 787.96, + "end": 788.28 + }, + { + "word": "They're", + "start": 789.6, + "end": 790.12 + }, + { + "word": "fantastic.", + "start": 790.12, + "end": 790.58 + }, + { + "word": "So", + "start": 791.52, + "end": 791.94 + }, + { + "word": "the", + "start": 791.94, + "end": 792.28 + }, + { + "word": "clients,", + "start": 792.28, + "end": 792.62 + }, + { + "word": "like", + "start": 792.9, + "end": 793.06 + }, + { + "word": "the", + "start": 793.06, + "end": 793.28 + }, + { + "word": "TypeScript", + "start": 793.28, + "end": 793.54 + }, + { + "word": "client", + "start": 793.54, + "end": 793.9 + }, + { + "word": "and", + "start": 793.9, + "end": 794.1 + } + ] + }, + { + "start": 794.1, + "end": 799.68, + "text": "I have a Python client and a Go client that's in a PR, actually just communicate with this", + "words": [ + { + "word": "I", + "start": 794.1, + "end": 794.18 + }, + { + "word": "have", + "start": 794.18, + "end": 794.28 + }, + { + "word": "a", + "start": 794.28, + "end": 794.36 + }, + { + "word": "Python", + "start": 794.36, + "end": 794.62 + }, + { + "word": "client", + "start": 794.62, + "end": 795.0 + }, + { + "word": "and", + "start": 795.0, + "end": 795.6 + }, + { + "word": "a", + "start": 795.6, + "end": 795.8 + }, + { + "word": "Go", + "start": 795.8, + "end": 795.94 + }, + { + "word": "client", + "start": 795.94, + "end": 796.22 + }, + { + "word": "that's", + "start": 796.22, + "end": 796.48 + }, + { + "word": "in", + "start": 796.48, + "end": 796.58 + }, + { + "word": "a", + "start": 796.58, + "end": 796.74 + }, + { + "word": "PR,", + "start": 796.74, + "end": 797.12 + }, + { + "word": "actually", + "start": 798.06, + "end": 798.36 + }, + { + "word": "just", + "start": 798.36, + "end": 798.66 + }, + { + "word": "communicate", + "start": 798.66, + "end": 799.14 + }, + { + "word": "with", + "start": 799.14, + "end": 799.42 + }, + { + "word": "this", + "start": 799.42, + "end": 799.68 + } + ] + }, + { + "start": 799.68, + "end": 805.3, + "text": "So I'm going to use the Rust binary over standard in, standard out, just using JSON RPC. It's", + "words": [ + { + "word": "So", + "start": 799.68, + "end": 799.68 + }, + { + "word": "I'm", + "start": 799.68, + "end": 799.68 + }, + { + "word": "going", + "start": 799.68, + "end": 799.68 + }, + { + "word": "to", + "start": 799.68, + "end": 799.68 + }, + { + "word": "use", + "start": 799.68, + "end": 799.68 + }, + { + "word": "the", + "start": 799.68, + "end": 799.68 + }, + { + "word": "Rust", + "start": 799.68, + "end": 799.82 + }, + { + "word": "binary", + "start": 799.82, + "end": 800.48 + }, + { + "word": "over", + "start": 800.48, + "end": 801.38 + }, + { + "word": "standard", + "start": 801.38, + "end": 801.64 + }, + { + "word": "in,", + "start": 801.64, + "end": 801.84 + }, + { + "word": "standard", + "start": 801.84, + "end": 801.98 + }, + { + "word": "out,", + "start": 801.98, + "end": 802.24 + }, + { + "word": "just", + "start": 802.36, + "end": 802.54 + }, + { + "word": "using", + "start": 802.54, + "end": 802.96 + }, + { + "word": "JSON", + "start": 802.96, + "end": 803.5 + }, + { + "word": "RPC.", + "start": 803.5, + "end": 804.02 + }, + { + "word": "It's", + "start": 804.78, + "end": 805.3 + } + ] + }, + { + "start": 805.3, + "end": 812.4, + "text": "really, really simple. Where the code generation part comes in is the data structures for the", + "words": [ + { + "word": "really,", + "start": 805.3, + "end": 805.82 + }, + { + "word": "really", + "start": 805.82, + "end": 806.02 + }, + { + "word": "simple.", + "start": 806.02, + "end": 806.42 + }, + { + "word": "Where", + "start": 807.16, + "end": 807.48 + }, + { + "word": "the", + "start": 807.48, + "end": 808.12 + }, + { + "word": "code", + "start": 808.12, + "end": 808.32 + }, + { + "word": "generation", + "start": 808.32, + "end": 808.78 + }, + { + "word": "part", + "start": 808.78, + "end": 809.04 + }, + { + "word": "comes", + "start": 809.04, + "end": 809.34 + }, + { + "word": "in", + "start": 809.34, + "end": 809.76 + }, + { + "word": "is", + "start": 809.76, + "end": 810.28 + }, + { + "word": "the", + "start": 810.28, + "end": 810.94 + }, + { + "word": "data", + "start": 810.94, + "end": 811.16 + }, + { + "word": "structures", + "start": 811.16, + "end": 811.68 + }, + { + "word": "for", + "start": 811.68, + "end": 812.16 + }, + { + "word": "the", + "start": 812.16, + "end": 812.4 + } + ] + }, + { + "start": 812.4, + "end": 816.52, + "text": "messages that pass back and forth over standard in, standard out are all defined in my Rust code.", + "words": [ + { + "word": "messages", + "start": 812.4, + "end": 812.74 + }, + { + "word": "that", + "start": 812.74, + "end": 813.04 + }, + { + "word": "pass", + "start": 813.04, + "end": 813.28 + }, + { + "word": "back", + "start": 813.28, + "end": 813.64 + }, + { + "word": "and", + "start": 813.64, + "end": 813.8 + }, + { + "word": "forth", + "start": 813.8, + "end": 813.92 + }, + { + "word": "over", + "start": 813.92, + "end": 814.12 + }, + { + "word": "standard", + "start": 814.12, + "end": 814.36 + }, + { + "word": "in,", + "start": 814.36, + "end": 814.54 + }, + { + "word": "standard", + "start": 814.6, + "end": 814.74 + }, + { + "word": "out", + "start": 814.74, + "end": 814.96 + }, + { + "word": "are", + "start": 814.96, + "end": 815.14 + }, + { + "word": "all", + "start": 815.14, + "end": 815.36 + }, + { + "word": "defined", + "start": 815.36, + "end": 815.58 + }, + { + "word": "in", + "start": 815.58, + "end": 815.72 + }, + { + "word": "my", + "start": 815.72, + "end": 815.88 + }, + { + "word": "Rust", + "start": 815.88, + "end": 816.12 + }, + { + "word": "code.", + "start": 816.12, + "end": 816.52 + } + ] + }, + { + "start": 817.18, + "end": 822.52, + "text": "So it defines the sort of source of truth of what the messages look like. And for every client that", + "words": [ + { + "word": "So", + "start": 817.18, + "end": 817.54 + }, + { + "word": "it", + "start": 817.54, + "end": 817.76 + }, + { + "word": "defines", + "start": 817.76, + "end": 818.24 + }, + { + "word": "the", + "start": 818.24, + "end": 818.56 + }, + { + "word": "sort", + "start": 818.56, + "end": 818.56 + }, + { + "word": "of", + "start": 818.56, + "end": 818.8 + }, + { + "word": "source", + "start": 818.8, + "end": 818.98 + }, + { + "word": "of", + "start": 818.98, + "end": 819.18 + }, + { + "word": "truth", + "start": 819.18, + "end": 819.4 + }, + { + "word": "of", + "start": 819.4, + "end": 819.66 + }, + { + "word": "what", + "start": 819.66, + "end": 819.86 + }, + { + "word": "the", + "start": 819.86, + "end": 820.1 + }, + { + "word": "messages", + "start": 820.1, + "end": 820.34 + }, + { + "word": "look", + "start": 820.34, + "end": 820.6 + }, + { + "word": "like.", + "start": 820.6, + "end": 820.96 + }, + { + "word": "And", + "start": 821.22, + "end": 821.36 + }, + { + "word": "for", + "start": 821.36, + "end": 821.6 + }, + { + "word": "every", + "start": 821.6, + "end": 821.88 + }, + { + "word": "client", + "start": 821.88, + "end": 822.3 + }, + { + "word": "that", + "start": 822.3, + "end": 822.52 + } + ] + }, + { + "start": 822.52, + "end": 827.7, + "text": "I add, it generates out the data structures and the patterns needed to send those messages back", + "words": [ + { + "word": "I", + "start": 822.52, + "end": 822.74 + }, + { + "word": "add,", + "start": 822.74, + "end": 823.2 + }, + { + "word": "it", + "start": 823.66, + "end": 823.84 + }, + { + "word": "generates", + "start": 823.84, + "end": 824.26 + }, + { + "word": "out", + "start": 824.26, + "end": 824.6 + }, + { + "word": "the", + "start": 824.6, + "end": 824.78 + }, + { + "word": "data", + "start": 824.78, + "end": 824.96 + }, + { + "word": "structures", + "start": 824.96, + "end": 825.5 + }, + { + "word": "and", + "start": 825.5, + "end": 825.7 + }, + { + "word": "the", + "start": 825.7, + "end": 825.9 + }, + { + "word": "patterns", + "start": 825.9, + "end": 826.18 + }, + { + "word": "needed", + "start": 826.18, + "end": 826.56 + }, + { + "word": "to", + "start": 826.56, + "end": 826.78 + }, + { + "word": "send", + "start": 826.78, + "end": 826.92 + }, + { + "word": "those", + "start": 826.92, + "end": 827.2 + }, + { + "word": "messages", + "start": 827.2, + "end": 827.46 + }, + { + "word": "back", + "start": 827.46, + "end": 827.7 + } + ] + }, + { + "start": 827.7, + "end": 831.64, + "text": "and forth. So if I'm adding a new client, it's really just thinking about like, how do I adapt", + "words": [ + { + "word": "and", + "start": 827.7, + "end": 827.84 + }, + { + "word": "forth.", + "start": 827.84, + "end": 828.08 + }, + { + "word": "So", + "start": 828.16, + "end": 828.56 + }, + { + "word": "if", + "start": 828.56, + "end": 828.72 + }, + { + "word": "I'm", + "start": 828.72, + "end": 828.82 + }, + { + "word": "adding", + "start": 828.82, + "end": 829.04 + }, + { + "word": "a", + "start": 829.04, + "end": 829.18 + }, + { + "word": "new", + "start": 829.18, + "end": 829.32 + }, + { + "word": "client,", + "start": 829.32, + "end": 829.6 + }, + { + "word": "it's", + "start": 829.7, + "end": 829.78 + }, + { + "word": "really", + "start": 829.78, + "end": 829.96 + }, + { + "word": "just", + "start": 829.96, + "end": 830.14 + }, + { + "word": "thinking", + "start": 830.14, + "end": 830.34 + }, + { + "word": "about", + "start": 830.34, + "end": 830.58 + }, + { + "word": "like,", + "start": 830.58, + "end": 831.12 + }, + { + "word": "how", + "start": 831.18, + "end": 831.24 + }, + { + "word": "do", + "start": 831.24, + "end": 831.4 + }, + { + "word": "I", + "start": 831.4, + "end": 831.56 + }, + { + "word": "adapt", + "start": 831.56, + "end": 831.64 + } + ] + }, + { + "start": 831.64, + "end": 836.98, + "text": "my generators to like generate this new, these new data structures and then the small bit of", + "words": [ + { + "word": "my", + "start": 831.64, + "end": 831.9 + }, + { + "word": "generators", + "start": 831.9, + "end": 832.34 + }, + { + "word": "to", + "start": 832.34, + "end": 832.72 + }, + { + "word": "like", + "start": 832.72, + "end": 832.92 + }, + { + "word": "generate", + "start": 832.92, + "end": 833.18 + }, + { + "word": "this", + "start": 833.18, + "end": 833.44 + }, + { + "word": "new,", + "start": 833.44, + "end": 833.88 + }, + { + "word": "these", + "start": 834.06, + "end": 834.24 + }, + { + "word": "new", + "start": 834.24, + "end": 834.4 + }, + { + "word": "data", + "start": 834.4, + "end": 834.58 + }, + { + "word": "structures", + "start": 834.58, + "end": 835.02 + }, + { + "word": "and", + "start": 835.02, + "end": 835.28 + }, + { + "word": "then", + "start": 835.28, + "end": 835.74 + }, + { + "word": "the", + "start": 835.74, + "end": 836.26 + }, + { + "word": "small", + "start": 836.26, + "end": 836.52 + }, + { + "word": "bit", + "start": 836.52, + "end": 836.7 + }, + { + "word": "of", + "start": 836.7, + "end": 836.98 + } + ] + }, + { + "start": 836.98, + "end": 845.18, + "text": "wrapping code that I need to actually make the application work. Oh, is my zoom going to work?", + "words": [ + { + "word": "wrapping", + "start": 836.98, + "end": 837.2 + }, + { + "word": "code", + "start": 837.2, + "end": 837.48 + }, + { + "word": "that", + "start": 837.48, + "end": 837.64 + }, + { + "word": "I", + "start": 837.64, + "end": 837.78 + }, + { + "word": "need", + "start": 837.78, + "end": 837.86 + }, + { + "word": "to", + "start": 837.86, + "end": 838.06 + }, + { + "word": "actually", + "start": 838.06, + "end": 838.24 + }, + { + "word": "make", + "start": 838.24, + "end": 838.42 + }, + { + "word": "the", + "start": 838.42, + "end": 838.7 + }, + { + "word": "application", + "start": 838.7, + "end": 839.1 + }, + { + "word": "work.", + "start": 839.1, + "end": 840.1 + }, + { + "word": "Oh,", + "start": 843.72, + "end": 844.12 + }, + { + "word": "is", + "start": 844.34, + "end": 844.5 + }, + { + "word": "my", + "start": 844.5, + "end": 844.58 + }, + { + "word": "zoom", + "start": 844.58, + "end": 844.66 + }, + { + "word": "going", + "start": 844.66, + "end": 844.8 + }, + { + "word": "to", + "start": 844.8, + "end": 844.92 + }, + { + "word": "work?", + "start": 844.92, + "end": 845.18 + } + ] + }, + { + "start": 846.48, + "end": 851.92, + "text": "It's really annoys me that this was working earlier. But so I know this is a little bit small,", + "words": [ + { + "word": "It's", + "start": 846.48, + "end": 846.88 + }, + { + "word": "really", + "start": 846.88, + "end": 847.22 + }, + { + "word": "annoys", + "start": 847.22, + "end": 847.5 + }, + { + "word": "me", + "start": 847.5, + "end": 847.72 + }, + { + "word": "that", + "start": 847.72, + "end": 847.84 + }, + { + "word": "this", + "start": 847.84, + "end": 848.06 + }, + { + "word": "was", + "start": 848.06, + "end": 848.2 + }, + { + "word": "working", + "start": 848.2, + "end": 848.7 + }, + { + "word": "earlier.", + "start": 848.7, + "end": 849.18 + }, + { + "word": "But", + "start": 849.36, + "end": 849.64 + }, + { + "word": "so", + "start": 849.64, + "end": 850.56 + }, + { + "word": "I", + "start": 850.56, + "end": 850.76 + }, + { + "word": "know", + "start": 850.76, + "end": 850.84 + }, + { + "word": "this", + "start": 850.84, + "end": 851.0 + }, + { + "word": "is", + "start": 851.0, + "end": 851.14 + }, + { + "word": "a", + "start": 851.14, + "end": 851.24 + }, + { + "word": "little", + "start": 851.24, + "end": 851.34 + }, + { + "word": "bit", + "start": 851.34, + "end": 851.52 + }, + { + "word": "small,", + "start": 851.52, + "end": 851.92 + } + ] + }, + { + "start": 852.48, + "end": 856.86, + "text": "but I'll just kind of go through like what the data flow is to the application. This is a bit", + "words": [ + { + "word": "but", + "start": 852.48, + "end": 852.88 + }, + { + "word": "I'll", + "start": 852.88, + "end": 853.28 + }, + { + "word": "just", + "start": 853.28, + "end": 853.48 + }, + { + "word": "kind", + "start": 853.48, + "end": 853.62 + }, + { + "word": "of", + "start": 853.62, + "end": 853.68 + }, + { + "word": "go", + "start": 853.68, + "end": 853.84 + }, + { + "word": "through", + "start": 853.84, + "end": 854.1 + }, + { + "word": "like", + "start": 854.1, + "end": 854.32 + }, + { + "word": "what", + "start": 854.32, + "end": 854.58 + }, + { + "word": "the", + "start": 854.58, + "end": 855.06 + }, + { + "word": "data", + "start": 855.06, + "end": 855.4 + }, + { + "word": "flow", + "start": 855.4, + "end": 855.54 + }, + { + "word": "is", + "start": 855.54, + "end": 855.78 + }, + { + "word": "to", + "start": 855.78, + "end": 855.9 + }, + { + "word": "the", + "start": 855.9, + "end": 856.0 + }, + { + "word": "application.", + "start": 856.0, + "end": 856.34 + }, + { + "word": "This", + "start": 856.34, + "end": 856.52 + }, + { + "word": "is", + "start": 856.52, + "end": 856.72 + }, + { + "word": "a", + "start": 856.72, + "end": 856.76 + }, + { + "word": "bit", + "start": 856.76, + "end": 856.86 + } + ] + }, + { + "start": 856.86, + "end": 861.44, + "text": "aside, but just to kind of give you a better, a better sense of like what's going on. So you have", + "words": [ + { + "word": "aside,", + "start": 856.86, + "end": 857.34 + }, + { + "word": "but", + "start": 857.52, + "end": 857.74 + }, + { + "word": "just", + "start": 857.74, + "end": 858.04 + }, + { + "word": "to", + "start": 858.04, + "end": 858.14 + }, + { + "word": "kind", + "start": 858.14, + "end": 858.26 + }, + { + "word": "of", + "start": 858.26, + "end": 858.3 + }, + { + "word": "give", + "start": 858.3, + "end": 858.4 + }, + { + "word": "you", + "start": 858.4, + "end": 858.54 + }, + { + "word": "a", + "start": 858.54, + "end": 858.62 + }, + { + "word": "better,", + "start": 858.62, + "end": 858.88 + }, + { + "word": "a", + "start": 858.88, + "end": 859.16 + }, + { + "word": "better", + "start": 859.16, + "end": 859.28 + }, + { + "word": "sense", + "start": 859.28, + "end": 859.54 + }, + { + "word": "of", + "start": 859.54, + "end": 859.66 + }, + { + "word": "like", + "start": 859.66, + "end": 859.8 + }, + { + "word": "what's", + "start": 859.8, + "end": 860.0 + }, + { + "word": "going", + "start": 860.0, + "end": 860.16 + }, + { + "word": "on.", + "start": 860.16, + "end": 860.48 + }, + { + "word": "So", + "start": 860.7, + "end": 860.92 + }, + { + "word": "you", + "start": 860.92, + "end": 861.16 + }, + { + "word": "have", + "start": 861.16, + "end": 861.44 + } + ] + }, + { + "start": 861.44, + "end": 866.5, + "text": "a right now, like a Dino application or a Python application that you've written to interface with", + "words": [ + { + "word": "a", + "start": 861.44, + "end": 862.14 + }, + { + "word": "right", + "start": 862.14, + "end": 862.3 + }, + { + "word": "now,", + "start": 862.3, + "end": 862.48 + }, + { + "word": "like", + "start": 862.56, + "end": 862.68 + }, + { + "word": "a", + "start": 862.68, + "end": 862.8 + }, + { + "word": "Dino", + "start": 862.8, + "end": 862.96 + }, + { + "word": "application", + "start": 862.96, + "end": 863.46 + }, + { + "word": "or", + "start": 863.46, + "end": 863.64 + }, + { + "word": "a", + "start": 863.64, + "end": 863.7 + }, + { + "word": "Python", + "start": 863.7, + "end": 863.94 + }, + { + "word": "application", + "start": 863.94, + "end": 864.42 + }, + { + "word": "that", + "start": 864.42, + "end": 864.6 + }, + { + "word": "you've", + "start": 864.6, + "end": 864.86 + }, + { + "word": "written", + "start": 864.86, + "end": 865.06 + }, + { + "word": "to", + "start": 865.06, + "end": 865.5 + }, + { + "word": "interface", + "start": 865.5, + "end": 865.9 + }, + { + "word": "with", + "start": 865.9, + "end": 866.5 + } + ] + }, + { + "start": 867.7, + "end": 872.54, + "text": "the sort of like lightweight SDKs for like managing the data structures. And those", + "words": [ + { + "word": "the", + "start": 867.7, + "end": 868.14 + }, + { + "word": "sort", + "start": 868.14, + "end": 868.44 + }, + { + "word": "of", + "start": 868.44, + "end": 868.58 + }, + { + "word": "like", + "start": 868.58, + "end": 868.86 + }, + { + "word": "lightweight", + "start": 868.86, + "end": 869.18 + }, + { + "word": "SDKs", + "start": 869.18, + "end": 869.92 + }, + { + "word": "for", + "start": 869.92, + "end": 870.04 + }, + { + "word": "like", + "start": 870.04, + "end": 870.28 + }, + { + "word": "managing", + "start": 870.28, + "end": 870.5 + }, + { + "word": "the", + "start": 870.5, + "end": 870.72 + }, + { + "word": "data", + "start": 870.72, + "end": 870.86 + }, + { + "word": "structures.", + "start": 870.86, + "end": 871.34 + }, + { + "word": "And", + "start": 871.38, + "end": 871.72 + }, + { + "word": "those", + "start": 871.72, + "end": 872.54 + } + ] + }, + { + "start": 872.54, + "end": 879.5, + "text": "send messages over standard in, standard out. And the Rust back end, it just has kind of a loop", + "words": [ + { + "word": "send", + "start": 872.54, + "end": 872.84 + }, + { + "word": "messages", + "start": 872.84, + "end": 873.28 + }, + { + "word": "over", + "start": 873.28, + "end": 873.7 + }, + { + "word": "standard", + "start": 873.7, + "end": 873.94 + }, + { + "word": "in,", + "start": 873.94, + "end": 874.18 + }, + { + "word": "standard", + "start": 874.18, + "end": 874.36 + }, + { + "word": "out.", + "start": 874.36, + "end": 874.74 + }, + { + "word": "And", + "start": 875.96, + "end": 876.3 + }, + { + "word": "the", + "start": 876.3, + "end": 876.88 + }, + { + "word": "Rust", + "start": 876.88, + "end": 877.02 + }, + { + "word": "back", + "start": 877.02, + "end": 877.34 + }, + { + "word": "end,", + "start": 877.34, + "end": 877.66 + }, + { + "word": "it", + "start": 877.72, + "end": 877.78 + }, + { + "word": "just", + "start": 877.78, + "end": 877.92 + }, + { + "word": "has", + "start": 877.92, + "end": 878.1 + }, + { + "word": "kind", + "start": 878.1, + "end": 878.34 + }, + { + "word": "of", + "start": 878.34, + "end": 878.7 + }, + { + "word": "a", + "start": 878.7, + "end": 879.32 + }, + { + "word": "loop", + "start": 879.32, + "end": 879.5 + } + ] + }, + { + "start": 879.5, + "end": 882.86, + "text": "running on a separate thread where it's just like reading from standard in, standard out.", + "words": [ + { + "word": "running", + "start": 879.5, + "end": 879.7 + }, + { + "word": "on", + "start": 879.7, + "end": 879.92 + }, + { + "word": "a", + "start": 879.92, + "end": 880.06 + }, + { + "word": "separate", + "start": 880.06, + "end": 880.24 + }, + { + "word": "thread", + "start": 880.24, + "end": 880.52 + }, + { + "word": "where", + "start": 880.52, + "end": 880.72 + }, + { + "word": "it's", + "start": 880.72, + "end": 880.92 + }, + { + "word": "just", + "start": 880.92, + "end": 881.02 + }, + { + "word": "like", + "start": 881.02, + "end": 881.26 + }, + { + "word": "reading", + "start": 881.26, + "end": 881.46 + }, + { + "word": "from", + "start": 881.46, + "end": 881.7 + }, + { + "word": "standard", + "start": 881.7, + "end": 881.9 + }, + { + "word": "in,", + "start": 881.9, + "end": 882.08 + }, + { + "word": "standard", + "start": 882.12, + "end": 882.28 + }, + { + "word": "out.", + "start": 882.28, + "end": 882.86 + } + ] + }, + { + "start": 882.86, + "end": 888.44, + "text": "And just sending calls to Rye essentially. And that's like the whole thing. It's super,", + "words": [ + { + "word": "And", + "start": 882.86, + "end": 883.78 + }, + { + "word": "just", + "start": 883.78, + "end": 884.22 + }, + { + "word": "sending", + "start": 884.22, + "end": 884.62 + }, + { + "word": "calls", + "start": 884.62, + "end": 885.0 + }, + { + "word": "to", + "start": 885.0, + "end": 885.24 + }, + { + "word": "Rye", + "start": 885.24, + "end": 885.48 + }, + { + "word": "essentially.", + "start": 885.48, + "end": 885.98 + }, + { + "word": "And", + "start": 886.1, + "end": 886.18 + }, + { + "word": "that's", + "start": 886.18, + "end": 886.44 + }, + { + "word": "like", + "start": 886.44, + "end": 886.94 + }, + { + "word": "the", + "start": 886.94, + "end": 887.02 + }, + { + "word": "whole", + "start": 887.02, + "end": 887.24 + }, + { + "word": "thing.", + "start": 887.24, + "end": 887.48 + }, + { + "word": "It's", + "start": 887.74, + "end": 888.14 + }, + { + "word": "super,", + "start": 888.14, + "end": 888.44 + } + ] + }, + { + "start": 888.44, + "end": 898.02, + "text": "super simple. And then as far as the co-gen goes, again, I have these JSON schemas that are generated", + "words": [ + { + "word": "super", + "start": 888.44, + "end": 888.66 + }, + { + "word": "simple.", + "start": 888.66, + "end": 889.0 + }, + { + "word": "And", + "start": 890.9, + "end": 891.38 + }, + { + "word": "then", + "start": 891.38, + "end": 891.66 + }, + { + "word": "as", + "start": 891.66, + "end": 891.88 + }, + { + "word": "far", + "start": 891.88, + "end": 892.1 + }, + { + "word": "as", + "start": 892.1, + "end": 892.28 + }, + { + "word": "the", + "start": 892.28, + "end": 892.48 + }, + { + "word": "co", + "start": 892.48, + "end": 892.62 + }, + { + "word": "-gen", + "start": 892.62, + "end": 892.7 + }, + { + "word": "goes,", + "start": 892.7, + "end": 893.32 + }, + { + "word": "again,", + "start": 893.82, + "end": 894.38 + }, + { + "word": "I", + "start": 894.46, + "end": 894.92 + }, + { + "word": "have", + "start": 894.92, + "end": 895.74 + }, + { + "word": "these", + "start": 895.74, + "end": 896.1 + }, + { + "word": "JSON", + "start": 896.1, + "end": 896.36 + }, + { + "word": "schemas", + "start": 896.36, + "end": 897.0 + }, + { + "word": "that", + "start": 897.0, + "end": 897.3 + }, + { + "word": "are", + "start": 897.3, + "end": 897.62 + }, + { + "word": "generated", + "start": 897.62, + "end": 898.02 + } + ] + }, + { + "start": 898.02, + "end": 902.54, + "text": "from my actual Rust implementation. I'll talk about like what crate I use for that and some", + "words": [ + { + "word": "from", + "start": 898.02, + "end": 898.22 + }, + { + "word": "my", + "start": 898.22, + "end": 898.4 + }, + { + "word": "actual", + "start": 898.4, + "end": 898.74 + }, + { + "word": "Rust", + "start": 898.74, + "end": 898.94 + }, + { + "word": "implementation.", + "start": 898.94, + "end": 899.52 + }, + { + "word": "I'll", + "start": 900.08, + "end": 900.26 + }, + { + "word": "talk", + "start": 900.26, + "end": 900.4 + }, + { + "word": "about", + "start": 900.4, + "end": 900.6 + }, + { + "word": "like", + "start": 900.6, + "end": 900.86 + }, + { + "word": "what", + "start": 900.86, + "end": 901.0 + }, + { + "word": "crate", + "start": 901.0, + "end": 901.2 + }, + { + "word": "I", + "start": 901.2, + "end": 901.42 + }, + { + "word": "use", + "start": 901.42, + "end": 901.5 + }, + { + "word": "for", + "start": 901.5, + "end": 901.72 + }, + { + "word": "that", + "start": 901.72, + "end": 901.98 + }, + { + "word": "and", + "start": 901.98, + "end": 902.16 + }, + { + "word": "some", + "start": 902.16, + "end": 902.54 + } + ] + }, + { + "start": 902.54, + "end": 907.14, + "text": "strategies for them a little bit. And then those definitions are just sent through this like custom", + "words": [ + { + "word": "strategies", + "start": 902.54, + "end": 902.96 + }, + { + "word": "for", + "start": 902.96, + "end": 903.14 + }, + { + "word": "them", + "start": 903.14, + "end": 903.24 + }, + { + "word": "a", + "start": 903.24, + "end": 903.34 + }, + { + "word": "little", + "start": 903.34, + "end": 903.5 + }, + { + "word": "bit.", + "start": 903.5, + "end": 903.8 + }, + { + "word": "And", + "start": 904.4, + "end": 904.88 + }, + { + "word": "then", + "start": 904.88, + "end": 905.06 + }, + { + "word": "those", + "start": 905.06, + "end": 905.32 + }, + { + "word": "definitions", + "start": 905.32, + "end": 905.74 + }, + { + "word": "are", + "start": 905.74, + "end": 905.94 + }, + { + "word": "just", + "start": 905.94, + "end": 906.14 + }, + { + "word": "sent", + "start": 906.14, + "end": 906.24 + }, + { + "word": "through", + "start": 906.24, + "end": 906.46 + }, + { + "word": "this", + "start": 906.46, + "end": 906.72 + }, + { + "word": "like", + "start": 906.72, + "end": 906.98 + }, + { + "word": "custom", + "start": 906.98, + "end": 907.14 + } + ] + }, + { + "start": 907.14, + "end": 911.88, + "text": "parser that I wrote. It's just like reading the JSON schemas and like figuring out like, okay,", + "words": [ + { + "word": "parser", + "start": 907.14, + "end": 907.56 + }, + { + "word": "that", + "start": 907.56, + "end": 907.74 + }, + { + "word": "I", + "start": 907.74, + "end": 907.94 + }, + { + "word": "wrote.", + "start": 907.94, + "end": 908.12 + }, + { + "word": "It's", + "start": 908.48, + "end": 908.6 + }, + { + "word": "just", + "start": 908.6, + "end": 908.72 + }, + { + "word": "like", + "start": 908.72, + "end": 908.96 + }, + { + "word": "reading", + "start": 908.96, + "end": 909.34 + }, + { + "word": "the", + "start": 909.34, + "end": 909.72 + }, + { + "word": "JSON", + "start": 909.72, + "end": 910.04 + }, + { + "word": "schemas", + "start": 910.04, + "end": 910.6 + }, + { + "word": "and", + "start": 910.6, + "end": 910.76 + }, + { + "word": "like", + "start": 910.76, + "end": 910.9 + }, + { + "word": "figuring", + "start": 910.9, + "end": 911.1 + }, + { + "word": "out", + "start": 911.1, + "end": 911.3 + }, + { + "word": "like,", + "start": 911.3, + "end": 911.48 + }, + { + "word": "okay,", + "start": 911.64, + "end": 911.88 + } + ] + }, + { + "start": 911.88, + "end": 917.68, + "text": "how do I like munch these into some usable code? There's a TypeScript generator and a", + "words": [ + { + "word": "how", + "start": 911.88, + "end": 912.2 + }, + { + "word": "do", + "start": 912.2, + "end": 912.38 + }, + { + "word": "I", + "start": 912.38, + "end": 912.58 + }, + { + "word": "like", + "start": 912.58, + "end": 912.9 + }, + { + "word": "munch", + "start": 912.9, + "end": 913.12 + }, + { + "word": "these", + "start": 913.12, + "end": 913.46 + }, + { + "word": "into", + "start": 913.46, + "end": 913.82 + }, + { + "word": "some", + "start": 913.82, + "end": 915.0 + }, + { + "word": "usable", + "start": 915.0, + "end": 915.46 + }, + { + "word": "code?", + "start": 915.46, + "end": 915.88 + }, + { + "word": "There's", + "start": 916.56, + "end": 916.74 + }, + { + "word": "a", + "start": 916.74, + "end": 916.88 + }, + { + "word": "TypeScript", + "start": 916.88, + "end": 917.08 + }, + { + "word": "generator", + "start": 917.08, + "end": 917.5 + }, + { + "word": "and", + "start": 917.5, + "end": 917.62 + }, + { + "word": "a", + "start": 917.62, + "end": 917.68 + } + ] + }, + { + "start": 917.68, + "end": 921.88, + "text": "Python generator. And then there's a bunch of stuff that like falls downstream out of that. So", + "words": [ + { + "word": "Python", + "start": 917.68, + "end": 917.9 + }, + { + "word": "generator.", + "start": 917.9, + "end": 918.36 + }, + { + "word": "And", + "start": 918.54, + "end": 918.62 + }, + { + "word": "then", + "start": 918.62, + "end": 919.06 + }, + { + "word": "there's", + "start": 919.06, + "end": 919.3 + }, + { + "word": "a", + "start": 919.3, + "end": 919.38 + }, + { + "word": "bunch", + "start": 919.38, + "end": 919.46 + }, + { + "word": "of", + "start": 919.46, + "end": 919.62 + }, + { + "word": "stuff", + "start": 919.62, + "end": 919.76 + }, + { + "word": "that", + "start": 919.76, + "end": 919.94 + }, + { + "word": "like", + "start": 919.94, + "end": 920.1 + }, + { + "word": "falls", + "start": 920.1, + "end": 920.28 + }, + { + "word": "downstream", + "start": 920.28, + "end": 920.66 + }, + { + "word": "out", + "start": 920.66, + "end": 920.88 + }, + { + "word": "of", + "start": 920.88, + "end": 921.0 + }, + { + "word": "that.", + "start": 921.0, + "end": 921.2 + }, + { + "word": "So", + "start": 921.88, + "end": 921.88 + } + ] + }, + { + "start": 921.88, + "end": 927.34, + "text": "I have my TypeScript definitions. I generate Zod schemas for TypeScript just so it's like easy to", + "words": [ + { + "word": "I", + "start": 921.88, + "end": 922.3 + }, + { + "word": "have", + "start": 922.3, + "end": 922.48 + }, + { + "word": "my", + "start": 922.48, + "end": 922.8 + }, + { + "word": "TypeScript", + "start": 922.8, + "end": 923.14 + }, + { + "word": "definitions.", + "start": 923.14, + "end": 923.74 + }, + { + "word": "I", + "start": 924.56, + "end": 924.64 + }, + { + "word": "generate", + "start": 924.64, + "end": 924.82 + }, + { + "word": "Zod", + "start": 924.82, + "end": 925.08 + }, + { + "word": "schemas", + "start": 925.08, + "end": 925.46 + }, + { + "word": "for", + "start": 925.46, + "end": 925.64 + }, + { + "word": "TypeScript", + "start": 925.64, + "end": 926.1 + }, + { + "word": "just", + "start": 926.1, + "end": 926.3 + }, + { + "word": "so", + "start": 926.3, + "end": 926.44 + }, + { + "word": "it's", + "start": 926.44, + "end": 926.62 + }, + { + "word": "like", + "start": 926.62, + "end": 926.8 + }, + { + "word": "easy", + "start": 926.8, + "end": 927.08 + }, + { + "word": "to", + "start": 927.08, + "end": 927.34 + } + ] + }, + { + "start": 927.34, + "end": 932.7, + "text": "like get runtime validation. And then there's a lot of like Python typing stuff that I had to", + "words": [ + { + "word": "like", + "start": 927.34, + "end": 927.6 + }, + { + "word": "get", + "start": 927.6, + "end": 927.74 + }, + { + "word": "runtime", + "start": 927.74, + "end": 928.04 + }, + { + "word": "validation.", + "start": 928.04, + "end": 928.62 + }, + { + "word": "And", + "start": 929.44, + "end": 929.84 + }, + { + "word": "then", + "start": 929.84, + "end": 930.36 + }, + { + "word": "there's", + "start": 930.36, + "end": 930.66 + }, + { + "word": "a", + "start": 930.66, + "end": 930.74 + }, + { + "word": "lot", + "start": 930.74, + "end": 930.84 + }, + { + "word": "of", + "start": 930.84, + "end": 930.96 + }, + { + "word": "like", + "start": 930.96, + "end": 931.14 + }, + { + "word": "Python", + "start": 931.14, + "end": 931.52 + }, + { + "word": "typing", + "start": 931.52, + "end": 931.88 + }, + { + "word": "stuff", + "start": 931.88, + "end": 932.18 + }, + { + "word": "that", + "start": 932.18, + "end": 932.44 + }, + { + "word": "I", + "start": 932.44, + "end": 932.56 + }, + { + "word": "had", + "start": 932.56, + "end": 932.68 + }, + { + "word": "to", + "start": 932.68, + "end": 932.7 + } + ] + }, + { + "start": 932.7, + "end": 939.18, + "text": "get someone to help me with. So one of the things I want to emphasize if you're ever taking on a", + "words": [ + { + "word": "get", + "start": 932.7, + "end": 932.84 + }, + { + "word": "someone", + "start": 932.84, + "end": 933.02 + }, + { + "word": "to", + "start": 933.02, + "end": 933.14 + }, + { + "word": "help", + "start": 933.14, + "end": 933.2 + }, + { + "word": "me", + "start": 933.2, + "end": 933.4 + }, + { + "word": "with.", + "start": 933.4, + "end": 933.64 + }, + { + "word": "So", + "start": 936.36, + "end": 936.76 + }, + { + "word": "one", + "start": 936.76, + "end": 937.16 + }, + { + "word": "of", + "start": 937.16, + "end": 937.24 + }, + { + "word": "the", + "start": 937.24, + "end": 937.28 + }, + { + "word": "things", + "start": 937.28, + "end": 937.42 + }, + { + "word": "I", + "start": 937.42, + "end": 937.52 + }, + { + "word": "want", + "start": 937.52, + "end": 937.62 + }, + { + "word": "to", + "start": 937.62, + "end": 937.78 + }, + { + "word": "emphasize", + "start": 937.78, + "end": 938.16 + }, + { + "word": "if", + "start": 938.16, + "end": 938.3 + }, + { + "word": "you're", + "start": 938.3, + "end": 938.42 + }, + { + "word": "ever", + "start": 938.42, + "end": 938.62 + }, + { + "word": "taking", + "start": 938.62, + "end": 938.82 + }, + { + "word": "on", + "start": 938.82, + "end": 938.98 + }, + { + "word": "a", + "start": 938.98, + "end": 939.18 + } + ] + }, + { + "start": 939.18, + "end": 943.76, + "text": "project like this is to begin with the end of mind. Think about what you're trying to accomplish.", + "words": [ + { + "word": "project", + "start": 939.18, + "end": 939.36 + }, + { + "word": "like", + "start": 939.36, + "end": 939.7 + }, + { + "word": "this", + "start": 939.7, + "end": 940.16 + }, + { + "word": "is", + "start": 940.16, + "end": 940.54 + }, + { + "word": "to", + "start": 940.54, + "end": 940.8 + }, + { + "word": "begin", + "start": 940.8, + "end": 940.98 + }, + { + "word": "with", + "start": 940.98, + "end": 941.1 + }, + { + "word": "the", + "start": 941.1, + "end": 941.24 + }, + { + "word": "end", + "start": 941.24, + "end": 941.36 + }, + { + "word": "of", + "start": 941.36, + "end": 941.52 + }, + { + "word": "mind.", + "start": 941.52, + "end": 941.78 + }, + { + "word": "Think", + "start": 942.08, + "end": 942.24 + }, + { + "word": "about", + "start": 942.24, + "end": 942.38 + }, + { + "word": "what", + "start": 942.38, + "end": 942.5 + }, + { + "word": "you're", + "start": 942.5, + "end": 942.72 + }, + { + "word": "trying", + "start": 942.72, + "end": 943.0 + }, + { + "word": "to", + "start": 943.0, + "end": 943.28 + }, + { + "word": "accomplish.", + "start": 943.28, + "end": 943.76 + } + ] + }, + { + "start": 944.34, + "end": 950.38, + "text": "Write the SDK you want to see. Do it by hand first. It's critically important to understand", + "words": [ + { + "word": "Write", + "start": 944.34, + "end": 944.56 + }, + { + "word": "the", + "start": 944.56, + "end": 944.88 + }, + { + "word": "SDK", + "start": 944.88, + "end": 945.18 + }, + { + "word": "you", + "start": 945.18, + "end": 945.42 + }, + { + "word": "want", + "start": 945.42, + "end": 945.58 + }, + { + "word": "to", + "start": 945.58, + "end": 945.8 + }, + { + "word": "see.", + "start": 945.8, + "end": 946.12 + }, + { + "word": "Do", + "start": 946.82, + "end": 946.98 + }, + { + "word": "it", + "start": 946.98, + "end": 947.1 + }, + { + "word": "by", + "start": 947.1, + "end": 947.3 + }, + { + "word": "hand", + "start": 947.3, + "end": 947.5 + }, + { + "word": "first.", + "start": 947.5, + "end": 948.14 + }, + { + "word": "It's", + "start": 948.76, + "end": 948.94 + }, + { + "word": "critically", + "start": 948.94, + "end": 949.2 + }, + { + "word": "important", + "start": 949.2, + "end": 949.6 + }, + { + "word": "to", + "start": 949.6, + "end": 949.82 + }, + { + "word": "understand", + "start": 949.82, + "end": 950.38 + } + ] + }, + { + "start": 950.38, + "end": 956.36, + "text": "like what the shape of this thing should look like on the outside. And it's important because", + "words": [ + { + "word": "like", + "start": 950.38, + "end": 950.7 + }, + { + "word": "what", + "start": 950.7, + "end": 950.92 + }, + { + "word": "the", + "start": 950.92, + "end": 951.32 + }, + { + "word": "shape", + "start": 951.32, + "end": 951.48 + }, + { + "word": "of", + "start": 951.48, + "end": 951.7 + }, + { + "word": "this", + "start": 951.7, + "end": 951.94 + }, + { + "word": "thing", + "start": 951.94, + "end": 952.1 + }, + { + "word": "should", + "start": 952.1, + "end": 952.32 + }, + { + "word": "look", + "start": 952.32, + "end": 952.56 + }, + { + "word": "like", + "start": 952.56, + "end": 952.86 + }, + { + "word": "on", + "start": 952.86, + "end": 953.08 + }, + { + "word": "the", + "start": 953.08, + "end": 953.22 + }, + { + "word": "outside.", + "start": 953.22, + "end": 953.66 + }, + { + "word": "And", + "start": 954.18, + "end": 954.66 + }, + { + "word": "it's", + "start": 954.66, + "end": 955.28 + }, + { + "word": "important", + "start": 955.28, + "end": 955.6 + }, + { + "word": "because", + "start": 955.6, + "end": 956.36 + } + ] + }, + { + "start": 956.36, + "end": 960.8, + "text": "there's just this constant translation that you're going to have to do from the source", + "words": [ + { + "word": "there's", + "start": 956.36, + "end": 957.28 + }, + { + "word": "just", + "start": 957.28, + "end": 957.6 + }, + { + "word": "this", + "start": 957.6, + "end": 957.86 + }, + { + "word": "constant", + "start": 957.86, + "end": 958.36 + }, + { + "word": "translation", + "start": 958.36, + "end": 958.9 + }, + { + "word": "that", + "start": 958.9, + "end": 959.16 + }, + { + "word": "you're", + "start": 959.16, + "end": 959.36 + }, + { + "word": "going", + "start": 959.36, + "end": 959.42 + }, + { + "word": "to", + "start": 959.42, + "end": 959.54 + }, + { + "word": "have", + "start": 959.54, + "end": 959.7 + }, + { + "word": "to", + "start": 959.7, + "end": 959.88 + }, + { + "word": "do", + "start": 959.88, + "end": 960.18 + }, + { + "word": "from", + "start": 960.18, + "end": 960.38 + }, + { + "word": "the", + "start": 960.38, + "end": 960.6 + }, + { + "word": "source", + "start": 960.6, + "end": 960.8 + } + ] + }, + { + "start": 960.8, + "end": 965.66, + "text": "language that you're generating in, if it's Rust or whatever language, to whatever your client is.", + "words": [ + { + "word": "language", + "start": 960.8, + "end": 961.12 + }, + { + "word": "that", + "start": 961.12, + "end": 961.26 + }, + { + "word": "you're", + "start": 961.26, + "end": 961.48 + }, + { + "word": "generating", + "start": 961.48, + "end": 961.8 + }, + { + "word": "in,", + "start": 961.8, + "end": 962.1 + }, + { + "word": "if", + "start": 962.1, + "end": 962.2 + }, + { + "word": "it's", + "start": 962.2, + "end": 962.44 + }, + { + "word": "Rust", + "start": 962.44, + "end": 962.6 + }, + { + "word": "or", + "start": 962.6, + "end": 962.76 + }, + { + "word": "whatever", + "start": 962.76, + "end": 962.98 + }, + { + "word": "language,", + "start": 962.98, + "end": 963.48 + }, + { + "word": "to", + "start": 964.02, + "end": 964.36 + }, + { + "word": "whatever", + "start": 964.36, + "end": 964.6 + }, + { + "word": "your", + "start": 964.6, + "end": 964.9 + }, + { + "word": "client", + "start": 964.9, + "end": 965.16 + }, + { + "word": "is.", + "start": 965.16, + "end": 965.66 + } + ] + }, + { + "start": 967.1, + "end": 973.98, + "text": "So here's a simple code example of the WebView framework. This is like as easy as you can get.", + "words": [ + { + "word": "So", + "start": 967.1, + "end": 967.54 + }, + { + "word": "here's", + "start": 967.54, + "end": 967.98 + }, + { + "word": "a", + "start": 967.98, + "end": 968.9 + }, + { + "word": "simple", + "start": 968.9, + "end": 969.3 + }, + { + "word": "code", + "start": 969.3, + "end": 969.54 + }, + { + "word": "example", + "start": 969.54, + "end": 969.86 + }, + { + "word": "of", + "start": 969.86, + "end": 970.02 + }, + { + "word": "the", + "start": 970.02, + "end": 970.18 + }, + { + "word": "WebView", + "start": 970.18, + "end": 970.78 + }, + { + "word": "framework.", + "start": 970.78, + "end": 971.32 + }, + { + "word": "This", + "start": 972.38, + "end": 972.58 + }, + { + "word": "is", + "start": 972.58, + "end": 972.8 + }, + { + "word": "like", + "start": 972.8, + "end": 973.08 + }, + { + "word": "as", + "start": 973.08, + "end": 973.22 + }, + { + "word": "easy", + "start": 973.22, + "end": 973.44 + }, + { + "word": "as", + "start": 973.44, + "end": 973.52 + }, + { + "word": "you", + "start": 973.52, + "end": 973.66 + }, + { + "word": "can", + "start": 973.66, + "end": 973.82 + }, + { + "word": "get.", + "start": 973.82, + "end": 973.98 + } + ] + }, + { + "start": 974.06, + "end": 979.82, + "text": "There's just like a function and you can pass in props like a title or I want dev tools to be", + "words": [ + { + "word": "There's", + "start": 974.06, + "end": 974.28 + }, + { + "word": "just", + "start": 974.28, + "end": 974.46 + }, + { + "word": "like", + "start": 974.46, + "end": 974.6 + }, + { + "word": "a", + "start": 974.6, + "end": 974.72 + }, + { + "word": "function", + "start": 974.72, + "end": 975.18 + }, + { + "word": "and", + "start": 975.18, + "end": 975.82 + }, + { + "word": "you", + "start": 975.82, + "end": 975.92 + }, + { + "word": "can", + "start": 975.92, + "end": 976.06 + }, + { + "word": "pass", + "start": 976.06, + "end": 976.28 + }, + { + "word": "in", + "start": 976.28, + "end": 976.46 + }, + { + "word": "props", + "start": 976.46, + "end": 976.64 + }, + { + "word": "like", + "start": 976.64, + "end": 977.12 + }, + { + "word": "a", + "start": 977.12, + "end": 977.68 + }, + { + "word": "title", + "start": 977.68, + "end": 978.0 + }, + { + "word": "or", + "start": 978.0, + "end": 978.48 + }, + { + "word": "I", + "start": 978.48, + "end": 978.82 + }, + { + "word": "want", + "start": 978.82, + "end": 979.14 + }, + { + "word": "dev", + "start": 979.14, + "end": 979.34 + }, + { + "word": "tools", + "start": 979.34, + "end": 979.54 + }, + { + "word": "to", + "start": 979.54, + "end": 979.66 + }, + { + "word": "be", + "start": 979.66, + "end": 979.82 + } + ] + }, + { + "start": 979.82, + "end": 984.8, + "text": "enabled. This load function here is kind of interesting because it's like not really", + "words": [ + { + "word": "enabled.", + "start": 979.82, + "end": 980.2 + }, + { + "word": "This", + "start": 980.8, + "end": 981.24 + }, + { + "word": "load", + "start": 981.24, + "end": 981.66 + }, + { + "word": "function", + "start": 981.66, + "end": 982.06 + }, + { + "word": "here", + "start": 982.06, + "end": 982.3 + }, + { + "word": "is", + "start": 982.3, + "end": 982.5 + }, + { + "word": "kind", + "start": 982.5, + "end": 982.6 + }, + { + "word": "of", + "start": 982.6, + "end": 982.8 + }, + { + "word": "interesting", + "start": 982.8, + "end": 983.12 + }, + { + "word": "because", + "start": 983.12, + "end": 983.36 + }, + { + "word": "it's", + "start": 983.36, + "end": 983.64 + }, + { + "word": "like", + "start": 983.64, + "end": 983.94 + }, + { + "word": "not", + "start": 983.94, + "end": 984.28 + }, + { + "word": "really", + "start": 984.28, + "end": 984.8 + } + ] + }, + { + "start": 984.8, + "end": 989.42, + "text": "idiomatic TypeScript. That's not normally how you'd expect the API to be written. Like normally I", + "words": [ + { + "word": "idiomatic", + "start": 984.8, + "end": 985.42 + }, + { + "word": "TypeScript.", + "start": 985.42, + "end": 985.88 + }, + { + "word": "That's", + "start": 985.92, + "end": 986.1 + }, + { + "word": "not", + "start": 986.1, + "end": 986.4 + }, + { + "word": "normally", + "start": 986.4, + "end": 986.76 + }, + { + "word": "how", + "start": 986.76, + "end": 986.96 + }, + { + "word": "you'd", + "start": 986.96, + "end": 987.2 + }, + { + "word": "expect", + "start": 987.2, + "end": 987.52 + }, + { + "word": "the", + "start": 987.52, + "end": 987.7 + }, + { + "word": "API", + "start": 987.7, + "end": 987.9 + }, + { + "word": "to", + "start": 987.9, + "end": 988.04 + }, + { + "word": "be", + "start": 988.04, + "end": 988.18 + }, + { + "word": "written.", + "start": 988.18, + "end": 988.38 + }, + { + "word": "Like", + "start": 988.86, + "end": 989.06 + }, + { + "word": "normally", + "start": 989.06, + "end": 989.3 + }, + { + "word": "I", + "start": 989.3, + "end": 989.42 + } + ] + }, + { + "start": 989.42, + "end": 993.74, + "text": "would just want to write HTML and like you know it'd be fine. I'll talk more a little bit about", + "words": [ + { + "word": "would", + "start": 989.42, + "end": 989.48 + }, + { + "word": "just", + "start": 989.48, + "end": 989.66 + }, + { + "word": "want", + "start": 989.66, + "end": 989.76 + }, + { + "word": "to", + "start": 989.76, + "end": 989.92 + }, + { + "word": "write", + "start": 989.92, + "end": 990.38 + }, + { + "word": "HTML", + "start": 990.38, + "end": 990.84 + }, + { + "word": "and", + "start": 990.84, + "end": 991.2 + }, + { + "word": "like", + "start": 991.2, + "end": 991.5 + }, + { + "word": "you", + "start": 991.5, + "end": 991.78 + }, + { + "word": "know", + "start": 991.78, + "end": 991.94 + }, + { + "word": "it'd", + "start": 991.94, + "end": 992.08 + }, + { + "word": "be", + "start": 992.08, + "end": 992.22 + }, + { + "word": "fine.", + "start": 992.22, + "end": 992.56 + }, + { + "word": "I'll", + "start": 992.8, + "end": 993.02 + }, + { + "word": "talk", + "start": 993.02, + "end": 993.12 + }, + { + "word": "more", + "start": 993.12, + "end": 993.28 + }, + { + "word": "a", + "start": 993.28, + "end": 993.34 + }, + { + "word": "little", + "start": 993.34, + "end": 993.5 + }, + { + "word": "bit", + "start": 993.5, + "end": 993.62 + }, + { + "word": "about", + "start": 993.62, + "end": 993.74 + } + ] + }, + { + "start": 993.74, + "end": 1001.12, + "text": "that later. So again nothing like crazy as far as the implementation here. And then here's the", + "words": [ + { + "word": "that", + "start": 993.74, + "end": 993.88 + }, + { + "word": "later.", + "start": 993.88, + "end": 994.18 + }, + { + "word": "So", + "start": 995.72, + "end": 995.72 + }, + { + "word": "again", + "start": 995.72, + "end": 996.34 + }, + { + "word": "nothing", + "start": 996.34, + "end": 996.92 + }, + { + "word": "like", + "start": 996.92, + "end": 997.22 + }, + { + "word": "crazy", + "start": 997.22, + "end": 997.66 + }, + { + "word": "as", + "start": 997.66, + "end": 998.42 + }, + { + "word": "far", + "start": 998.42, + "end": 998.58 + }, + { + "word": "as", + "start": 998.58, + "end": 998.68 + }, + { + "word": "the", + "start": 998.68, + "end": 998.8 + }, + { + "word": "implementation", + "start": 998.8, + "end": 999.14 + }, + { + "word": "here.", + "start": 999.14, + "end": 999.68 + }, + { + "word": "And", + "start": 1000.08, + "end": 1000.34 + }, + { + "word": "then", + "start": 1000.34, + "end": 1000.62 + }, + { + "word": "here's", + "start": 1000.62, + "end": 1000.92 + }, + { + "word": "the", + "start": 1000.92, + "end": 1001.12 + } + ] + }, + { + "start": 1001.12, + "end": 1007.84, + "text": "Python example. Same exact thing. So we set up some options in the beginning. Just give it a title", + "words": [ + { + "word": "Python", + "start": 1001.12, + "end": 1001.38 + }, + { + "word": "example.", + "start": 1001.38, + "end": 1001.76 + }, + { + "word": "Same", + "start": 1002.52, + "end": 1002.82 + }, + { + "word": "exact", + "start": 1002.82, + "end": 1003.38 + }, + { + "word": "thing.", + "start": 1003.38, + "end": 1003.9 + }, + { + "word": "So", + "start": 1004.64, + "end": 1004.64 + }, + { + "word": "we", + "start": 1004.64, + "end": 1005.38 + }, + { + "word": "set", + "start": 1005.38, + "end": 1005.56 + }, + { + "word": "up", + "start": 1005.56, + "end": 1005.76 + }, + { + "word": "some", + "start": 1005.76, + "end": 1006.06 + }, + { + "word": "options", + "start": 1006.06, + "end": 1006.42 + }, + { + "word": "in", + "start": 1006.42, + "end": 1006.58 + }, + { + "word": "the", + "start": 1006.58, + "end": 1006.7 + }, + { + "word": "beginning.", + "start": 1006.7, + "end": 1006.98 + }, + { + "word": "Just", + "start": 1007.08, + "end": 1007.22 + }, + { + "word": "give", + "start": 1007.22, + "end": 1007.3 + }, + { + "word": "it", + "start": 1007.3, + "end": 1007.42 + }, + { + "word": "a", + "start": 1007.42, + "end": 1007.52 + }, + { + "word": "title", + "start": 1007.52, + "end": 1007.84 + } + ] + }, + { + "start": 1007.84, + "end": 1012.98, + "text": "and like some content to load and then initialize the WebView. One thing that I'll point out here", + "words": [ + { + "word": "and", + "start": 1007.84, + "end": 1008.08 + }, + { + "word": "like", + "start": 1008.08, + "end": 1008.18 + }, + { + "word": "some", + "start": 1008.18, + "end": 1008.36 + }, + { + "word": "content", + "start": 1008.36, + "end": 1008.62 + }, + { + "word": "to", + "start": 1008.62, + "end": 1008.86 + }, + { + "word": "load", + "start": 1008.86, + "end": 1009.22 + }, + { + "word": "and", + "start": 1009.22, + "end": 1010.12 + }, + { + "word": "then", + "start": 1010.12, + "end": 1010.52 + }, + { + "word": "initialize", + "start": 1010.52, + "end": 1010.86 + }, + { + "word": "the", + "start": 1010.86, + "end": 1011.0 + }, + { + "word": "WebView.", + "start": 1011.0, + "end": 1011.28 + }, + { + "word": "One", + "start": 1011.56, + "end": 1011.74 + }, + { + "word": "thing", + "start": 1011.74, + "end": 1011.92 + }, + { + "word": "that", + "start": 1011.92, + "end": 1012.06 + }, + { + "word": "I'll", + "start": 1012.06, + "end": 1012.28 + }, + { + "word": "point", + "start": 1012.28, + "end": 1012.42 + }, + { + "word": "out", + "start": 1012.42, + "end": 1012.66 + }, + { + "word": "here", + "start": 1012.66, + "end": 1012.98 + } + ] + }, + { + "start": 1012.98, + "end": 1022.02, + "text": "is like notice that the load here is a similar shape but it makes more sense in the Python usage.", + "words": [ + { + "word": "is", + "start": 1012.98, + "end": 1013.28 + }, + { + "word": "like", + "start": 1013.28, + "end": 1013.56 + }, + { + "word": "notice", + "start": 1013.56, + "end": 1013.92 + }, + { + "word": "that", + "start": 1013.92, + "end": 1014.62 + }, + { + "word": "the", + "start": 1014.62, + "end": 1014.96 + }, + { + "word": "load", + "start": 1014.96, + "end": 1015.2 + }, + { + "word": "here", + "start": 1015.2, + "end": 1015.86 + }, + { + "word": "is", + "start": 1015.86, + "end": 1017.0 + }, + { + "word": "a", + "start": 1017.0, + "end": 1017.16 + }, + { + "word": "similar", + "start": 1017.16, + "end": 1017.4 + }, + { + "word": "shape", + "start": 1017.4, + "end": 1017.92 + }, + { + "word": "but", + "start": 1017.92, + "end": 1019.1 + }, + { + "word": "it", + "start": 1019.1, + "end": 1019.26 + }, + { + "word": "makes", + "start": 1019.26, + "end": 1019.38 + }, + { + "word": "more", + "start": 1019.38, + "end": 1019.62 + }, + { + "word": "sense", + "start": 1019.62, + "end": 1020.2 + }, + { + "word": "in", + "start": 1020.2, + "end": 1020.76 + }, + { + "word": "the", + "start": 1020.76, + "end": 1020.98 + }, + { + "word": "Python", + "start": 1020.98, + "end": 1021.56 + }, + { + "word": "usage.", + "start": 1021.56, + "end": 1022.02 + } + ] + }, + { + "start": 1022.02, + "end": 1029.1, + "text": "So this is an example of a case where I had to realize that in order to get a good experience", + "words": [ + { + "word": "So", + "start": 1022.02, + "end": 1022.44 + }, + { + "word": "this", + "start": 1022.44, + "end": 1022.96 + }, + { + "word": "is", + "start": 1022.96, + "end": 1023.16 + }, + { + "word": "an", + "start": 1023.16, + "end": 1023.3 + }, + { + "word": "example", + "start": 1023.3, + "end": 1023.72 + }, + { + "word": "of", + "start": 1023.72, + "end": 1023.92 + }, + { + "word": "a", + "start": 1023.92, + "end": 1024.02 + }, + { + "word": "case", + "start": 1024.02, + "end": 1024.26 + }, + { + "word": "where", + "start": 1024.26, + "end": 1024.5 + }, + { + "word": "I", + "start": 1024.5, + "end": 1024.6 + }, + { + "word": "had", + "start": 1024.6, + "end": 1024.74 + }, + { + "word": "to", + "start": 1024.74, + "end": 1024.98 + }, + { + "word": "realize", + "start": 1024.98, + "end": 1025.42 + }, + { + "word": "that", + "start": 1025.42, + "end": 1026.08 + }, + { + "word": "in", + "start": 1026.08, + "end": 1026.36 + }, + { + "word": "order", + "start": 1026.36, + "end": 1026.56 + }, + { + "word": "to", + "start": 1026.56, + "end": 1026.74 + }, + { + "word": "get", + "start": 1026.74, + "end": 1026.88 + }, + { + "word": "a", + "start": 1026.88, + "end": 1027.22 + }, + { + "word": "good", + "start": 1027.22, + "end": 1028.2 + }, + { + "word": "experience", + "start": 1028.2, + "end": 1029.1 + } + ] + }, + { + "start": 1029.1, + "end": 1034.64, + "text": "across implementations, I had to sacrifice some things and some of my other implementations. So", + "words": [ + { + "word": "across", + "start": 1029.1, + "end": 1029.8 + }, + { + "word": "implementations,", + "start": 1029.8, + "end": 1030.88 + }, + { + "word": "I", + "start": 1031.06, + "end": 1031.3 + }, + { + "word": "had", + "start": 1031.3, + "end": 1031.5 + }, + { + "word": "to", + "start": 1031.5, + "end": 1031.7 + }, + { + "word": "sacrifice", + "start": 1031.7, + "end": 1032.16 + }, + { + "word": "some", + "start": 1032.16, + "end": 1032.48 + }, + { + "word": "things", + "start": 1032.48, + "end": 1032.78 + }, + { + "word": "and", + "start": 1032.78, + "end": 1032.96 + }, + { + "word": "some", + "start": 1032.96, + "end": 1033.14 + }, + { + "word": "of", + "start": 1033.14, + "end": 1033.24 + }, + { + "word": "my", + "start": 1033.24, + "end": 1033.38 + }, + { + "word": "other", + "start": 1033.38, + "end": 1033.56 + }, + { + "word": "implementations.", + "start": 1033.56, + "end": 1034.04 + }, + { + "word": "So", + "start": 1034.54, + "end": 1034.64 + } + ] + }, + { + "start": 1034.64, + "end": 1040.2, + "text": "the TypeScript API I would normally just have like this intersection object on the config and", + "words": [ + { + "word": "the", + "start": 1034.64, + "end": 1034.9 + }, + { + "word": "TypeScript", + "start": 1034.9, + "end": 1035.34 + }, + { + "word": "API", + "start": 1035.34, + "end": 1035.9 + }, + { + "word": "I", + "start": 1035.9, + "end": 1036.22 + }, + { + "word": "would", + "start": 1036.22, + "end": 1036.38 + }, + { + "word": "normally", + "start": 1036.38, + "end": 1036.66 + }, + { + "word": "just", + "start": 1036.66, + "end": 1036.92 + }, + { + "word": "have", + "start": 1036.92, + "end": 1037.1 + }, + { + "word": "like", + "start": 1037.1, + "end": 1037.68 + }, + { + "word": "this", + "start": 1037.68, + "end": 1038.28 + }, + { + "word": "intersection", + "start": 1038.28, + "end": 1038.66 + }, + { + "word": "object", + "start": 1038.66, + "end": 1039.2 + }, + { + "word": "on", + "start": 1039.2, + "end": 1039.46 + }, + { + "word": "the", + "start": 1039.46, + "end": 1039.66 + }, + { + "word": "config", + "start": 1039.66, + "end": 1039.98 + }, + { + "word": "and", + "start": 1039.98, + "end": 1040.2 + } + ] + }, + { + "start": 1040.2, + "end": 1046.78, + "text": "it's like oh you just like specify HTML in line. But doing that made all the other code gen worse", + "words": [ + { + "word": "it's", + "start": 1040.2, + "end": 1040.36 + }, + { + "word": "like", + "start": 1040.36, + "end": 1040.52 + }, + { + "word": "oh", + "start": 1040.52, + "end": 1040.72 + }, + { + "word": "you", + "start": 1040.72, + "end": 1040.8 + }, + { + "word": "just", + "start": 1040.8, + "end": 1040.98 + }, + { + "word": "like", + "start": 1040.98, + "end": 1041.16 + }, + { + "word": "specify", + "start": 1041.16, + "end": 1041.5 + }, + { + "word": "HTML", + "start": 1041.5, + "end": 1041.92 + }, + { + "word": "in", + "start": 1041.92, + "end": 1042.22 + }, + { + "word": "line.", + "start": 1042.22, + "end": 1042.44 + }, + { + "word": "But", + "start": 1043.02, + "end": 1043.06 + }, + { + "word": "doing", + "start": 1043.06, + "end": 1043.48 + }, + { + "word": "that", + "start": 1043.48, + "end": 1043.96 + }, + { + "word": "made", + "start": 1043.96, + "end": 1044.46 + }, + { + "word": "all", + "start": 1044.46, + "end": 1045.02 + }, + { + "word": "the", + "start": 1045.02, + "end": 1045.22 + }, + { + "word": "other", + "start": 1045.22, + "end": 1045.46 + }, + { + "word": "code", + "start": 1045.46, + "end": 1045.76 + }, + { + "word": "gen", + "start": 1045.76, + "end": 1046.18 + }, + { + "word": "worse", + "start": 1046.18, + "end": 1046.78 + } + ] + }, + { + "start": 1046.78, + "end": 1054.68, + "text": "because other languages aren't expressive as TypeScript. So one piece of advice is like", + "words": [ + { + "word": "because", + "start": 1046.78, + "end": 1047.32 + }, + { + "word": "other", + "start": 1047.32, + "end": 1048.28 + }, + { + "word": "languages", + "start": 1048.28, + "end": 1048.6 + }, + { + "word": "aren't", + "start": 1048.6, + "end": 1048.92 + }, + { + "word": "expressive", + "start": 1048.92, + "end": 1049.44 + }, + { + "word": "as", + "start": 1049.44, + "end": 1050.16 + }, + { + "word": "TypeScript.", + "start": 1050.16, + "end": 1050.66 + }, + { + "word": "So", + "start": 1052.44, + "end": 1052.96 + }, + { + "word": "one", + "start": 1052.96, + "end": 1053.36 + }, + { + "word": "piece", + "start": 1053.36, + "end": 1053.54 + }, + { + "word": "of", + "start": 1053.54, + "end": 1053.68 + }, + { + "word": "advice", + "start": 1053.68, + "end": 1053.9 + }, + { + "word": "is", + "start": 1053.9, + "end": 1054.16 + }, + { + "word": "like", + "start": 1054.16, + "end": 1054.68 + } + ] + }, + { + "start": 1054.68, + "end": 1059.38, + "text": "if you're generating stuff, like I said it's lossy, you're just going to have to accept a little bit", + "words": [ + { + "word": "if", + "start": 1054.68, + "end": 1054.76 + }, + { + "word": "you're", + "start": 1054.76, + "end": 1054.94 + }, + { + "word": "generating", + "start": 1054.94, + "end": 1055.4 + }, + { + "word": "stuff,", + "start": 1055.4, + "end": 1055.88 + }, + { + "word": "like", + "start": 1056.04, + "end": 1056.24 + }, + { + "word": "I", + "start": 1056.24, + "end": 1056.38 + }, + { + "word": "said", + "start": 1056.38, + "end": 1056.48 + }, + { + "word": "it's", + "start": 1056.48, + "end": 1056.72 + }, + { + "word": "lossy,", + "start": 1056.72, + "end": 1057.12 + }, + { + "word": "you're", + "start": 1057.16, + "end": 1057.48 + }, + { + "word": "just", + "start": 1057.48, + "end": 1057.66 + }, + { + "word": "going", + "start": 1057.66, + "end": 1057.76 + }, + { + "word": "to", + "start": 1057.76, + "end": 1057.86 + }, + { + "word": "have", + "start": 1057.86, + "end": 1058.02 + }, + { + "word": "to", + "start": 1058.02, + "end": 1058.66 + }, + { + "word": "accept", + "start": 1058.66, + "end": 1058.96 + }, + { + "word": "a", + "start": 1058.96, + "end": 1059.06 + }, + { + "word": "little", + "start": 1059.06, + "end": 1059.24 + }, + { + "word": "bit", + "start": 1059.24, + "end": 1059.38 + } + ] + }, + { + "start": 1059.38, + "end": 1064.38, + "text": "of weirdness. And there's a trade-off to be made here between what is the UX of the API", + "words": [ + { + "word": "of", + "start": 1059.38, + "end": 1059.46 + }, + { + "word": "weirdness.", + "start": 1059.46, + "end": 1059.86 + }, + { + "word": "And", + "start": 1059.96, + "end": 1060.32 + }, + { + "word": "there's", + "start": 1060.32, + "end": 1060.68 + }, + { + "word": "a", + "start": 1060.68, + "end": 1060.88 + }, + { + "word": "trade", + "start": 1060.88, + "end": 1061.04 + }, + { + "word": "-off", + "start": 1061.04, + "end": 1061.18 + }, + { + "word": "to", + "start": 1061.18, + "end": 1061.36 + }, + { + "word": "be", + "start": 1061.36, + "end": 1061.5 + }, + { + "word": "made", + "start": 1061.5, + "end": 1061.7 + }, + { + "word": "here", + "start": 1061.7, + "end": 1062.14 + }, + { + "word": "between", + "start": 1062.14, + "end": 1062.52 + }, + { + "word": "what", + "start": 1062.52, + "end": 1062.76 + }, + { + "word": "is", + "start": 1062.76, + "end": 1062.96 + }, + { + "word": "the", + "start": 1062.96, + "end": 1063.16 + }, + { + "word": "UX", + "start": 1063.16, + "end": 1063.48 + }, + { + "word": "of", + "start": 1063.48, + "end": 1063.82 + }, + { + "word": "the", + "start": 1063.82, + "end": 1064.0 + }, + { + "word": "API", + "start": 1064.0, + "end": 1064.38 + } + ] + }, + { + "start": 1064.38, + "end": 1071.36, + "text": "and how complex is my generation. Because you could do custom generation for every client and go in", + "words": [ + { + "word": "and", + "start": 1064.38, + "end": 1065.3 + }, + { + "word": "how", + "start": 1065.3, + "end": 1065.8 + }, + { + "word": "complex", + "start": 1065.8, + "end": 1066.28 + }, + { + "word": "is", + "start": 1066.28, + "end": 1066.46 + }, + { + "word": "my", + "start": 1066.46, + "end": 1066.6 + }, + { + "word": "generation.", + "start": 1066.6, + "end": 1067.16 + }, + { + "word": "Because", + "start": 1067.56, + "end": 1067.86 + }, + { + "word": "you", + "start": 1067.86, + "end": 1068.16 + }, + { + "word": "could", + "start": 1068.16, + "end": 1068.28 + }, + { + "word": "do", + "start": 1068.28, + "end": 1068.44 + }, + { + "word": "custom", + "start": 1068.44, + "end": 1068.72 + }, + { + "word": "generation", + "start": 1068.72, + "end": 1069.4 + }, + { + "word": "for", + "start": 1069.4, + "end": 1070.0 + }, + { + "word": "every", + "start": 1070.0, + "end": 1070.34 + }, + { + "word": "client", + "start": 1070.34, + "end": 1070.76 + }, + { + "word": "and", + "start": 1070.76, + "end": 1071.0 + }, + { + "word": "go", + "start": 1071.0, + "end": 1071.18 + }, + { + "word": "in", + "start": 1071.18, + "end": 1071.36 + } + ] + }, + { + "start": 1071.36, + "end": 1076.14, + "text": "and have all these edge cases and just you know really munch it. But you're going to pay for that", + "words": [ + { + "word": "and", + "start": 1071.36, + "end": 1071.48 + }, + { + "word": "have", + "start": 1071.48, + "end": 1071.6 + }, + { + "word": "all", + "start": 1071.6, + "end": 1071.86 + }, + { + "word": "these", + "start": 1071.86, + "end": 1072.1 + }, + { + "word": "edge", + "start": 1072.1, + "end": 1072.28 + }, + { + "word": "cases", + "start": 1072.28, + "end": 1072.68 + }, + { + "word": "and", + "start": 1072.68, + "end": 1073.06 + }, + { + "word": "just", + "start": 1073.06, + "end": 1073.48 + }, + { + "word": "you", + "start": 1073.48, + "end": 1073.5 + }, + { + "word": "know", + "start": 1073.5, + "end": 1073.76 + }, + { + "word": "really", + "start": 1073.76, + "end": 1074.06 + }, + { + "word": "munch", + "start": 1074.06, + "end": 1074.32 + }, + { + "word": "it.", + "start": 1074.32, + "end": 1074.5 + }, + { + "word": "But", + "start": 1074.5, + "end": 1074.84 + }, + { + "word": "you're", + "start": 1074.84, + "end": 1075.22 + }, + { + "word": "going", + "start": 1075.22, + "end": 1075.28 + }, + { + "word": "to", + "start": 1075.28, + "end": 1075.38 + }, + { + "word": "pay", + "start": 1075.38, + "end": 1075.58 + }, + { + "word": "for", + "start": 1075.58, + "end": 1075.8 + }, + { + "word": "that", + "start": 1075.8, + "end": 1076.14 + } + ] + }, + { + "start": 1076.14, + "end": 1082.48, + "text": "because it's going to get really hard to maintain. And really at a certain point you have to think", + "words": [ + { + "word": "because", + "start": 1076.14, + "end": 1076.36 + }, + { + "word": "it's", + "start": 1076.36, + "end": 1076.68 + }, + { + "word": "going", + "start": 1076.68, + "end": 1076.76 + }, + { + "word": "to", + "start": 1076.76, + "end": 1076.84 + }, + { + "word": "get", + "start": 1076.84, + "end": 1077.06 + }, + { + "word": "really", + "start": 1077.06, + "end": 1077.5 + }, + { + "word": "hard", + "start": 1077.5, + "end": 1077.7 + }, + { + "word": "to", + "start": 1077.7, + "end": 1077.88 + }, + { + "word": "maintain.", + "start": 1077.88, + "end": 1078.34 + }, + { + "word": "And", + "start": 1079.98, + "end": 1079.98 + }, + { + "word": "really", + "start": 1079.98, + "end": 1080.68 + }, + { + "word": "at", + "start": 1080.68, + "end": 1081.14 + }, + { + "word": "a", + "start": 1081.14, + "end": 1081.32 + }, + { + "word": "certain", + "start": 1081.32, + "end": 1081.46 + }, + { + "word": "point", + "start": 1081.46, + "end": 1081.7 + }, + { + "word": "you", + "start": 1081.7, + "end": 1081.8 + }, + { + "word": "have", + "start": 1081.8, + "end": 1081.96 + }, + { + "word": "to", + "start": 1081.96, + "end": 1082.2 + }, + { + "word": "think", + "start": 1082.2, + "end": 1082.48 + } + ] + }, + { + "start": 1082.48, + "end": 1087.22, + "text": "like am I actually getting the benefits of this approach? If you're having to every time you make", + "words": [ + { + "word": "like", + "start": 1082.48, + "end": 1083.04 + }, + { + "word": "am", + "start": 1083.04, + "end": 1083.22 + }, + { + "word": "I", + "start": 1083.22, + "end": 1083.5 + }, + { + "word": "actually", + "start": 1083.5, + "end": 1083.78 + }, + { + "word": "getting", + "start": 1083.78, + "end": 1083.94 + }, + { + "word": "the", + "start": 1083.94, + "end": 1084.2 + }, + { + "word": "benefits", + "start": 1084.2, + "end": 1084.48 + }, + { + "word": "of", + "start": 1084.48, + "end": 1084.64 + }, + { + "word": "this", + "start": 1084.64, + "end": 1084.78 + }, + { + "word": "approach?", + "start": 1084.78, + "end": 1085.14 + }, + { + "word": "If", + "start": 1085.28, + "end": 1085.3 + }, + { + "word": "you're", + "start": 1085.3, + "end": 1085.46 + }, + { + "word": "having", + "start": 1085.46, + "end": 1085.66 + }, + { + "word": "to", + "start": 1085.66, + "end": 1086.08 + }, + { + "word": "every", + "start": 1086.08, + "end": 1086.36 + }, + { + "word": "time", + "start": 1086.36, + "end": 1086.76 + }, + { + "word": "you", + "start": 1086.76, + "end": 1087.08 + }, + { + "word": "make", + "start": 1087.08, + "end": 1087.22 + } + ] + }, + { + "start": 1087.22, + "end": 1093.3, + "text": "an addition to the upstream language go through and like edit some generation logic, you're doing", + "words": [ + { + "word": "an", + "start": 1087.22, + "end": 1087.44 + }, + { + "word": "addition", + "start": 1087.44, + "end": 1087.84 + }, + { + "word": "to", + "start": 1087.84, + "end": 1088.4 + }, + { + "word": "the", + "start": 1088.4, + "end": 1088.58 + }, + { + "word": "upstream", + "start": 1088.58, + "end": 1088.9 + }, + { + "word": "language", + "start": 1088.9, + "end": 1089.32 + }, + { + "word": "go", + "start": 1089.32, + "end": 1089.62 + }, + { + "word": "through", + "start": 1089.62, + "end": 1089.9 + }, + { + "word": "and", + "start": 1089.9, + "end": 1090.16 + }, + { + "word": "like", + "start": 1090.16, + "end": 1090.8 + }, + { + "word": "edit", + "start": 1090.8, + "end": 1091.06 + }, + { + "word": "some", + "start": 1091.06, + "end": 1091.34 + }, + { + "word": "generation", + "start": 1091.34, + "end": 1091.86 + }, + { + "word": "logic,", + "start": 1091.86, + "end": 1092.38 + }, + { + "word": "you're", + "start": 1092.94, + "end": 1093.22 + }, + { + "word": "doing", + "start": 1093.22, + "end": 1093.3 + } + ] + }, + { + "start": 1093.3, + "end": 1097.68, + "text": "something wrong. So definitely keep an eye on that and like be okay with it not being perfect.", + "words": [ + { + "word": "something", + "start": 1093.3, + "end": 1093.56 + }, + { + "word": "wrong.", + "start": 1093.56, + "end": 1093.92 + }, + { + "word": "So", + "start": 1094.12, + "end": 1094.56 + }, + { + "word": "definitely", + "start": 1094.56, + "end": 1094.78 + }, + { + "word": "keep", + "start": 1094.78, + "end": 1094.96 + }, + { + "word": "an", + "start": 1094.96, + "end": 1095.1 + }, + { + "word": "eye", + "start": 1095.1, + "end": 1095.16 + }, + { + "word": "on", + "start": 1095.16, + "end": 1095.36 + }, + { + "word": "that", + "start": 1095.36, + "end": 1095.62 + }, + { + "word": "and", + "start": 1095.62, + "end": 1095.76 + }, + { + "word": "like", + "start": 1095.76, + "end": 1096.08 + }, + { + "word": "be", + "start": 1096.08, + "end": 1096.3 + }, + { + "word": "okay", + "start": 1096.3, + "end": 1096.62 + }, + { + "word": "with", + "start": 1096.62, + "end": 1096.78 + }, + { + "word": "it", + "start": 1096.78, + "end": 1096.94 + }, + { + "word": "not", + "start": 1096.94, + "end": 1097.06 + }, + { + "word": "being", + "start": 1097.06, + "end": 1097.26 + }, + { + "word": "perfect.", + "start": 1097.26, + "end": 1097.68 + } + ] + }, + { + "start": 1098.02, + "end": 1103.0, + "text": "The point here is that you're trying to increase your overall effectiveness of like all the clients", + "words": [ + { + "word": "The", + "start": 1098.02, + "end": 1098.18 + }, + { + "word": "point", + "start": 1098.18, + "end": 1098.38 + }, + { + "word": "here", + "start": 1098.38, + "end": 1098.72 + }, + { + "word": "is", + "start": 1098.72, + "end": 1098.88 + }, + { + "word": "that", + "start": 1098.88, + "end": 1099.04 + }, + { + "word": "you're", + "start": 1099.04, + "end": 1099.26 + }, + { + "word": "trying", + "start": 1099.26, + "end": 1099.4 + }, + { + "word": "to", + "start": 1099.4, + "end": 1099.66 + }, + { + "word": "increase", + "start": 1099.66, + "end": 1099.82 + }, + { + "word": "your", + "start": 1099.82, + "end": 1100.14 + }, + { + "word": "overall", + "start": 1100.14, + "end": 1100.5 + }, + { + "word": "effectiveness", + "start": 1100.5, + "end": 1101.0 + }, + { + "word": "of", + "start": 1101.0, + "end": 1101.84 + }, + { + "word": "like", + "start": 1101.84, + "end": 1102.18 + }, + { + "word": "all", + "start": 1102.18, + "end": 1102.46 + }, + { + "word": "the", + "start": 1102.46, + "end": 1102.66 + }, + { + "word": "clients", + "start": 1102.66, + "end": 1103.0 + } + ] + }, + { + "start": 1103.0, + "end": 1113.2, + "text": "and if you over index on any one you'll pay for it. So this is the Rust code that generated those", + "words": [ + { + "word": "and", + "start": 1103.0, + "end": 1103.28 + }, + { + "word": "if", + "start": 1103.28, + "end": 1103.44 + }, + { + "word": "you", + "start": 1103.44, + "end": 1103.72 + }, + { + "word": "over", + "start": 1103.72, + "end": 1103.96 + }, + { + "word": "index", + "start": 1103.96, + "end": 1104.28 + }, + { + "word": "on", + "start": 1104.28, + "end": 1104.5 + }, + { + "word": "any", + "start": 1104.5, + "end": 1104.78 + }, + { + "word": "one", + "start": 1104.78, + "end": 1105.14 + }, + { + "word": "you'll", + "start": 1105.14, + "end": 1105.94 + }, + { + "word": "pay", + "start": 1105.94, + "end": 1106.1 + }, + { + "word": "for", + "start": 1106.1, + "end": 1106.3 + }, + { + "word": "it.", + "start": 1106.3, + "end": 1107.18 + }, + { + "word": "So", + "start": 1108.68, + "end": 1109.18 + }, + { + "word": "this", + "start": 1109.18, + "end": 1109.48 + }, + { + "word": "is", + "start": 1109.48, + "end": 1109.66 + }, + { + "word": "the", + "start": 1109.66, + "end": 1109.78 + }, + { + "word": "Rust", + "start": 1109.78, + "end": 1109.92 + }, + { + "word": "code", + "start": 1109.92, + "end": 1110.46 + }, + { + "word": "that", + "start": 1110.46, + "end": 1111.46 + }, + { + "word": "generated", + "start": 1111.46, + "end": 1112.74 + }, + { + "word": "those", + "start": 1112.74, + "end": 1113.2 + } + ] + }, + { + "start": 1113.2, + "end": 1119.54, + "text": "content HTML things that I pointed out earlier. So this is an enum, has two members of it, this URL", + "words": [ + { + "word": "content", + "start": 1113.2, + "end": 1113.48 + }, + { + "word": "HTML", + "start": 1113.48, + "end": 1113.8 + }, + { + "word": "things", + "start": 1113.8, + "end": 1114.06 + }, + { + "word": "that", + "start": 1114.06, + "end": 1114.18 + }, + { + "word": "I", + "start": 1114.18, + "end": 1114.32 + }, + { + "word": "pointed", + "start": 1114.32, + "end": 1114.42 + }, + { + "word": "out", + "start": 1114.42, + "end": 1114.56 + }, + { + "word": "earlier.", + "start": 1114.56, + "end": 1115.02 + }, + { + "word": "So", + "start": 1115.82, + "end": 1115.82 + }, + { + "word": "this", + "start": 1115.82, + "end": 1116.0 + }, + { + "word": "is", + "start": 1116.0, + "end": 1116.28 + }, + { + "word": "an", + "start": 1116.28, + "end": 1116.5 + }, + { + "word": "enum,", + "start": 1116.5, + "end": 1116.9 + }, + { + "word": "has", + "start": 1117.58, + "end": 1118.04 + }, + { + "word": "two", + "start": 1118.04, + "end": 1118.38 + }, + { + "word": "members", + "start": 1118.38, + "end": 1118.66 + }, + { + "word": "of", + "start": 1118.66, + "end": 1118.82 + }, + { + "word": "it,", + "start": 1118.82, + "end": 1118.94 + }, + { + "word": "this", + "start": 1118.94, + "end": 1119.18 + }, + { + "word": "URL", + "start": 1119.18, + "end": 1119.54 + } + ] + }, + { + "start": 1119.54, + "end": 1125.64, + "text": "and HTML enum. If people haven't used SIRDE here, SIRDE is fantastic. I am assuming that most people", + "words": [ + { + "word": "and", + "start": 1119.54, + "end": 1119.88 + }, + { + "word": "HTML", + "start": 1119.88, + "end": 1120.2 + }, + { + "word": "enum.", + "start": 1120.2, + "end": 1120.72 + }, + { + "word": "If", + "start": 1121.12, + "end": 1121.56 + }, + { + "word": "people", + "start": 1121.56, + "end": 1121.98 + }, + { + "word": "haven't", + "start": 1121.98, + "end": 1122.3 + }, + { + "word": "used", + "start": 1122.3, + "end": 1122.54 + }, + { + "word": "SIRDE", + "start": 1122.54, + "end": 1122.76 + }, + { + "word": "here,", + "start": 1122.76, + "end": 1123.12 + }, + { + "word": "SIRDE", + "start": 1123.16, + "end": 1123.42 + }, + { + "word": "is", + "start": 1123.42, + "end": 1123.62 + }, + { + "word": "fantastic.", + "start": 1123.62, + "end": 1124.22 + }, + { + "word": "I", + "start": 1124.5, + "end": 1124.58 + }, + { + "word": "am", + "start": 1124.58, + "end": 1124.76 + }, + { + "word": "assuming", + "start": 1124.76, + "end": 1125.04 + }, + { + "word": "that", + "start": 1125.04, + "end": 1125.26 + }, + { + "word": "most", + "start": 1125.26, + "end": 1125.42 + }, + { + "word": "people", + "start": 1125.42, + "end": 1125.64 + } + ] + }, + { + "start": 1125.64, + "end": 1131.16, + "text": "who have used Rust have used SIRDE. There is this like one thing that I want to point out up top", + "words": [ + { + "word": "who", + "start": 1125.64, + "end": 1125.8 + }, + { + "word": "have", + "start": 1125.8, + "end": 1125.94 + }, + { + "word": "used", + "start": 1125.94, + "end": 1126.06 + }, + { + "word": "Rust", + "start": 1126.06, + "end": 1126.3 + }, + { + "word": "have", + "start": 1126.3, + "end": 1126.52 + }, + { + "word": "used", + "start": 1126.52, + "end": 1126.72 + }, + { + "word": "SIRDE.", + "start": 1126.72, + "end": 1127.36 + }, + { + "word": "There", + "start": 1128.48, + "end": 1128.76 + }, + { + "word": "is", + "start": 1128.76, + "end": 1129.12 + }, + { + "word": "this", + "start": 1129.12, + "end": 1129.38 + }, + { + "word": "like", + "start": 1129.38, + "end": 1129.66 + }, + { + "word": "one", + "start": 1129.66, + "end": 1129.82 + }, + { + "word": "thing", + "start": 1129.82, + "end": 1129.94 + }, + { + "word": "that", + "start": 1129.94, + "end": 1130.04 + }, + { + "word": "I", + "start": 1130.04, + "end": 1130.08 + }, + { + "word": "want", + "start": 1130.08, + "end": 1130.18 + }, + { + "word": "to", + "start": 1130.18, + "end": 1130.28 + }, + { + "word": "point", + "start": 1130.28, + "end": 1130.4 + }, + { + "word": "out", + "start": 1130.4, + "end": 1130.54 + }, + { + "word": "up", + "start": 1130.54, + "end": 1130.76 + }, + { + "word": "top", + "start": 1130.76, + "end": 1131.16 + } + ] + }, + { + "start": 1132.76, + "end": 1139.26, + "text": "is the this usage of JSON schema. This comes from a crate called schemars. This is how I generate the", + "words": [ + { + "word": "is", + "start": 1132.76, + "end": 1133.28 + }, + { + "word": "the", + "start": 1133.28, + "end": 1133.8 + }, + { + "word": "this", + "start": 1133.8, + "end": 1134.02 + }, + { + "word": "usage", + "start": 1134.02, + "end": 1134.4 + }, + { + "word": "of", + "start": 1134.4, + "end": 1134.86 + }, + { + "word": "JSON", + "start": 1134.86, + "end": 1135.06 + }, + { + "word": "schema.", + "start": 1135.06, + "end": 1135.38 + }, + { + "word": "This", + "start": 1135.48, + "end": 1135.62 + }, + { + "word": "comes", + "start": 1135.62, + "end": 1135.78 + }, + { + "word": "from", + "start": 1135.78, + "end": 1135.98 + }, + { + "word": "a", + "start": 1135.98, + "end": 1136.12 + }, + { + "word": "crate", + "start": 1136.12, + "end": 1136.18 + }, + { + "word": "called", + "start": 1136.18, + "end": 1136.48 + }, + { + "word": "schemars.", + "start": 1136.48, + "end": 1137.04 + }, + { + "word": "This", + "start": 1137.46, + "end": 1137.64 + }, + { + "word": "is", + "start": 1137.64, + "end": 1137.8 + }, + { + "word": "how", + "start": 1137.8, + "end": 1137.92 + }, + { + "word": "I", + "start": 1137.92, + "end": 1138.08 + }, + { + "word": "generate", + "start": 1138.08, + "end": 1138.46 + }, + { + "word": "the", + "start": 1138.46, + "end": 1139.26 + } + ] + }, + { + "start": 1139.26, + "end": 1144.88, + "text": "JSON schema of this type. So if you're looking for something that's actually a fantastic crate,", + "words": [ + { + "word": "JSON", + "start": 1139.26, + "end": 1139.56 + }, + { + "word": "schema", + "start": 1139.56, + "end": 1139.96 + }, + { + "word": "of", + "start": 1139.96, + "end": 1140.52 + }, + { + "word": "this", + "start": 1140.52, + "end": 1140.82 + }, + { + "word": "type.", + "start": 1140.82, + "end": 1141.16 + }, + { + "word": "So", + "start": 1142.02, + "end": 1142.28 + }, + { + "word": "if", + "start": 1142.28, + "end": 1142.36 + }, + { + "word": "you're", + "start": 1142.36, + "end": 1142.5 + }, + { + "word": "looking", + "start": 1142.5, + "end": 1142.74 + }, + { + "word": "for", + "start": 1142.74, + "end": 1142.96 + }, + { + "word": "something", + "start": 1142.96, + "end": 1143.3 + }, + { + "word": "that's", + "start": 1143.3, + "end": 1143.74 + }, + { + "word": "actually", + "start": 1143.74, + "end": 1144.0 + }, + { + "word": "a", + "start": 1144.0, + "end": 1144.28 + }, + { + "word": "fantastic", + "start": 1144.28, + "end": 1144.64 + }, + { + "word": "crate,", + "start": 1144.64, + "end": 1144.88 + } + ] + }, + { + "start": 1145.12, + "end": 1151.52, + "text": "Oxide uses that under the hood. And then of course all the SIRDE configuration in the macros at the", + "words": [ + { + "word": "Oxide", + "start": 1145.12, + "end": 1145.28 + }, + { + "word": "uses", + "start": 1145.28, + "end": 1145.54 + }, + { + "word": "that", + "start": 1145.54, + "end": 1145.74 + }, + { + "word": "under", + "start": 1145.74, + "end": 1145.88 + }, + { + "word": "the", + "start": 1145.88, + "end": 1146.06 + }, + { + "word": "hood.", + "start": 1146.06, + "end": 1146.28 + }, + { + "word": "And", + "start": 1147.5, + "end": 1148.02 + }, + { + "word": "then", + "start": 1148.02, + "end": 1148.2 + }, + { + "word": "of", + "start": 1148.2, + "end": 1148.32 + }, + { + "word": "course", + "start": 1148.32, + "end": 1148.48 + }, + { + "word": "all", + "start": 1148.48, + "end": 1148.8 + }, + { + "word": "the", + "start": 1148.8, + "end": 1149.02 + }, + { + "word": "SIRDE", + "start": 1149.02, + "end": 1149.22 + }, + { + "word": "configuration", + "start": 1149.22, + "end": 1150.04 + }, + { + "word": "in", + "start": 1150.04, + "end": 1150.88 + }, + { + "word": "the", + "start": 1150.88, + "end": 1151.04 + }, + { + "word": "macros", + "start": 1151.04, + "end": 1151.2 + }, + { + "word": "at", + "start": 1151.2, + "end": 1151.34 + }, + { + "word": "the", + "start": 1151.34, + "end": 1151.52 + } + ] + }, + { + "start": 1151.52, + "end": 1158.92, + "text": "top. Particularly I want to point out the untagged macro. So untagged means for this data structure", + "words": [ + { + "word": "top.", + "start": 1151.52, + "end": 1151.8 + }, + { + "word": "Particularly", + "start": 1152.42, + "end": 1152.92 + }, + { + "word": "I", + "start": 1152.92, + "end": 1153.04 + }, + { + "word": "want", + "start": 1153.04, + "end": 1153.18 + }, + { + "word": "to", + "start": 1153.18, + "end": 1153.32 + }, + { + "word": "point", + "start": 1153.32, + "end": 1153.46 + }, + { + "word": "out", + "start": 1153.46, + "end": 1153.76 + }, + { + "word": "the", + "start": 1153.76, + "end": 1154.3 + }, + { + "word": "untagged", + "start": 1154.3, + "end": 1155.8 + }, + { + "word": "macro.", + "start": 1155.8, + "end": 1156.14 + }, + { + "word": "So", + "start": 1156.48, + "end": 1156.8 + }, + { + "word": "untagged", + "start": 1156.8, + "end": 1157.28 + }, + { + "word": "means", + "start": 1157.28, + "end": 1157.58 + }, + { + "word": "for", + "start": 1157.58, + "end": 1157.88 + }, + { + "word": "this", + "start": 1157.88, + "end": 1158.12 + }, + { + "word": "data", + "start": 1158.12, + "end": 1158.38 + }, + { + "word": "structure", + "start": 1158.38, + "end": 1158.92 + } + ] + }, + { + "start": 1158.92, + "end": 1165.02, + "text": "the URL and the HTML names won't be encoded in the final output. Those will just be collapsed", + "words": [ + { + "word": "the", + "start": 1158.92, + "end": 1159.46 + }, + { + "word": "URL", + "start": 1159.46, + "end": 1159.98 + }, + { + "word": "and", + "start": 1159.98, + "end": 1160.5 + }, + { + "word": "the", + "start": 1160.5, + "end": 1160.66 + }, + { + "word": "HTML", + "start": 1160.66, + "end": 1161.04 + }, + { + "word": "names", + "start": 1161.04, + "end": 1161.86 + }, + { + "word": "won't", + "start": 1161.86, + "end": 1162.26 + }, + { + "word": "be", + "start": 1162.26, + "end": 1162.52 + }, + { + "word": "encoded", + "start": 1162.52, + "end": 1162.94 + }, + { + "word": "in", + "start": 1162.94, + "end": 1163.14 + }, + { + "word": "the", + "start": 1163.14, + "end": 1163.32 + }, + { + "word": "final", + "start": 1163.32, + "end": 1163.54 + }, + { + "word": "output.", + "start": 1163.54, + "end": 1163.92 + }, + { + "word": "Those", + "start": 1164.04, + "end": 1164.22 + }, + { + "word": "will", + "start": 1164.22, + "end": 1164.36 + }, + { + "word": "just", + "start": 1164.36, + "end": 1164.52 + }, + { + "word": "be", + "start": 1164.52, + "end": 1164.74 + }, + { + "word": "collapsed", + "start": 1164.74, + "end": 1165.02 + } + ] + }, + { + "start": 1165.02, + "end": 1172.3, + "text": "down. So you can think of this as like a union of the URL headers object and then the HTML origin", + "words": [ + { + "word": "down.", + "start": 1165.02, + "end": 1165.3 + }, + { + "word": "So", + "start": 1165.32, + "end": 1165.46 + }, + { + "word": "you", + "start": 1165.46, + "end": 1165.5 + }, + { + "word": "can", + "start": 1165.5, + "end": 1165.72 + }, + { + "word": "think", + "start": 1165.72, + "end": 1165.86 + }, + { + "word": "of", + "start": 1165.86, + "end": 1165.98 + }, + { + "word": "this", + "start": 1165.98, + "end": 1166.18 + }, + { + "word": "as", + "start": 1166.18, + "end": 1166.42 + }, + { + "word": "like", + "start": 1166.42, + "end": 1167.16 + }, + { + "word": "a", + "start": 1167.16, + "end": 1167.42 + }, + { + "word": "union", + "start": 1167.42, + "end": 1167.94 + }, + { + "word": "of", + "start": 1167.94, + "end": 1168.88 + }, + { + "word": "the", + "start": 1168.88, + "end": 1169.28 + }, + { + "word": "URL", + "start": 1169.28, + "end": 1169.58 + }, + { + "word": "headers", + "start": 1169.58, + "end": 1169.9 + }, + { + "word": "object", + "start": 1169.9, + "end": 1170.52 + }, + { + "word": "and", + "start": 1170.52, + "end": 1170.88 + }, + { + "word": "then", + "start": 1170.88, + "end": 1171.38 + }, + { + "word": "the", + "start": 1171.38, + "end": 1171.62 + }, + { + "word": "HTML", + "start": 1171.62, + "end": 1171.88 + }, + { + "word": "origin", + "start": 1171.88, + "end": 1172.3 + } + ] + }, + { + "start": 1172.3, + "end": 1179.64, + "text": "object. And the JSON schema looks something a little bit like this. So you have this any of", + "words": [ + { + "word": "object.", + "start": 1172.3, + "end": 1172.84 + }, + { + "word": "And", + "start": 1174.2, + "end": 1174.68 + }, + { + "word": "the", + "start": 1174.68, + "end": 1175.0 + }, + { + "word": "JSON", + "start": 1175.0, + "end": 1175.18 + }, + { + "word": "schema", + "start": 1175.18, + "end": 1175.4 + }, + { + "word": "looks", + "start": 1175.4, + "end": 1175.82 + }, + { + "word": "something", + "start": 1175.82, + "end": 1176.3 + }, + { + "word": "a", + "start": 1176.3, + "end": 1176.5 + }, + { + "word": "little", + "start": 1176.5, + "end": 1176.64 + }, + { + "word": "bit", + "start": 1176.64, + "end": 1176.78 + }, + { + "word": "like", + "start": 1176.78, + "end": 1177.02 + }, + { + "word": "this.", + "start": 1177.02, + "end": 1177.68 + }, + { + "word": "So", + "start": 1178.16, + "end": 1178.4 + }, + { + "word": "you", + "start": 1178.4, + "end": 1178.64 + }, + { + "word": "have", + "start": 1178.64, + "end": 1178.72 + }, + { + "word": "this", + "start": 1178.72, + "end": 1178.98 + }, + { + "word": "any", + "start": 1178.98, + "end": 1179.22 + }, + { + "word": "of", + "start": 1179.22, + "end": 1179.64 + } + ] + }, + { + "start": 1180.4, + "end": 1184.44, + "text": "and there's two objects. I think the thing to really note here is like this is like", + "words": [ + { + "word": "and", + "start": 1180.4, + "end": 1180.88 + }, + { + "word": "there's", + "start": 1180.88, + "end": 1181.1 + }, + { + "word": "two", + "start": 1181.1, + "end": 1181.28 + }, + { + "word": "objects.", + "start": 1181.28, + "end": 1181.58 + }, + { + "word": "I", + "start": 1181.76, + "end": 1181.92 + }, + { + "word": "think", + "start": 1181.92, + "end": 1182.12 + }, + { + "word": "the", + "start": 1182.12, + "end": 1182.34 + }, + { + "word": "thing", + "start": 1182.34, + "end": 1182.42 + }, + { + "word": "to", + "start": 1182.42, + "end": 1182.64 + }, + { + "word": "really", + "start": 1182.64, + "end": 1182.88 + }, + { + "word": "note", + "start": 1182.88, + "end": 1183.06 + }, + { + "word": "here", + "start": 1183.06, + "end": 1183.32 + }, + { + "word": "is", + "start": 1183.32, + "end": 1183.46 + }, + { + "word": "like", + "start": 1183.46, + "end": 1183.6 + }, + { + "word": "this", + "start": 1183.6, + "end": 1183.76 + }, + { + "word": "is", + "start": 1183.76, + "end": 1183.96 + }, + { + "word": "like", + "start": 1183.96, + "end": 1184.44 + } + ] + }, + { + "start": 1184.44, + "end": 1189.72, + "text": "not a traditional discriminated union. There's not a key to like I can just check. It's like", + "words": [ + { + "word": "not", + "start": 1184.44, + "end": 1184.92 + }, + { + "word": "a", + "start": 1184.92, + "end": 1185.28 + }, + { + "word": "traditional", + "start": 1185.28, + "end": 1185.82 + }, + { + "word": "discriminated", + "start": 1185.82, + "end": 1186.4 + }, + { + "word": "union.", + "start": 1186.4, + "end": 1186.68 + }, + { + "word": "There's", + "start": 1186.76, + "end": 1186.84 + }, + { + "word": "not", + "start": 1186.84, + "end": 1187.02 + }, + { + "word": "a", + "start": 1187.02, + "end": 1187.18 + }, + { + "word": "key", + "start": 1187.18, + "end": 1187.62 + }, + { + "word": "to", + "start": 1187.62, + "end": 1188.26 + }, + { + "word": "like", + "start": 1188.26, + "end": 1188.66 + }, + { + "word": "I", + "start": 1188.66, + "end": 1188.8 + }, + { + "word": "can", + "start": 1188.8, + "end": 1189.0 + }, + { + "word": "just", + "start": 1189.0, + "end": 1189.3 + }, + { + "word": "check.", + "start": 1189.3, + "end": 1189.48 + }, + { + "word": "It's", + "start": 1189.52, + "end": 1189.6 + }, + { + "word": "like", + "start": 1189.6, + "end": 1189.72 + } + ] + }, + { + "start": 1189.72, + "end": 1198.76, + "text": "what type is this? So oftentimes for an expressive and intuitive API you want to use untagged enums.", + "words": [ + { + "word": "what", + "start": 1189.72, + "end": 1189.9 + }, + { + "word": "type", + "start": 1189.9, + "end": 1190.12 + }, + { + "word": "is", + "start": 1190.12, + "end": 1190.36 + }, + { + "word": "this?", + "start": 1190.36, + "end": 1190.76 + }, + { + "word": "So", + "start": 1191.6, + "end": 1192.12 + }, + { + "word": "oftentimes", + "start": 1192.12, + "end": 1192.58 + }, + { + "word": "for", + "start": 1192.58, + "end": 1193.2 + }, + { + "word": "an", + "start": 1193.2, + "end": 1193.5 + }, + { + "word": "expressive", + "start": 1193.5, + "end": 1194.06 + }, + { + "word": "and", + "start": 1194.06, + "end": 1194.36 + }, + { + "word": "intuitive", + "start": 1194.36, + "end": 1194.76 + }, + { + "word": "API", + "start": 1194.76, + "end": 1195.28 + }, + { + "word": "you", + "start": 1195.28, + "end": 1195.72 + }, + { + "word": "want", + "start": 1195.72, + "end": 1195.96 + }, + { + "word": "to", + "start": 1195.96, + "end": 1196.16 + }, + { + "word": "use", + "start": 1196.16, + "end": 1196.9 + }, + { + "word": "untagged", + "start": 1196.9, + "end": 1198.38 + }, + { + "word": "enums.", + "start": 1198.38, + "end": 1198.76 + } + ] + }, + { + "start": 1199.44, + "end": 1203.32, + "text": "But there be dragons. You have to be really, really careful because there's this", + "words": [ + { + "word": "But", + "start": 1199.44, + "end": 1199.82 + }, + { + "word": "there", + "start": 1199.82, + "end": 1200.16 + }, + { + "word": "be", + "start": 1200.16, + "end": 1200.3 + }, + { + "word": "dragons.", + "start": 1200.3, + "end": 1200.64 + }, + { + "word": "You", + "start": 1200.7, + "end": 1200.78 + }, + { + "word": "have", + "start": 1200.78, + "end": 1200.92 + }, + { + "word": "to", + "start": 1200.92, + "end": 1201.02 + }, + { + "word": "be", + "start": 1201.02, + "end": 1201.26 + }, + { + "word": "really,", + "start": 1201.26, + "end": 1201.6 + }, + { + "word": "really", + "start": 1201.6, + "end": 1201.82 + }, + { + "word": "careful", + "start": 1201.82, + "end": 1202.14 + }, + { + "word": "because", + "start": 1202.14, + "end": 1202.44 + }, + { + "word": "there's", + "start": 1202.44, + "end": 1202.84 + }, + { + "word": "this", + "start": 1202.84, + "end": 1203.32 + } + ] + }, + { + "start": 1203.32, + "end": 1206.98, + "text": "ambiguity that can come in when you don't have an explicit key.", + "words": [ + { + "word": "ambiguity", + "start": 1203.32, + "end": 1204.22 + }, + { + "word": "that", + "start": 1204.22, + "end": 1204.6 + }, + { + "word": "can", + "start": 1204.6, + "end": 1204.76 + }, + { + "word": "come", + "start": 1204.76, + "end": 1204.96 + }, + { + "word": "in", + "start": 1204.96, + "end": 1205.4 + }, + { + "word": "when", + "start": 1205.4, + "end": 1205.54 + }, + { + "word": "you", + "start": 1205.54, + "end": 1205.68 + }, + { + "word": "don't", + "start": 1205.68, + "end": 1205.92 + }, + { + "word": "have", + "start": 1205.92, + "end": 1206.06 + }, + { + "word": "an", + "start": 1206.06, + "end": 1206.22 + }, + { + "word": "explicit", + "start": 1206.22, + "end": 1206.54 + }, + { + "word": "key.", + "start": 1206.54, + "end": 1206.98 + } + ] + }, + { + "start": 1209.52, + "end": 1213.5, + "text": "So yeah, I mean I mentioned this a few times already. But co-gen is akin to translation.", + "words": [ + { + "word": "So", + "start": 1209.52, + "end": 1209.8 + }, + { + "word": "yeah,", + "start": 1209.8, + "end": 1210.12 + }, + { + "word": "I", + "start": 1210.14, + "end": 1210.42 + }, + { + "word": "mean", + "start": 1210.42, + "end": 1210.46 + }, + { + "word": "I", + "start": 1210.46, + "end": 1210.58 + }, + { + "word": "mentioned", + "start": 1210.58, + "end": 1210.74 + }, + { + "word": "this", + "start": 1210.74, + "end": 1210.94 + }, + { + "word": "a", + "start": 1210.94, + "end": 1211.04 + }, + { + "word": "few", + "start": 1211.04, + "end": 1211.12 + }, + { + "word": "times", + "start": 1211.12, + "end": 1211.36 + }, + { + "word": "already.", + "start": 1211.36, + "end": 1211.7 + }, + { + "word": "But", + "start": 1211.92, + "end": 1212.16 + }, + { + "word": "co", + "start": 1212.16, + "end": 1212.3 + }, + { + "word": "-gen", + "start": 1212.3, + "end": 1212.4 + }, + { + "word": "is", + "start": 1212.4, + "end": 1212.62 + }, + { + "word": "akin", + "start": 1212.62, + "end": 1212.78 + }, + { + "word": "to", + "start": 1212.78, + "end": 1212.98 + }, + { + "word": "translation.", + "start": 1212.98, + "end": 1213.5 + } + ] + }, + { + "start": 1213.5, + "end": 1219.08, + "text": "Just like you can't translate everything from one language, spoken language, to another spoken", + "words": [ + { + "word": "Just", + "start": 1213.5, + "end": 1213.98 + }, + { + "word": "like", + "start": 1213.98, + "end": 1214.46 + }, + { + "word": "you", + "start": 1214.46, + "end": 1214.98 + }, + { + "word": "can't", + "start": 1214.98, + "end": 1215.38 + }, + { + "word": "translate", + "start": 1215.38, + "end": 1215.76 + }, + { + "word": "everything", + "start": 1215.76, + "end": 1216.22 + }, + { + "word": "from", + "start": 1216.22, + "end": 1216.54 + }, + { + "word": "one", + "start": 1216.54, + "end": 1216.8 + }, + { + "word": "language,", + "start": 1216.8, + "end": 1217.42 + }, + { + "word": "spoken", + "start": 1217.72, + "end": 1217.86 + }, + { + "word": "language,", + "start": 1217.86, + "end": 1218.24 + }, + { + "word": "to", + "start": 1218.36, + "end": 1218.5 + }, + { + "word": "another", + "start": 1218.5, + "end": 1218.8 + }, + { + "word": "spoken", + "start": 1218.8, + "end": 1219.08 + } + ] + }, + { + "start": 1219.08, + "end": 1223.76, + "text": "language because there might not be a word for it or the cultural concept might not exist. The", + "words": [ + { + "word": "language", + "start": 1219.08, + "end": 1219.46 + }, + { + "word": "because", + "start": 1219.46, + "end": 1219.88 + }, + { + "word": "there", + "start": 1219.88, + "end": 1220.22 + }, + { + "word": "might", + "start": 1220.22, + "end": 1220.42 + }, + { + "word": "not", + "start": 1220.42, + "end": 1220.52 + }, + { + "word": "be", + "start": 1220.52, + "end": 1220.64 + }, + { + "word": "a", + "start": 1220.64, + "end": 1220.76 + }, + { + "word": "word", + "start": 1220.76, + "end": 1220.9 + }, + { + "word": "for", + "start": 1220.9, + "end": 1221.26 + }, + { + "word": "it", + "start": 1221.26, + "end": 1221.66 + }, + { + "word": "or", + "start": 1221.66, + "end": 1221.84 + }, + { + "word": "the", + "start": 1221.84, + "end": 1222.04 + }, + { + "word": "cultural", + "start": 1222.04, + "end": 1222.4 + }, + { + "word": "concept", + "start": 1222.4, + "end": 1222.78 + }, + { + "word": "might", + "start": 1222.78, + "end": 1222.98 + }, + { + "word": "not", + "start": 1222.98, + "end": 1223.16 + }, + { + "word": "exist.", + "start": 1223.16, + "end": 1223.52 + }, + { + "word": "The", + "start": 1223.54, + "end": 1223.76 + } + ] + }, + { + "start": 1223.76, + "end": 1229.36, + "text": "same thing is true of programming languages. There are just like some concepts that don't work.", + "words": [ + { + "word": "same", + "start": 1223.76, + "end": 1224.02 + }, + { + "word": "thing", + "start": 1224.02, + "end": 1224.46 + }, + { + "word": "is", + "start": 1224.46, + "end": 1225.16 + }, + { + "word": "true", + "start": 1225.16, + "end": 1225.52 + }, + { + "word": "of", + "start": 1225.52, + "end": 1226.1 + }, + { + "word": "programming", + "start": 1226.1, + "end": 1226.44 + }, + { + "word": "languages.", + "start": 1226.44, + "end": 1226.8 + }, + { + "word": "There", + "start": 1226.9, + "end": 1227.14 + }, + { + "word": "are", + "start": 1227.14, + "end": 1227.24 + }, + { + "word": "just", + "start": 1227.24, + "end": 1227.44 + }, + { + "word": "like", + "start": 1227.44, + "end": 1227.66 + }, + { + "word": "some", + "start": 1227.66, + "end": 1227.84 + }, + { + "word": "concepts", + "start": 1227.84, + "end": 1228.3 + }, + { + "word": "that", + "start": 1228.3, + "end": 1228.54 + }, + { + "word": "don't", + "start": 1228.54, + "end": 1228.76 + }, + { + "word": "work.", + "start": 1228.76, + "end": 1229.36 + } + ] + }, + { + "start": 1230.02, + "end": 1236.94, + "text": "And that is a big limiting factor because you're really limited by the least expressive language", + "words": [ + { + "word": "And", + "start": 1230.02, + "end": 1230.7 + }, + { + "word": "that", + "start": 1230.7, + "end": 1231.88 + }, + { + "word": "is", + "start": 1231.88, + "end": 1232.4 + }, + { + "word": "a", + "start": 1232.4, + "end": 1232.7 + }, + { + "word": "big", + "start": 1232.7, + "end": 1232.82 + }, + { + "word": "limiting", + "start": 1232.82, + "end": 1233.08 + }, + { + "word": "factor", + "start": 1233.08, + "end": 1233.48 + }, + { + "word": "because", + "start": 1233.48, + "end": 1233.92 + }, + { + "word": "you're", + "start": 1233.92, + "end": 1234.42 + }, + { + "word": "really", + "start": 1234.42, + "end": 1234.72 + }, + { + "word": "limited", + "start": 1234.72, + "end": 1235.26 + }, + { + "word": "by", + "start": 1235.26, + "end": 1235.74 + }, + { + "word": "the", + "start": 1235.74, + "end": 1235.96 + }, + { + "word": "least", + "start": 1235.96, + "end": 1236.24 + }, + { + "word": "expressive", + "start": 1236.24, + "end": 1236.6 + }, + { + "word": "language", + "start": 1236.6, + "end": 1236.94 + } + ] + }, + { + "start": 1236.94, + "end": 1244.06, + "text": "that you're targeting. So it's also another thing to think about. It's like you could try", + "words": [ + { + "word": "that", + "start": 1236.94, + "end": 1237.1 + }, + { + "word": "you're", + "start": 1237.1, + "end": 1238.36 + }, + { + "word": "targeting.", + "start": 1238.36, + "end": 1238.94 + }, + { + "word": "So", + "start": 1239.52, + "end": 1239.92 + }, + { + "word": "it's", + "start": 1239.92, + "end": 1240.18 + }, + { + "word": "also", + "start": 1240.18, + "end": 1240.42 + }, + { + "word": "another", + "start": 1240.42, + "end": 1240.66 + }, + { + "word": "thing", + "start": 1240.66, + "end": 1241.12 + }, + { + "word": "to", + "start": 1241.12, + "end": 1241.32 + }, + { + "word": "think", + "start": 1241.32, + "end": 1241.48 + }, + { + "word": "about.", + "start": 1241.48, + "end": 1241.74 + }, + { + "word": "It's", + "start": 1241.94, + "end": 1242.06 + }, + { + "word": "like", + "start": 1242.06, + "end": 1243.06 + }, + { + "word": "you", + "start": 1243.06, + "end": 1243.48 + }, + { + "word": "could", + "start": 1243.48, + "end": 1243.74 + }, + { + "word": "try", + "start": 1243.74, + "end": 1244.06 + } + ] + }, + { + "start": 1244.06, + "end": 1250.96, + "text": "to generate something that targets bash, but like should you? You might be in for a bad time or", + "words": [ + { + "word": "to", + "start": 1244.06, + "end": 1244.3 + }, + { + "word": "generate", + "start": 1244.3, + "end": 1244.6 + }, + { + "word": "something", + "start": 1244.6, + "end": 1245.2 + }, + { + "word": "that", + "start": 1245.2, + "end": 1245.56 + }, + { + "word": "targets", + "start": 1245.56, + "end": 1246.0 + }, + { + "word": "bash,", + "start": 1246.0, + "end": 1246.52 + }, + { + "word": "but", + "start": 1246.74, + "end": 1246.88 + }, + { + "word": "like", + "start": 1246.88, + "end": 1247.18 + }, + { + "word": "should", + "start": 1247.18, + "end": 1247.34 + }, + { + "word": "you?", + "start": 1247.34, + "end": 1248.0 + }, + { + "word": "You", + "start": 1248.62, + "end": 1249.1 + }, + { + "word": "might", + "start": 1249.1, + "end": 1249.3 + }, + { + "word": "be", + "start": 1249.3, + "end": 1249.44 + }, + { + "word": "in", + "start": 1249.44, + "end": 1249.46 + }, + { + "word": "for", + "start": 1249.46, + "end": 1249.64 + }, + { + "word": "a", + "start": 1249.64, + "end": 1249.74 + }, + { + "word": "bad", + "start": 1249.74, + "end": 1249.92 + }, + { + "word": "time", + "start": 1249.92, + "end": 1250.38 + }, + { + "word": "or", + "start": 1250.38, + "end": 1250.96 + } + ] + }, + { + "start": 1250.96, + "end": 1256.24, + "text": "you might need to explicitly accept that the generation for that is just not going to be good.", + "words": [ + { + "word": "you", + "start": 1250.96, + "end": 1251.36 + }, + { + "word": "might", + "start": 1251.36, + "end": 1251.58 + }, + { + "word": "need", + "start": 1251.58, + "end": 1251.72 + }, + { + "word": "to", + "start": 1251.72, + "end": 1252.0 + }, + { + "word": "explicitly", + "start": 1252.0, + "end": 1252.42 + }, + { + "word": "accept", + "start": 1252.42, + "end": 1253.26 + }, + { + "word": "that", + "start": 1253.26, + "end": 1253.74 + }, + { + "word": "the", + "start": 1253.74, + "end": 1253.96 + }, + { + "word": "generation", + "start": 1253.96, + "end": 1254.3 + }, + { + "word": "for", + "start": 1254.3, + "end": 1254.54 + }, + { + "word": "that", + "start": 1254.54, + "end": 1254.66 + }, + { + "word": "is", + "start": 1254.66, + "end": 1254.82 + }, + { + "word": "just", + "start": 1254.82, + "end": 1255.12 + }, + { + "word": "not", + "start": 1255.12, + "end": 1255.4 + }, + { + "word": "going", + "start": 1255.4, + "end": 1255.52 + }, + { + "word": "to", + "start": 1255.52, + "end": 1255.62 + }, + { + "word": "be", + "start": 1255.62, + "end": 1255.84 + }, + { + "word": "good.", + "start": 1255.84, + "end": 1256.24 + } + ] + }, + { + "start": 1256.68, + "end": 1261.72, + "text": "And I think like if you target is sort of like, hey, this is like a secondary kind of supported,", + "words": [ + { + "word": "And", + "start": 1256.68, + "end": 1256.94 + }, + { + "word": "I", + "start": 1256.94, + "end": 1257.1 + }, + { + "word": "think", + "start": 1257.1, + "end": 1257.32 + }, + { + "word": "like", + "start": 1257.32, + "end": 1257.5 + }, + { + "word": "if", + "start": 1257.5, + "end": 1257.62 + }, + { + "word": "you", + "start": 1257.62, + "end": 1258.1 + }, + { + "word": "target", + "start": 1258.1, + "end": 1258.34 + }, + { + "word": "is", + "start": 1258.34, + "end": 1258.6 + }, + { + "word": "sort", + "start": 1258.6, + "end": 1258.78 + }, + { + "word": "of", + "start": 1258.78, + "end": 1258.96 + }, + { + "word": "like,", + "start": 1258.96, + "end": 1259.22 + }, + { + "word": "hey,", + "start": 1259.5, + "end": 1259.78 + }, + { + "word": "this", + "start": 1259.84, + "end": 1260.04 + }, + { + "word": "is", + "start": 1260.04, + "end": 1260.18 + }, + { + "word": "like", + "start": 1260.18, + "end": 1260.3 + }, + { + "word": "a", + "start": 1260.3, + "end": 1260.54 + }, + { + "word": "secondary", + "start": 1260.54, + "end": 1261.0 + }, + { + "word": "kind", + "start": 1261.0, + "end": 1261.34 + }, + { + "word": "of", + "start": 1261.34, + "end": 1261.56 + }, + { + "word": "supported,", + "start": 1261.56, + "end": 1261.72 + } + ] + }, + { + "start": 1261.72, + "end": 1266.16, + "text": "not really supported thing, that you still may be able to get something interesting out of it. But", + "words": [ + { + "word": "not", + "start": 1261.72, + "end": 1261.92 + }, + { + "word": "really", + "start": 1261.92, + "end": 1262.2 + }, + { + "word": "supported", + "start": 1262.2, + "end": 1262.6 + }, + { + "word": "thing,", + "start": 1262.6, + "end": 1263.02 + }, + { + "word": "that", + "start": 1263.4, + "end": 1263.4 + }, + { + "word": "you", + "start": 1263.4, + "end": 1263.96 + }, + { + "word": "still", + "start": 1263.96, + "end": 1264.18 + }, + { + "word": "may", + "start": 1264.18, + "end": 1264.32 + }, + { + "word": "be", + "start": 1264.32, + "end": 1264.42 + }, + { + "word": "able", + "start": 1264.42, + "end": 1264.5 + }, + { + "word": "to", + "start": 1264.5, + "end": 1264.6 + }, + { + "word": "get", + "start": 1264.6, + "end": 1264.66 + }, + { + "word": "something", + "start": 1264.66, + "end": 1264.9 + }, + { + "word": "interesting", + "start": 1264.9, + "end": 1265.28 + }, + { + "word": "out", + "start": 1265.28, + "end": 1265.46 + }, + { + "word": "of", + "start": 1265.46, + "end": 1265.56 + }, + { + "word": "it.", + "start": 1265.56, + "end": 1265.7 + }, + { + "word": "But", + "start": 1265.7, + "end": 1266.16 + } + ] + }, + { + "start": 1266.94, + "end": 1275.66, + "text": "you know, this does add a lot to the overhead of this approach. And Rust is very expressive.", + "words": [ + { + "word": "you", + "start": 1266.94, + "end": 1267.3 + }, + { + "word": "know,", + "start": 1267.3, + "end": 1267.74 + }, + { + "word": "this", + "start": 1268.3, + "end": 1268.58 + }, + { + "word": "does", + "start": 1268.58, + "end": 1269.0 + }, + { + "word": "add", + "start": 1269.0, + "end": 1269.26 + }, + { + "word": "a", + "start": 1269.26, + "end": 1269.48 + }, + { + "word": "lot", + "start": 1269.48, + "end": 1269.9 + }, + { + "word": "to", + "start": 1269.9, + "end": 1270.44 + }, + { + "word": "the", + "start": 1270.44, + "end": 1270.72 + }, + { + "word": "overhead", + "start": 1270.72, + "end": 1271.1 + }, + { + "word": "of", + "start": 1271.1, + "end": 1271.38 + }, + { + "word": "this", + "start": 1271.38, + "end": 1271.54 + }, + { + "word": "approach.", + "start": 1271.54, + "end": 1272.12 + }, + { + "word": "And", + "start": 1273.92, + "end": 1274.28 + }, + { + "word": "Rust", + "start": 1274.28, + "end": 1274.44 + }, + { + "word": "is", + "start": 1274.44, + "end": 1274.72 + }, + { + "word": "very", + "start": 1274.72, + "end": 1275.16 + }, + { + "word": "expressive.", + "start": 1275.16, + "end": 1275.66 + } + ] + }, + { + "start": 1275.9, + "end": 1282.56, + "text": "You can express all kinds of things. Enums themselves are incredibly, incredibly expressive.", + "words": [ + { + "word": "You", + "start": 1275.9, + "end": 1276.12 + }, + { + "word": "can", + "start": 1276.12, + "end": 1276.5 + }, + { + "word": "express", + "start": 1276.5, + "end": 1276.84 + }, + { + "word": "all", + "start": 1276.84, + "end": 1277.24 + }, + { + "word": "kinds", + "start": 1277.24, + "end": 1277.48 + }, + { + "word": "of", + "start": 1277.48, + "end": 1277.7 + }, + { + "word": "things.", + "start": 1277.7, + "end": 1278.16 + }, + { + "word": "Enums", + "start": 1278.64, + "end": 1278.96 + }, + { + "word": "themselves", + "start": 1278.96, + "end": 1279.7 + }, + { + "word": "are", + "start": 1279.7, + "end": 1280.16 + }, + { + "word": "incredibly,", + "start": 1280.16, + "end": 1280.94 + }, + { + "word": "incredibly", + "start": 1280.94, + "end": 1281.48 + }, + { + "word": "expressive.", + "start": 1281.48, + "end": 1282.56 + } + ] + }, + { + "start": 1282.74, + "end": 1289.08, + "text": "They're amazing, but also terrible. And so I want to talk a little bit about the expressiveness trap", + "words": [ + { + "word": "They're", + "start": 1282.74, + "end": 1283.2 + }, + { + "word": "amazing,", + "start": 1283.2, + "end": 1283.76 + }, + { + "word": "but", + "start": 1283.94, + "end": 1284.12 + }, + { + "word": "also", + "start": 1284.12, + "end": 1284.58 + }, + { + "word": "terrible.", + "start": 1284.58, + "end": 1285.08 + }, + { + "word": "And", + "start": 1286.66, + "end": 1286.96 + }, + { + "word": "so", + "start": 1286.96, + "end": 1287.12 + }, + { + "word": "I", + "start": 1287.12, + "end": 1287.18 + }, + { + "word": "want", + "start": 1287.18, + "end": 1287.34 + }, + { + "word": "to", + "start": 1287.34, + "end": 1287.44 + }, + { + "word": "talk", + "start": 1287.44, + "end": 1287.6 + }, + { + "word": "a", + "start": 1287.6, + "end": 1287.72 + }, + { + "word": "little", + "start": 1287.72, + "end": 1287.88 + }, + { + "word": "bit", + "start": 1287.88, + "end": 1288.02 + }, + { + "word": "about", + "start": 1288.02, + "end": 1288.16 + }, + { + "word": "the", + "start": 1288.16, + "end": 1288.52 + }, + { + "word": "expressiveness", + "start": 1288.52, + "end": 1288.82 + }, + { + "word": "trap", + "start": 1288.82, + "end": 1289.08 + } + ] + }, + { + "start": 1289.08, + "end": 1295.58, + "text": "because this is the biggest thing that will just bite you. Here I have a very simple example. This", + "words": [ + { + "word": "because", + "start": 1289.08, + "end": 1289.22 + }, + { + "word": "this", + "start": 1289.22, + "end": 1289.44 + }, + { + "word": "is", + "start": 1289.44, + "end": 1289.64 + }, + { + "word": "the", + "start": 1289.64, + "end": 1290.0 + }, + { + "word": "biggest", + "start": 1290.0, + "end": 1290.34 + }, + { + "word": "thing", + "start": 1290.34, + "end": 1290.84 + }, + { + "word": "that", + "start": 1290.84, + "end": 1291.24 + }, + { + "word": "will", + "start": 1291.24, + "end": 1291.4 + }, + { + "word": "just", + "start": 1291.4, + "end": 1291.68 + }, + { + "word": "bite", + "start": 1291.68, + "end": 1291.82 + }, + { + "word": "you.", + "start": 1291.82, + "end": 1292.52 + }, + { + "word": "Here", + "start": 1292.86, + "end": 1293.1 + }, + { + "word": "I", + "start": 1293.1, + "end": 1293.24 + }, + { + "word": "have", + "start": 1293.24, + "end": 1293.46 + }, + { + "word": "a", + "start": 1293.46, + "end": 1293.6 + }, + { + "word": "very", + "start": 1293.6, + "end": 1294.2 + }, + { + "word": "simple", + "start": 1294.2, + "end": 1295.04 + }, + { + "word": "example.", + "start": 1295.04, + "end": 1295.42 + }, + { + "word": "This", + "start": 1295.42, + "end": 1295.58 + } + ] + }, + { + "start": 1295.58, + "end": 1301.04, + "text": "is actually in my project when I was adding Python support, I got really bitten by this.", + "words": [ + { + "word": "is", + "start": 1295.58, + "end": 1295.8 + }, + { + "word": "actually", + "start": 1295.8, + "end": 1296.02 + }, + { + "word": "in", + "start": 1296.02, + "end": 1296.58 + }, + { + "word": "my", + "start": 1296.58, + "end": 1297.38 + }, + { + "word": "project", + "start": 1297.38, + "end": 1297.84 + }, + { + "word": "when", + "start": 1297.84, + "end": 1298.48 + }, + { + "word": "I", + "start": 1298.48, + "end": 1298.58 + }, + { + "word": "was", + "start": 1298.58, + "end": 1298.68 + }, + { + "word": "adding", + "start": 1298.68, + "end": 1298.9 + }, + { + "word": "Python", + "start": 1298.9, + "end": 1299.24 + }, + { + "word": "support,", + "start": 1299.24, + "end": 1299.56 + }, + { + "word": "I", + "start": 1299.74, + "end": 1299.74 + }, + { + "word": "got", + "start": 1299.74, + "end": 1300.12 + }, + { + "word": "really", + "start": 1300.12, + "end": 1300.42 + }, + { + "word": "bitten", + "start": 1300.42, + "end": 1300.5 + }, + { + "word": "by", + "start": 1300.5, + "end": 1300.66 + }, + { + "word": "this.", + "start": 1300.66, + "end": 1301.04 + } + ] + }, + { + "start": 1301.62, + "end": 1307.18, + "text": "So here at the top, we have an untagged Rust enum window size, and it has two arms to the variant.", + "words": [ + { + "word": "So", + "start": 1301.62, + "end": 1301.62 + }, + { + "word": "here", + "start": 1301.62, + "end": 1301.9 + }, + { + "word": "at", + "start": 1301.9, + "end": 1302.0 + }, + { + "word": "the", + "start": 1302.0, + "end": 1302.12 + }, + { + "word": "top,", + "start": 1302.12, + "end": 1302.26 + }, + { + "word": "we", + "start": 1302.42, + "end": 1302.42 + }, + { + "word": "have", + "start": 1302.42, + "end": 1302.6 + }, + { + "word": "an", + "start": 1302.6, + "end": 1302.78 + }, + { + "word": "untagged", + "start": 1302.78, + "end": 1303.68 + }, + { + "word": "Rust", + "start": 1303.68, + "end": 1303.96 + }, + { + "word": "enum", + "start": 1303.96, + "end": 1304.5 + }, + { + "word": "window", + "start": 1304.5, + "end": 1304.84 + }, + { + "word": "size,", + "start": 1304.84, + "end": 1305.32 + }, + { + "word": "and", + "start": 1305.82, + "end": 1305.98 + }, + { + "word": "it", + "start": 1305.98, + "end": 1306.12 + }, + { + "word": "has", + "start": 1306.12, + "end": 1306.28 + }, + { + "word": "two", + "start": 1306.28, + "end": 1306.46 + }, + { + "word": "arms", + "start": 1306.46, + "end": 1306.66 + }, + { + "word": "to", + "start": 1306.66, + "end": 1306.8 + }, + { + "word": "the", + "start": 1306.8, + "end": 1306.94 + }, + { + "word": "variant.", + "start": 1306.94, + "end": 1307.18 + } + ] + }, + { + "start": 1307.68, + "end": 1312.88, + "text": "So we have this like states arm of the variant, and this is kind of like the function call,", + "words": [ + { + "word": "So", + "start": 1307.68, + "end": 1307.82 + }, + { + "word": "we", + "start": 1307.82, + "end": 1308.12 + }, + { + "word": "have", + "start": 1308.12, + "end": 1308.38 + }, + { + "word": "this", + "start": 1308.38, + "end": 1308.74 + }, + { + "word": "like", + "start": 1308.74, + "end": 1309.1 + }, + { + "word": "states", + "start": 1309.1, + "end": 1309.92 + }, + { + "word": "arm", + "start": 1309.92, + "end": 1310.64 + }, + { + "word": "of", + "start": 1310.64, + "end": 1310.76 + }, + { + "word": "the", + "start": 1310.76, + "end": 1310.86 + }, + { + "word": "variant,", + "start": 1310.86, + "end": 1311.08 + }, + { + "word": "and", + "start": 1311.16, + "end": 1311.24 + }, + { + "word": "this", + "start": 1311.24, + "end": 1311.4 + }, + { + "word": "is", + "start": 1311.4, + "end": 1311.5 + }, + { + "word": "kind", + "start": 1311.5, + "end": 1311.62 + }, + { + "word": "of", + "start": 1311.62, + "end": 1311.68 + }, + { + "word": "like", + "start": 1311.68, + "end": 1311.8 + }, + { + "word": "the", + "start": 1311.8, + "end": 1311.96 + }, + { + "word": "function", + "start": 1311.96, + "end": 1312.32 + }, + { + "word": "call,", + "start": 1312.32, + "end": 1312.88 + } + ] + }, + { + "start": 1312.88, + "end": 1318.86, + "text": "you know, variant. And then we have this like more object declarative syntax. I don't know. I", + "words": [ + { + "word": "you", + "start": 1312.88, + "end": 1313.08 + }, + { + "word": "know,", + "start": 1313.08, + "end": 1313.12 + }, + { + "word": "variant.", + "start": 1313.24, + "end": 1313.52 + }, + { + "word": "And", + "start": 1313.9, + "end": 1314.06 + }, + { + "word": "then", + "start": 1314.06, + "end": 1314.18 + }, + { + "word": "we", + "start": 1314.18, + "end": 1314.34 + }, + { + "word": "have", + "start": 1314.34, + "end": 1314.46 + }, + { + "word": "this", + "start": 1314.46, + "end": 1314.68 + }, + { + "word": "like", + "start": 1314.68, + "end": 1314.84 + }, + { + "word": "more", + "start": 1314.84, + "end": 1315.56 + }, + { + "word": "object", + "start": 1315.56, + "end": 1316.06 + }, + { + "word": "declarative", + "start": 1316.06, + "end": 1317.82 + }, + { + "word": "syntax.", + "start": 1317.82, + "end": 1318.34 + }, + { + "word": "I", + "start": 1318.52, + "end": 1318.52 + }, + { + "word": "don't", + "start": 1318.52, + "end": 1318.64 + }, + { + "word": "know.", + "start": 1318.64, + "end": 1318.76 + }, + { + "word": "I", + "start": 1318.76, + "end": 1318.86 + } + ] + }, + { + "start": 1318.86, + "end": 1323.74, + "text": "don't know what the names of these are. But anyway, they're not uniform. They're not of the same type.", + "words": [ + { + "word": "don't", + "start": 1318.86, + "end": 1318.96 + }, + { + "word": "know", + "start": 1318.96, + "end": 1319.04 + }, + { + "word": "what", + "start": 1319.04, + "end": 1319.16 + }, + { + "word": "the", + "start": 1319.16, + "end": 1319.28 + }, + { + "word": "names", + "start": 1319.28, + "end": 1319.4 + }, + { + "word": "of", + "start": 1319.4, + "end": 1319.54 + }, + { + "word": "these", + "start": 1319.54, + "end": 1319.68 + }, + { + "word": "are.", + "start": 1319.68, + "end": 1319.88 + }, + { + "word": "But", + "start": 1320.12, + "end": 1320.28 + }, + { + "word": "anyway,", + "start": 1320.28, + "end": 1320.6 + }, + { + "word": "they're", + "start": 1321.42, + "end": 1321.82 + }, + { + "word": "not", + "start": 1321.82, + "end": 1322.24 + }, + { + "word": "uniform.", + "start": 1322.24, + "end": 1322.58 + }, + { + "word": "They're", + "start": 1322.64, + "end": 1322.72 + }, + { + "word": "not", + "start": 1322.72, + "end": 1322.92 + }, + { + "word": "of", + "start": 1322.92, + "end": 1323.08 + }, + { + "word": "the", + "start": 1323.08, + "end": 1323.22 + }, + { + "word": "same", + "start": 1323.22, + "end": 1323.4 + }, + { + "word": "type.", + "start": 1323.4, + "end": 1323.74 + } + ] + }, + { + "start": 1323.74, + "end": 1328.68, + "text": "And you could also just have like a bare variant arm that like doesn't have any arguments or any", + "words": [ + { + "word": "And", + "start": 1323.74, + "end": 1324.12 + }, + { + "word": "you", + "start": 1324.12, + "end": 1324.3 + }, + { + "word": "could", + "start": 1324.3, + "end": 1324.5 + }, + { + "word": "also", + "start": 1324.5, + "end": 1324.74 + }, + { + "word": "just", + "start": 1324.74, + "end": 1324.98 + }, + { + "word": "have", + "start": 1324.98, + "end": 1325.12 + }, + { + "word": "like", + "start": 1325.12, + "end": 1325.32 + }, + { + "word": "a", + "start": 1325.32, + "end": 1325.5 + }, + { + "word": "bare", + "start": 1325.5, + "end": 1326.12 + }, + { + "word": "variant", + "start": 1326.12, + "end": 1326.58 + }, + { + "word": "arm", + "start": 1326.58, + "end": 1326.88 + }, + { + "word": "that", + "start": 1326.88, + "end": 1327.02 + }, + { + "word": "like", + "start": 1327.02, + "end": 1327.26 + }, + { + "word": "doesn't", + "start": 1327.26, + "end": 1327.46 + }, + { + "word": "have", + "start": 1327.46, + "end": 1327.74 + }, + { + "word": "any", + "start": 1327.74, + "end": 1328.0 + }, + { + "word": "arguments", + "start": 1328.0, + "end": 1328.3 + }, + { + "word": "or", + "start": 1328.3, + "end": 1328.48 + }, + { + "word": "any", + "start": 1328.48, + "end": 1328.68 + } + ] + }, + { + "start": 1328.68, + "end": 1337.74, + "text": "object, right? So I found that mixing types in an enum can actually cause tremendous problems", + "words": [ + { + "word": "object,", + "start": 1328.68, + "end": 1328.96 + }, + { + "word": "right?", + "start": 1329.1, + "end": 1329.64 + }, + { + "word": "So", + "start": 1330.04, + "end": 1330.64 + }, + { + "word": "I", + "start": 1330.64, + "end": 1331.68 + }, + { + "word": "found", + "start": 1331.68, + "end": 1332.24 + }, + { + "word": "that", + "start": 1332.24, + "end": 1332.98 + }, + { + "word": "mixing", + "start": 1332.98, + "end": 1333.76 + }, + { + "word": "types", + "start": 1333.76, + "end": 1334.5 + }, + { + "word": "in", + "start": 1334.5, + "end": 1334.7 + }, + { + "word": "an", + "start": 1334.7, + "end": 1334.86 + }, + { + "word": "enum", + "start": 1334.86, + "end": 1335.24 + }, + { + "word": "can", + "start": 1335.24, + "end": 1335.62 + }, + { + "word": "actually", + "start": 1335.62, + "end": 1335.92 + }, + { + "word": "cause", + "start": 1335.92, + "end": 1336.26 + }, + { + "word": "tremendous", + "start": 1336.26, + "end": 1337.16 + }, + { + "word": "problems", + "start": 1337.16, + "end": 1337.74 + } + ] + }, + { + "start": 1337.74, + "end": 1342.52, + "text": "downstream. There's a lot of languages that just cannot express these different types. And it gets", + "words": [ + { + "word": "downstream.", + "start": 1337.74, + "end": 1338.26 + }, + { + "word": "There's", + "start": 1338.6, + "end": 1338.78 + }, + { + "word": "a", + "start": 1338.78, + "end": 1338.88 + }, + { + "word": "lot", + "start": 1338.88, + "end": 1339.02 + }, + { + "word": "of", + "start": 1339.02, + "end": 1339.16 + }, + { + "word": "languages", + "start": 1339.16, + "end": 1339.42 + }, + { + "word": "that", + "start": 1339.42, + "end": 1339.66 + }, + { + "word": "just", + "start": 1339.66, + "end": 1339.98 + }, + { + "word": "cannot", + "start": 1339.98, + "end": 1340.48 + }, + { + "word": "express", + "start": 1340.48, + "end": 1341.28 + }, + { + "word": "these", + "start": 1341.28, + "end": 1341.62 + }, + { + "word": "different", + "start": 1341.62, + "end": 1341.86 + }, + { + "word": "types.", + "start": 1341.86, + "end": 1342.12 + }, + { + "word": "And", + "start": 1342.12, + "end": 1342.26 + }, + { + "word": "it", + "start": 1342.26, + "end": 1342.34 + }, + { + "word": "gets", + "start": 1342.34, + "end": 1342.52 + } + ] + }, + { + "start": 1342.52, + "end": 1351.82, + "text": "worse when you add untagged or if you add like flatten on one of the properties in the enum.", + "words": [ + { + "word": "worse", + "start": 1342.52, + "end": 1343.1 + }, + { + "word": "when", + "start": 1343.1, + "end": 1343.6 + }, + { + "word": "you", + "start": 1343.6, + "end": 1343.88 + }, + { + "word": "add", + "start": 1343.88, + "end": 1344.16 + }, + { + "word": "untagged", + "start": 1344.16, + "end": 1345.58 + }, + { + "word": "or", + "start": 1345.58, + "end": 1345.96 + }, + { + "word": "if", + "start": 1345.96, + "end": 1346.24 + }, + { + "word": "you", + "start": 1346.24, + "end": 1346.6 + }, + { + "word": "add", + "start": 1346.6, + "end": 1347.02 + }, + { + "word": "like", + "start": 1347.02, + "end": 1347.62 + }, + { + "word": "flatten", + "start": 1347.62, + "end": 1347.94 + }, + { + "word": "on", + "start": 1347.94, + "end": 1349.14 + }, + { + "word": "one", + "start": 1349.14, + "end": 1349.4 + }, + { + "word": "of", + "start": 1349.4, + "end": 1349.8 + }, + { + "word": "the", + "start": 1349.8, + "end": 1350.24 + }, + { + "word": "properties", + "start": 1350.24, + "end": 1350.74 + }, + { + "word": "in", + "start": 1350.74, + "end": 1351.04 + }, + { + "word": "the", + "start": 1351.04, + "end": 1351.16 + }, + { + "word": "enum.", + "start": 1351.16, + "end": 1351.82 + } + ] + }, + { + "start": 1352.5, + "end": 1357.26, + "text": "Probably talk a little bit more about those. But so this is the this is the TypeScript that", + "words": [ + { + "word": "Probably", + "start": 1352.5, + "end": 1352.96 + }, + { + "word": "talk", + "start": 1352.96, + "end": 1353.28 + }, + { + "word": "a", + "start": 1353.28, + "end": 1353.36 + }, + { + "word": "little", + "start": 1353.36, + "end": 1353.5 + }, + { + "word": "bit", + "start": 1353.5, + "end": 1353.58 + }, + { + "word": "more", + "start": 1353.58, + "end": 1353.76 + }, + { + "word": "about", + "start": 1353.76, + "end": 1353.98 + }, + { + "word": "those.", + "start": 1353.98, + "end": 1354.3 + }, + { + "word": "But", + "start": 1354.74, + "end": 1354.78 + }, + { + "word": "so", + "start": 1354.78, + "end": 1355.16 + }, + { + "word": "this", + "start": 1355.16, + "end": 1355.3 + }, + { + "word": "is", + "start": 1355.3, + "end": 1355.5 + }, + { + "word": "the", + "start": 1355.5, + "end": 1355.8 + }, + { + "word": "this", + "start": 1355.8, + "end": 1355.84 + }, + { + "word": "is", + "start": 1355.84, + "end": 1356.02 + }, + { + "word": "the", + "start": 1356.02, + "end": 1356.2 + }, + { + "word": "TypeScript", + "start": 1356.2, + "end": 1356.7 + }, + { + "word": "that", + "start": 1356.7, + "end": 1357.26 + } + ] + }, + { + "start": 1357.26, + "end": 1361.64, + "text": "generated from this. So my first implementation of this, I just had a TypeScript client and I was", + "words": [ + { + "word": "generated", + "start": 1357.26, + "end": 1357.84 + }, + { + "word": "from", + "start": 1357.84, + "end": 1358.06 + }, + { + "word": "this.", + "start": 1358.06, + "end": 1358.16 + }, + { + "word": "So", + "start": 1358.16, + "end": 1358.44 + }, + { + "word": "my", + "start": 1358.44, + "end": 1358.74 + }, + { + "word": "first", + "start": 1358.74, + "end": 1359.28 + }, + { + "word": "implementation", + "start": 1359.28, + "end": 1359.88 + }, + { + "word": "of", + "start": 1359.88, + "end": 1360.06 + }, + { + "word": "this,", + "start": 1360.06, + "end": 1360.18 + }, + { + "word": "I", + "start": 1360.2, + "end": 1360.3 + }, + { + "word": "just", + "start": 1360.3, + "end": 1360.44 + }, + { + "word": "had", + "start": 1360.44, + "end": 1360.54 + }, + { + "word": "a", + "start": 1360.54, + "end": 1360.7 + }, + { + "word": "TypeScript", + "start": 1360.7, + "end": 1361.0 + }, + { + "word": "client", + "start": 1361.0, + "end": 1361.3 + }, + { + "word": "and", + "start": 1361.3, + "end": 1361.46 + }, + { + "word": "I", + "start": 1361.46, + "end": 1361.54 + }, + { + "word": "was", + "start": 1361.54, + "end": 1361.64 + } + ] + }, + { + "start": 1361.64, + "end": 1366.46, + "text": "like, yeah, that looks reasonable. That's fine. That's good TypeScript. What's wrong with that?", + "words": [ + { + "word": "like,", + "start": 1361.64, + "end": 1362.16 + }, + { + "word": "yeah,", + "start": 1362.18, + "end": 1362.54 + }, + { + "word": "that", + "start": 1362.54, + "end": 1362.78 + }, + { + "word": "looks", + "start": 1362.78, + "end": 1362.94 + }, + { + "word": "reasonable.", + "start": 1362.94, + "end": 1363.36 + }, + { + "word": "That's", + "start": 1363.54, + "end": 1363.96 + }, + { + "word": "fine.", + "start": 1363.96, + "end": 1364.26 + }, + { + "word": "That's", + "start": 1364.3, + "end": 1364.52 + }, + { + "word": "good", + "start": 1364.52, + "end": 1364.66 + }, + { + "word": "TypeScript.", + "start": 1364.66, + "end": 1365.18 + }, + { + "word": "What's", + "start": 1365.52, + "end": 1365.74 + }, + { + "word": "wrong", + "start": 1365.74, + "end": 1365.8 + }, + { + "word": "with", + "start": 1365.8, + "end": 1365.98 + }, + { + "word": "that?", + "start": 1365.98, + "end": 1366.46 + } + ] + }, + { + "start": 1368.6, + "end": 1375.82, + "text": "But if you're representing that in a language like Python, how do you represent an object", + "words": [ + { + "word": "But", + "start": 1368.6, + "end": 1369.06 + }, + { + "word": "if", + "start": 1369.06, + "end": 1369.52 + }, + { + "word": "you're", + "start": 1369.52, + "end": 1370.66 + }, + { + "word": "representing", + "start": 1370.66, + "end": 1370.96 + }, + { + "word": "that", + "start": 1370.96, + "end": 1371.26 + }, + { + "word": "in", + "start": 1371.26, + "end": 1371.44 + }, + { + "word": "a", + "start": 1371.44, + "end": 1371.58 + }, + { + "word": "language", + "start": 1371.58, + "end": 1371.9 + }, + { + "word": "like", + "start": 1371.9, + "end": 1372.48 + }, + { + "word": "Python,", + "start": 1372.48, + "end": 1372.96 + }, + { + "word": "how", + "start": 1373.12, + "end": 1373.38 + }, + { + "word": "do", + "start": 1373.38, + "end": 1373.5 + }, + { + "word": "you", + "start": 1373.5, + "end": 1373.68 + }, + { + "word": "represent", + "start": 1373.68, + "end": 1374.32 + }, + { + "word": "an", + "start": 1374.32, + "end": 1375.36 + }, + { + "word": "object", + "start": 1375.36, + "end": 1375.82 + } + ] + }, + { + "start": 1375.82, + "end": 1383.68, + "text": "that has no name that's just a shape of a data type? I mean, you got to make something up,", + "words": [ + { + "word": "that", + "start": 1375.82, + "end": 1376.26 + }, + { + "word": "has", + "start": 1376.26, + "end": 1376.78 + }, + { + "word": "no", + "start": 1376.78, + "end": 1377.04 + }, + { + "word": "name", + "start": 1377.04, + "end": 1377.4 + }, + { + "word": "that's", + "start": 1377.4, + "end": 1377.92 + }, + { + "word": "just", + "start": 1377.92, + "end": 1378.22 + }, + { + "word": "a", + "start": 1378.22, + "end": 1378.48 + }, + { + "word": "shape", + "start": 1378.48, + "end": 1378.8 + }, + { + "word": "of", + "start": 1378.8, + "end": 1379.06 + }, + { + "word": "a", + "start": 1379.06, + "end": 1379.18 + }, + { + "word": "data", + "start": 1379.18, + "end": 1379.36 + }, + { + "word": "type?", + "start": 1379.36, + "end": 1379.74 + }, + { + "word": "I", + "start": 1381.5, + "end": 1381.94 + }, + { + "word": "mean,", + "start": 1381.94, + "end": 1382.24 + }, + { + "word": "you", + "start": 1382.24, + "end": 1382.5 + }, + { + "word": "got", + "start": 1382.5, + "end": 1382.66 + }, + { + "word": "to", + "start": 1382.66, + "end": 1382.94 + }, + { + "word": "make", + "start": 1382.94, + "end": 1383.08 + }, + { + "word": "something", + "start": 1383.08, + "end": 1383.32 + }, + { + "word": "up,", + "start": 1383.32, + "end": 1383.68 + } + ] + }, + { + "start": 1384.1, + "end": 1387.7, + "text": "like infer it based on the usage. Like you got to do something really weird.", + "words": [ + { + "word": "like", + "start": 1384.1, + "end": 1384.14 + }, + { + "word": "infer", + "start": 1384.14, + "end": 1384.36 + }, + { + "word": "it", + "start": 1384.36, + "end": 1384.52 + }, + { + "word": "based", + "start": 1384.52, + "end": 1384.74 + }, + { + "word": "on", + "start": 1384.74, + "end": 1384.88 + }, + { + "word": "the", + "start": 1384.88, + "end": 1385.1 + }, + { + "word": "usage.", + "start": 1385.1, + "end": 1385.48 + }, + { + "word": "Like", + "start": 1385.76, + "end": 1386.0 + }, + { + "word": "you", + "start": 1386.0, + "end": 1386.04 + }, + { + "word": "got", + "start": 1386.04, + "end": 1386.18 + }, + { + "word": "to", + "start": 1386.18, + "end": 1386.28 + }, + { + "word": "do", + "start": 1386.28, + "end": 1386.42 + }, + { + "word": "something", + "start": 1386.42, + "end": 1386.76 + }, + { + "word": "really", + "start": 1386.76, + "end": 1387.24 + }, + { + "word": "weird.", + "start": 1387.24, + "end": 1387.7 + } + ] + }, + { + "start": 1389.18, + "end": 1393.3, + "text": "And I tried. That was my first thing. It's like, oh, I'll just make it work. I'll like figure it", + "words": [ + { + "word": "And", + "start": 1389.18, + "end": 1389.62 + }, + { + "word": "I", + "start": 1389.62, + "end": 1390.06 + }, + { + "word": "tried.", + "start": 1390.06, + "end": 1390.44 + }, + { + "word": "That", + "start": 1390.68, + "end": 1390.84 + }, + { + "word": "was", + "start": 1390.84, + "end": 1390.94 + }, + { + "word": "my", + "start": 1390.94, + "end": 1391.1 + }, + { + "word": "first", + "start": 1391.1, + "end": 1391.36 + }, + { + "word": "thing.", + "start": 1391.36, + "end": 1391.52 + }, + { + "word": "It's", + "start": 1391.58, + "end": 1391.6 + }, + { + "word": "like,", + "start": 1391.6, + "end": 1391.72 + }, + { + "word": "oh,", + "start": 1391.72, + "end": 1391.9 + }, + { + "word": "I'll", + "start": 1391.9, + "end": 1392.02 + }, + { + "word": "just", + "start": 1392.02, + "end": 1392.2 + }, + { + "word": "make", + "start": 1392.2, + "end": 1392.32 + }, + { + "word": "it", + "start": 1392.32, + "end": 1392.46 + }, + { + "word": "work.", + "start": 1392.46, + "end": 1392.6 + }, + { + "word": "I'll", + "start": 1392.64, + "end": 1392.84 + }, + { + "word": "like", + "start": 1392.84, + "end": 1393.0 + }, + { + "word": "figure", + "start": 1393.0, + "end": 1393.14 + }, + { + "word": "it", + "start": 1393.14, + "end": 1393.3 + } + ] + }, + { + "start": 1393.3, + "end": 1398.68, + "text": "out. Right. That didn't work. And the actual solution, the thing that made it really simple", + "words": [ + { + "word": "out.", + "start": 1393.3, + "end": 1393.46 + }, + { + "word": "Right.", + "start": 1393.7, + "end": 1394.0 + }, + { + "word": "That", + "start": 1394.48, + "end": 1394.92 + }, + { + "word": "didn't", + "start": 1394.92, + "end": 1395.08 + }, + { + "word": "work.", + "start": 1395.08, + "end": 1395.48 + }, + { + "word": "And", + "start": 1395.72, + "end": 1396.16 + }, + { + "word": "the", + "start": 1396.16, + "end": 1396.44 + }, + { + "word": "actual", + "start": 1396.44, + "end": 1396.76 + }, + { + "word": "solution,", + "start": 1396.76, + "end": 1397.3 + }, + { + "word": "the", + "start": 1397.42, + "end": 1397.62 + }, + { + "word": "thing", + "start": 1397.62, + "end": 1397.7 + }, + { + "word": "that", + "start": 1397.7, + "end": 1397.88 + }, + { + "word": "made", + "start": 1397.88, + "end": 1397.98 + }, + { + "word": "it", + "start": 1397.98, + "end": 1398.14 + }, + { + "word": "really", + "start": 1398.14, + "end": 1398.3 + }, + { + "word": "simple", + "start": 1398.3, + "end": 1398.68 + } + ] + }, + { + "start": 1398.68, + "end": 1407.28, + "text": "is I just made the enum consistent. Just having the same shape makes it where this generates this", + "words": [ + { + "word": "is", + "start": 1398.68, + "end": 1398.88 + }, + { + "word": "I", + "start": 1398.88, + "end": 1398.96 + }, + { + "word": "just", + "start": 1398.96, + "end": 1399.7 + }, + { + "word": "made", + "start": 1399.7, + "end": 1400.46 + }, + { + "word": "the", + "start": 1400.46, + "end": 1400.76 + }, + { + "word": "enum", + "start": 1400.76, + "end": 1400.98 + }, + { + "word": "consistent.", + "start": 1400.98, + "end": 1401.68 + }, + { + "word": "Just", + "start": 1402.58, + "end": 1402.74 + }, + { + "word": "having", + "start": 1402.74, + "end": 1403.0 + }, + { + "word": "the", + "start": 1403.0, + "end": 1403.36 + }, + { + "word": "same", + "start": 1403.36, + "end": 1403.78 + }, + { + "word": "shape", + "start": 1403.78, + "end": 1404.42 + }, + { + "word": "makes", + "start": 1404.42, + "end": 1404.96 + }, + { + "word": "it", + "start": 1404.96, + "end": 1405.22 + }, + { + "word": "where", + "start": 1405.22, + "end": 1405.58 + }, + { + "word": "this", + "start": 1405.58, + "end": 1406.34 + }, + { + "word": "generates", + "start": 1406.34, + "end": 1406.84 + }, + { + "word": "this", + "start": 1406.84, + "end": 1407.28 + } + ] + }, + { + "start": 1407.28, + "end": 1414.98, + "text": "into a very simple union of two reference types. So it's like in Python, you can have a class that", + "words": [ + { + "word": "into", + "start": 1407.28, + "end": 1407.66 + }, + { + "word": "a", + "start": 1407.66, + "end": 1407.9 + }, + { + "word": "very", + "start": 1407.9, + "end": 1408.32 + }, + { + "word": "simple", + "start": 1408.32, + "end": 1409.22 + }, + { + "word": "union", + "start": 1409.22, + "end": 1409.76 + }, + { + "word": "of", + "start": 1409.76, + "end": 1410.36 + }, + { + "word": "two", + "start": 1410.36, + "end": 1410.74 + }, + { + "word": "reference", + "start": 1410.74, + "end": 1411.14 + }, + { + "word": "types.", + "start": 1411.14, + "end": 1411.62 + }, + { + "word": "So", + "start": 1411.82, + "end": 1411.92 + }, + { + "word": "it's", + "start": 1411.92, + "end": 1412.12 + }, + { + "word": "like", + "start": 1412.12, + "end": 1412.52 + }, + { + "word": "in", + "start": 1412.52, + "end": 1412.72 + }, + { + "word": "Python,", + "start": 1412.72, + "end": 1413.08 + }, + { + "word": "you", + "start": 1413.08, + "end": 1413.6 + }, + { + "word": "can", + "start": 1413.6, + "end": 1413.84 + }, + { + "word": "have", + "start": 1413.84, + "end": 1414.18 + }, + { + "word": "a", + "start": 1414.18, + "end": 1414.46 + }, + { + "word": "class", + "start": 1414.46, + "end": 1414.74 + }, + { + "word": "that", + "start": 1414.74, + "end": 1414.98 + } + ] + }, + { + "start": 1414.98, + "end": 1419.92, + "text": "defines size and a class that defines window size states and then just union them together. And it's", + "words": [ + { + "word": "defines", + "start": 1414.98, + "end": 1415.24 + }, + { + "word": "size", + "start": 1415.24, + "end": 1415.68 + }, + { + "word": "and", + "start": 1415.68, + "end": 1415.82 + }, + { + "word": "a", + "start": 1415.82, + "end": 1416.0 + }, + { + "word": "class", + "start": 1416.0, + "end": 1416.2 + }, + { + "word": "that", + "start": 1416.2, + "end": 1416.42 + }, + { + "word": "defines", + "start": 1416.42, + "end": 1416.8 + }, + { + "word": "window", + "start": 1416.8, + "end": 1417.28 + }, + { + "word": "size", + "start": 1417.28, + "end": 1417.52 + }, + { + "word": "states", + "start": 1417.52, + "end": 1417.9 + }, + { + "word": "and", + "start": 1417.9, + "end": 1418.28 + }, + { + "word": "then", + "start": 1418.28, + "end": 1418.44 + }, + { + "word": "just", + "start": 1418.44, + "end": 1418.82 + }, + { + "word": "union", + "start": 1418.82, + "end": 1419.02 + }, + { + "word": "them", + "start": 1419.02, + "end": 1419.2 + }, + { + "word": "together.", + "start": 1419.2, + "end": 1419.52 + }, + { + "word": "And", + "start": 1419.54, + "end": 1419.7 + }, + { + "word": "it's", + "start": 1419.7, + "end": 1419.92 + } + ] + }, + { + "start": 1419.92, + "end": 1426.12, + "text": "like easy. So I spent like hours trying to make this very convoluted thing where I was like trying", + "words": [ + { + "word": "like", + "start": 1419.92, + "end": 1420.38 + }, + { + "word": "easy.", + "start": 1420.38, + "end": 1420.72 + }, + { + "word": "So", + "start": 1421.48, + "end": 1421.72 + }, + { + "word": "I", + "start": 1421.72, + "end": 1421.96 + }, + { + "word": "spent", + "start": 1421.96, + "end": 1422.18 + }, + { + "word": "like", + "start": 1422.18, + "end": 1422.74 + }, + { + "word": "hours", + "start": 1422.74, + "end": 1423.06 + }, + { + "word": "trying", + "start": 1423.06, + "end": 1423.34 + }, + { + "word": "to", + "start": 1423.34, + "end": 1423.48 + }, + { + "word": "make", + "start": 1423.48, + "end": 1423.56 + }, + { + "word": "this", + "start": 1423.56, + "end": 1423.8 + }, + { + "word": "very", + "start": 1423.8, + "end": 1424.2 + }, + { + "word": "convoluted", + "start": 1424.2, + "end": 1424.72 + }, + { + "word": "thing", + "start": 1424.72, + "end": 1425.2 + }, + { + "word": "where", + "start": 1425.2, + "end": 1425.52 + }, + { + "word": "I", + "start": 1425.52, + "end": 1425.58 + }, + { + "word": "was", + "start": 1425.58, + "end": 1425.7 + }, + { + "word": "like", + "start": 1425.7, + "end": 1425.96 + }, + { + "word": "trying", + "start": 1425.96, + "end": 1426.12 + } + ] + }, + { + "start": 1426.12, + "end": 1431.92, + "text": "to infer the name and trying to look at the context. And then it just dawned on me, why am", + "words": [ + { + "word": "to", + "start": 1426.12, + "end": 1426.12 + }, + { + "word": "infer", + "start": 1426.12, + "end": 1426.5 + }, + { + "word": "the", + "start": 1426.5, + "end": 1426.82 + }, + { + "word": "name", + "start": 1426.82, + "end": 1427.16 + }, + { + "word": "and", + "start": 1427.16, + "end": 1427.36 + }, + { + "word": "trying", + "start": 1427.36, + "end": 1427.56 + }, + { + "word": "to", + "start": 1427.56, + "end": 1427.78 + }, + { + "word": "look", + "start": 1427.78, + "end": 1428.04 + }, + { + "word": "at", + "start": 1428.04, + "end": 1428.16 + }, + { + "word": "the", + "start": 1428.16, + "end": 1428.34 + }, + { + "word": "context.", + "start": 1428.34, + "end": 1428.98 + }, + { + "word": "And", + "start": 1430.4, + "end": 1430.4 + }, + { + "word": "then", + "start": 1430.4, + "end": 1430.52 + }, + { + "word": "it", + "start": 1430.52, + "end": 1430.52 + }, + { + "word": "just", + "start": 1430.52, + "end": 1430.8 + }, + { + "word": "dawned", + "start": 1430.8, + "end": 1431.04 + }, + { + "word": "on", + "start": 1431.04, + "end": 1431.22 + }, + { + "word": "me,", + "start": 1431.22, + "end": 1431.34 + }, + { + "word": "why", + "start": 1431.46, + "end": 1431.72 + }, + { + "word": "am", + "start": 1431.72, + "end": 1431.92 + } + ] + }, + { + "start": 1431.92, + "end": 1438.62, + "text": "I doing this to myself? There's a simpler solution here. And this is the number one thing, especially", + "words": [ + { + "word": "I", + "start": 1431.92, + "end": 1431.94 + }, + { + "word": "doing", + "start": 1431.94, + "end": 1432.1 + }, + { + "word": "this", + "start": 1432.1, + "end": 1432.3 + }, + { + "word": "to", + "start": 1432.3, + "end": 1432.42 + }, + { + "word": "myself?", + "start": 1432.42, + "end": 1432.82 + }, + { + "word": "There's", + "start": 1433.04, + "end": 1433.44 + }, + { + "word": "a", + "start": 1433.44, + "end": 1433.54 + }, + { + "word": "simpler", + "start": 1433.54, + "end": 1433.86 + }, + { + "word": "solution", + "start": 1433.86, + "end": 1434.3 + }, + { + "word": "here.", + "start": 1434.3, + "end": 1434.68 + }, + { + "word": "And", + "start": 1435.56, + "end": 1435.64 + }, + { + "word": "this", + "start": 1435.64, + "end": 1435.96 + }, + { + "word": "is", + "start": 1435.96, + "end": 1436.2 + }, + { + "word": "the", + "start": 1436.2, + "end": 1436.54 + }, + { + "word": "number", + "start": 1436.54, + "end": 1436.92 + }, + { + "word": "one", + "start": 1436.92, + "end": 1437.16 + }, + { + "word": "thing,", + "start": 1437.16, + "end": 1437.76 + }, + { + "word": "especially", + "start": 1438.1, + "end": 1438.62 + } + ] + }, + { + "start": 1438.62, + "end": 1443.48, + "text": "coming from Rust to any other language. Rust is much more expressive than other languages.", + "words": [ + { + "word": "coming", + "start": 1438.62, + "end": 1439.2 + }, + { + "word": "from", + "start": 1439.2, + "end": 1439.54 + }, + { + "word": "Rust", + "start": 1439.54, + "end": 1439.9 + }, + { + "word": "to", + "start": 1439.9, + "end": 1440.18 + }, + { + "word": "any", + "start": 1440.18, + "end": 1440.34 + }, + { + "word": "other", + "start": 1440.34, + "end": 1440.54 + }, + { + "word": "language.", + "start": 1440.54, + "end": 1440.88 + }, + { + "word": "Rust", + "start": 1441.14, + "end": 1441.4 + }, + { + "word": "is", + "start": 1441.4, + "end": 1441.72 + }, + { + "word": "much", + "start": 1441.72, + "end": 1442.0 + }, + { + "word": "more", + "start": 1442.0, + "end": 1442.3 + }, + { + "word": "expressive", + "start": 1442.3, + "end": 1442.7 + }, + { + "word": "than", + "start": 1442.7, + "end": 1442.9 + }, + { + "word": "other", + "start": 1442.9, + "end": 1443.12 + }, + { + "word": "languages.", + "start": 1443.12, + "end": 1443.48 + } + ] + }, + { + "start": 1444.38, + "end": 1450.3, + "text": "And a big thing that you'll commonly have to do if you're building a code gen library is Rust to go.", + "words": [ + { + "word": "And", + "start": 1444.38, + "end": 1444.38 + }, + { + "word": "a", + "start": 1444.38, + "end": 1444.7 + }, + { + "word": "big", + "start": 1444.7, + "end": 1444.94 + }, + { + "word": "thing", + "start": 1444.94, + "end": 1445.42 + }, + { + "word": "that", + "start": 1445.42, + "end": 1445.86 + }, + { + "word": "you'll", + "start": 1445.86, + "end": 1446.38 + }, + { + "word": "commonly", + "start": 1446.38, + "end": 1446.66 + }, + { + "word": "have", + "start": 1446.66, + "end": 1446.84 + }, + { + "word": "to", + "start": 1446.84, + "end": 1446.98 + }, + { + "word": "do", + "start": 1446.98, + "end": 1447.12 + }, + { + "word": "if", + "start": 1447.12, + "end": 1447.26 + }, + { + "word": "you're", + "start": 1447.26, + "end": 1447.38 + }, + { + "word": "building", + "start": 1447.38, + "end": 1447.66 + }, + { + "word": "a", + "start": 1447.66, + "end": 1447.84 + }, + { + "word": "code", + "start": 1447.84, + "end": 1448.02 + }, + { + "word": "gen", + "start": 1448.02, + "end": 1448.14 + }, + { + "word": "library", + "start": 1448.14, + "end": 1448.64 + }, + { + "word": "is", + "start": 1448.64, + "end": 1449.08 + }, + { + "word": "Rust", + "start": 1449.08, + "end": 1449.54 + }, + { + "word": "to", + "start": 1449.54, + "end": 1449.8 + }, + { + "word": "go.", + "start": 1449.8, + "end": 1450.3 + } + ] + }, + { + "start": 1450.64, + "end": 1456.1, + "text": "There be real dragons. The expressiveness is in a whole different level. So keeping things", + "words": [ + { + "word": "There", + "start": 1450.64, + "end": 1450.86 + }, + { + "word": "be", + "start": 1450.86, + "end": 1451.02 + }, + { + "word": "real", + "start": 1451.02, + "end": 1451.28 + }, + { + "word": "dragons.", + "start": 1451.28, + "end": 1451.68 + }, + { + "word": "The", + "start": 1452.6, + "end": 1453.12 + }, + { + "word": "expressiveness", + "start": 1453.12, + "end": 1453.52 + }, + { + "word": "is", + "start": 1453.52, + "end": 1453.72 + }, + { + "word": "in", + "start": 1453.72, + "end": 1453.82 + }, + { + "word": "a", + "start": 1453.82, + "end": 1453.98 + }, + { + "word": "whole", + "start": 1453.98, + "end": 1454.22 + }, + { + "word": "different", + "start": 1454.22, + "end": 1454.56 + }, + { + "word": "level.", + "start": 1454.56, + "end": 1454.9 + }, + { + "word": "So", + "start": 1455.44, + "end": 1455.62 + }, + { + "word": "keeping", + "start": 1455.62, + "end": 1455.84 + }, + { + "word": "things", + "start": 1455.84, + "end": 1456.1 + } + ] + }, + { + "start": 1456.1, + "end": 1463.16, + "text": "simple is really, really key. And again, this is like, this is a big trade off, right? You kind", + "words": [ + { + "word": "simple", + "start": 1456.1, + "end": 1456.64 + }, + { + "word": "is", + "start": 1456.64, + "end": 1457.82 + }, + { + "word": "really,", + "start": 1457.82, + "end": 1458.5 + }, + { + "word": "really", + "start": 1458.5, + "end": 1458.8 + }, + { + "word": "key.", + "start": 1458.8, + "end": 1459.06 + }, + { + "word": "And", + "start": 1459.46, + "end": 1459.6 + }, + { + "word": "again,", + "start": 1459.6, + "end": 1459.98 + }, + { + "word": "this", + "start": 1460.0, + "end": 1460.14 + }, + { + "word": "is", + "start": 1460.14, + "end": 1460.34 + }, + { + "word": "like,", + "start": 1460.34, + "end": 1460.66 + }, + { + "word": "this", + "start": 1460.88, + "end": 1461.02 + }, + { + "word": "is", + "start": 1461.02, + "end": 1461.14 + }, + { + "word": "a", + "start": 1461.14, + "end": 1461.2 + }, + { + "word": "big", + "start": 1461.2, + "end": 1461.34 + }, + { + "word": "trade", + "start": 1461.34, + "end": 1461.58 + }, + { + "word": "off,", + "start": 1461.58, + "end": 1461.8 + }, + { + "word": "right?", + "start": 1462.0, + "end": 1462.26 + }, + { + "word": "You", + "start": 1462.5, + "end": 1462.96 + }, + { + "word": "kind", + "start": 1462.96, + "end": 1463.16 + } + ] + }, + { + "start": 1463.16, + "end": 1468.44, + "text": "of lose some of the expressive power of Rust. You have to think about how you write your source code", + "words": [ + { + "word": "of", + "start": 1463.16, + "end": 1463.38 + }, + { + "word": "lose", + "start": 1463.38, + "end": 1463.8 + }, + { + "word": "some", + "start": 1463.8, + "end": 1464.12 + }, + { + "word": "of", + "start": 1464.12, + "end": 1464.22 + }, + { + "word": "the", + "start": 1464.22, + "end": 1464.4 + }, + { + "word": "expressive", + "start": 1464.4, + "end": 1464.7 + }, + { + "word": "power", + "start": 1464.7, + "end": 1465.06 + }, + { + "word": "of", + "start": 1465.06, + "end": 1465.28 + }, + { + "word": "Rust.", + "start": 1465.28, + "end": 1465.42 + }, + { + "word": "You", + "start": 1465.46, + "end": 1465.58 + }, + { + "word": "have", + "start": 1465.58, + "end": 1465.74 + }, + { + "word": "to", + "start": 1465.74, + "end": 1465.94 + }, + { + "word": "think", + "start": 1465.94, + "end": 1466.4 + }, + { + "word": "about", + "start": 1466.4, + "end": 1466.94 + }, + { + "word": "how", + "start": 1466.94, + "end": 1467.28 + }, + { + "word": "you", + "start": 1467.28, + "end": 1467.6 + }, + { + "word": "write", + "start": 1467.6, + "end": 1467.76 + }, + { + "word": "your", + "start": 1467.76, + "end": 1468.0 + }, + { + "word": "source", + "start": 1468.0, + "end": 1468.18 + }, + { + "word": "code", + "start": 1468.18, + "end": 1468.44 + } + ] + }, + { + "start": 1468.44, + "end": 1475.46, + "text": "in different ways. But it is fundamentally the sort of like trade off that you accept to be able to", + "words": [ + { + "word": "in", + "start": 1468.44, + "end": 1469.22 + }, + { + "word": "different", + "start": 1469.22, + "end": 1469.6 + }, + { + "word": "ways.", + "start": 1469.6, + "end": 1470.26 + }, + { + "word": "But", + "start": 1471.46, + "end": 1471.86 + }, + { + "word": "it", + "start": 1471.86, + "end": 1472.08 + }, + { + "word": "is", + "start": 1472.08, + "end": 1472.46 + }, + { + "word": "fundamentally", + "start": 1472.46, + "end": 1472.9 + }, + { + "word": "the", + "start": 1472.9, + "end": 1473.18 + }, + { + "word": "sort", + "start": 1473.18, + "end": 1473.32 + }, + { + "word": "of", + "start": 1473.32, + "end": 1473.56 + }, + { + "word": "like", + "start": 1473.56, + "end": 1473.68 + }, + { + "word": "trade", + "start": 1473.68, + "end": 1473.8 + }, + { + "word": "off", + "start": 1473.8, + "end": 1473.92 + }, + { + "word": "that", + "start": 1473.92, + "end": 1474.06 + }, + { + "word": "you", + "start": 1474.06, + "end": 1474.22 + }, + { + "word": "accept", + "start": 1474.22, + "end": 1474.56 + }, + { + "word": "to", + "start": 1474.56, + "end": 1474.72 + }, + { + "word": "be", + "start": 1474.72, + "end": 1474.84 + }, + { + "word": "able", + "start": 1474.84, + "end": 1475.0 + }, + { + "word": "to", + "start": 1475.0, + "end": 1475.46 + } + ] + }, + { + "start": 1475.46, + "end": 1479.46, + "text": "support and keep up to date all these other SDKs that are downstream.", + "words": [ + { + "word": "support", + "start": 1475.46, + "end": 1476.0 + }, + { + "word": "and", + "start": 1476.0, + "end": 1476.5 + }, + { + "word": "keep", + "start": 1476.5, + "end": 1476.68 + }, + { + "word": "up", + "start": 1476.68, + "end": 1476.9 + }, + { + "word": "to", + "start": 1476.9, + "end": 1477.08 + }, + { + "word": "date", + "start": 1477.08, + "end": 1477.32 + }, + { + "word": "all", + "start": 1477.32, + "end": 1477.74 + }, + { + "word": "these", + "start": 1477.74, + "end": 1477.94 + }, + { + "word": "other", + "start": 1477.94, + "end": 1478.28 + }, + { + "word": "SDKs", + "start": 1478.28, + "end": 1478.78 + }, + { + "word": "that", + "start": 1478.78, + "end": 1478.86 + }, + { + "word": "are", + "start": 1478.86, + "end": 1479.0 + }, + { + "word": "downstream.", + "start": 1479.0, + "end": 1479.46 + } + ] + }, + { + "start": 1482.28, + "end": 1488.94, + "text": "I wanted to give a shout out to this tool called AST grep that I use. So in that PR that I fixed", + "words": [ + { + "word": "I", + "start": 1482.28, + "end": 1482.72 + }, + { + "word": "wanted", + "start": 1482.72, + "end": 1483.16 + }, + { + "word": "to", + "start": 1483.16, + "end": 1483.28 + }, + { + "word": "give", + "start": 1483.28, + "end": 1483.38 + }, + { + "word": "a", + "start": 1483.38, + "end": 1483.5 + }, + { + "word": "shout", + "start": 1483.5, + "end": 1483.68 + }, + { + "word": "out", + "start": 1483.68, + "end": 1483.92 + }, + { + "word": "to", + "start": 1483.92, + "end": 1484.38 + }, + { + "word": "this", + "start": 1484.38, + "end": 1485.2 + }, + { + "word": "tool", + "start": 1485.2, + "end": 1485.34 + }, + { + "word": "called", + "start": 1485.34, + "end": 1485.54 + }, + { + "word": "AST", + "start": 1485.54, + "end": 1485.84 + }, + { + "word": "grep", + "start": 1485.84, + "end": 1486.32 + }, + { + "word": "that", + "start": 1486.32, + "end": 1486.96 + }, + { + "word": "I", + "start": 1486.96, + "end": 1487.22 + }, + { + "word": "use.", + "start": 1487.22, + "end": 1487.44 + }, + { + "word": "So", + "start": 1487.8, + "end": 1487.8 + }, + { + "word": "in", + "start": 1487.8, + "end": 1487.94 + }, + { + "word": "that", + "start": 1487.94, + "end": 1488.14 + }, + { + "word": "PR", + "start": 1488.14, + "end": 1488.36 + }, + { + "word": "that", + "start": 1488.36, + "end": 1488.62 + }, + { + "word": "I", + "start": 1488.62, + "end": 1488.8 + }, + { + "word": "fixed", + "start": 1488.8, + "end": 1488.94 + } + ] + }, + { + "start": 1488.94, + "end": 1494.42, + "text": "that issue, I wrote this AST grep rule. So AST grep is like a CLI tool that you can write these", + "words": [ + { + "word": "that", + "start": 1488.94, + "end": 1489.16 + }, + { + "word": "issue,", + "start": 1489.16, + "end": 1489.5 + }, + { + "word": "I", + "start": 1489.86, + "end": 1489.98 + }, + { + "word": "wrote", + "start": 1489.98, + "end": 1490.1 + }, + { + "word": "this", + "start": 1490.1, + "end": 1490.38 + }, + { + "word": "AST", + "start": 1490.38, + "end": 1490.68 + }, + { + "word": "grep", + "start": 1490.68, + "end": 1490.96 + }, + { + "word": "rule.", + "start": 1490.96, + "end": 1491.24 + }, + { + "word": "So", + "start": 1491.64, + "end": 1491.74 + }, + { + "word": "AST", + "start": 1491.74, + "end": 1491.96 + }, + { + "word": "grep", + "start": 1491.96, + "end": 1492.22 + }, + { + "word": "is", + "start": 1492.22, + "end": 1492.36 + }, + { + "word": "like", + "start": 1492.36, + "end": 1492.54 + }, + { + "word": "a", + "start": 1492.54, + "end": 1492.66 + }, + { + "word": "CLI", + "start": 1492.66, + "end": 1492.94 + }, + { + "word": "tool", + "start": 1492.94, + "end": 1493.36 + }, + { + "word": "that", + "start": 1493.36, + "end": 1493.82 + }, + { + "word": "you", + "start": 1493.82, + "end": 1493.9 + }, + { + "word": "can", + "start": 1493.9, + "end": 1494.02 + }, + { + "word": "write", + "start": 1494.02, + "end": 1494.2 + }, + { + "word": "these", + "start": 1494.2, + "end": 1494.42 + } + ] + }, + { + "start": 1494.42, + "end": 1500.92, + "text": "simple like lint rules and it'll go through and like, you know, in this case, check that I'm not", + "words": [ + { + "word": "simple", + "start": 1494.42, + "end": 1494.98 + }, + { + "word": "like", + "start": 1494.98, + "end": 1495.18 + }, + { + "word": "lint", + "start": 1495.18, + "end": 1495.28 + }, + { + "word": "rules", + "start": 1495.28, + "end": 1495.6 + }, + { + "word": "and", + "start": 1495.6, + "end": 1495.72 + }, + { + "word": "it'll", + "start": 1495.72, + "end": 1495.86 + }, + { + "word": "go", + "start": 1495.86, + "end": 1496.02 + }, + { + "word": "through", + "start": 1496.02, + "end": 1496.36 + }, + { + "word": "and", + "start": 1496.36, + "end": 1497.0 + }, + { + "word": "like,", + "start": 1497.0, + "end": 1497.92 + }, + { + "word": "you", + "start": 1497.92, + "end": 1497.96 + }, + { + "word": "know,", + "start": 1497.96, + "end": 1498.26 + }, + { + "word": "in", + "start": 1498.38, + "end": 1498.52 + }, + { + "word": "this", + "start": 1498.52, + "end": 1498.74 + }, + { + "word": "case,", + "start": 1498.74, + "end": 1499.14 + }, + { + "word": "check", + "start": 1499.36, + "end": 1499.8 + }, + { + "word": "that", + "start": 1499.8, + "end": 1500.3 + }, + { + "word": "I'm", + "start": 1500.3, + "end": 1500.58 + }, + { + "word": "not", + "start": 1500.58, + "end": 1500.92 + } + ] + }, + { + "start": 1500.92, + "end": 1511.02, + "text": "mixing variant types. So yeah, you can say, anyway, I'm not going to explain the actual rule here", + "words": [ + { + "word": "mixing", + "start": 1500.92, + "end": 1501.32 + }, + { + "word": "variant", + "start": 1501.32, + "end": 1502.3 + }, + { + "word": "types.", + "start": 1502.3, + "end": 1502.84 + }, + { + "word": "So", + "start": 1505.22, + "end": 1505.22 + }, + { + "word": "yeah,", + "start": 1505.22, + "end": 1506.0 + }, + { + "word": "you", + "start": 1506.08, + "end": 1506.08 + }, + { + "word": "can", + "start": 1506.08, + "end": 1506.28 + }, + { + "word": "say,", + "start": 1506.28, + "end": 1507.08 + }, + { + "word": "anyway,", + "start": 1508.06, + "end": 1508.36 + }, + { + "word": "I'm", + "start": 1508.5, + "end": 1509.1 + }, + { + "word": "not", + "start": 1509.1, + "end": 1509.2 + }, + { + "word": "going", + "start": 1509.2, + "end": 1509.3 + }, + { + "word": "to", + "start": 1509.3, + "end": 1509.44 + }, + { + "word": "explain", + "start": 1509.44, + "end": 1509.7 + }, + { + "word": "the", + "start": 1509.7, + "end": 1510.2 + }, + { + "word": "actual", + "start": 1510.2, + "end": 1510.5 + }, + { + "word": "rule", + "start": 1510.5, + "end": 1510.76 + }, + { + "word": "here", + "start": 1510.76, + "end": 1511.02 + } + ] + }, + { + "start": 1511.02, + "end": 1520.52, + "text": "because I forgot how it works. But it does work and it's good. So yeah, great tool. The author is", + "words": [ + { + "word": "because", + "start": 1511.02, + "end": 1511.3 + }, + { + "word": "I", + "start": 1511.3, + "end": 1511.7 + }, + { + "word": "forgot", + "start": 1511.7, + "end": 1511.9 + }, + { + "word": "how", + "start": 1511.9, + "end": 1512.1 + }, + { + "word": "it", + "start": 1512.1, + "end": 1512.26 + }, + { + "word": "works.", + "start": 1512.26, + "end": 1512.48 + }, + { + "word": "But", + "start": 1513.46, + "end": 1513.46 + }, + { + "word": "it", + "start": 1513.46, + "end": 1514.6 + }, + { + "word": "does", + "start": 1514.6, + "end": 1514.8 + }, + { + "word": "work", + "start": 1514.8, + "end": 1515.02 + }, + { + "word": "and", + "start": 1515.02, + "end": 1515.08 + }, + { + "word": "it's", + "start": 1515.08, + "end": 1515.28 + }, + { + "word": "good.", + "start": 1515.28, + "end": 1515.48 + }, + { + "word": "So", + "start": 1517.28, + "end": 1517.28 + }, + { + "word": "yeah,", + "start": 1517.28, + "end": 1519.12 + }, + { + "word": "great", + "start": 1519.38, + "end": 1519.68 + }, + { + "word": "tool.", + "start": 1519.68, + "end": 1519.92 + }, + { + "word": "The", + "start": 1520.04, + "end": 1520.2 + }, + { + "word": "author", + "start": 1520.2, + "end": 1520.36 + }, + { + "word": "is", + "start": 1520.36, + "end": 1520.52 + } + ] + }, + { + "start": 1520.52, + "end": 1524.4, + "text": "here. You should check it out. It's a really important tool in my toolbox.", + "words": [ + { + "word": "here.", + "start": 1520.52, + "end": 1520.76 + }, + { + "word": "You", + "start": 1521.0, + "end": 1521.22 + }, + { + "word": "should", + "start": 1521.22, + "end": 1521.36 + }, + { + "word": "check", + "start": 1521.36, + "end": 1521.5 + }, + { + "word": "it", + "start": 1521.5, + "end": 1521.68 + }, + { + "word": "out.", + "start": 1521.68, + "end": 1521.84 + }, + { + "word": "It's", + "start": 1522.48, + "end": 1522.96 + }, + { + "word": "a", + "start": 1522.96, + "end": 1523.12 + }, + { + "word": "really", + "start": 1523.12, + "end": 1523.38 + }, + { + "word": "important", + "start": 1523.38, + "end": 1523.64 + }, + { + "word": "tool", + "start": 1523.64, + "end": 1523.8 + }, + { + "word": "in", + "start": 1523.8, + "end": 1523.94 + }, + { + "word": "my", + "start": 1523.94, + "end": 1524.04 + }, + { + "word": "toolbox.", + "start": 1524.04, + "end": 1524.4 + } + ] + }, + { + "start": 1528.36, + "end": 1533.4, + "text": "So I'm going to sort of like, I'm going to start wrapping up here and I just want to like leave you", + "words": [ + { + "word": "So", + "start": 1528.36, + "end": 1528.84 + }, + { + "word": "I'm", + "start": 1528.84, + "end": 1529.32 + }, + { + "word": "going", + "start": 1529.32, + "end": 1529.66 + }, + { + "word": "to", + "start": 1529.66, + "end": 1529.8 + }, + { + "word": "sort", + "start": 1529.8, + "end": 1529.98 + }, + { + "word": "of", + "start": 1529.98, + "end": 1530.1 + }, + { + "word": "like,", + "start": 1530.1, + "end": 1530.24 + }, + { + "word": "I'm", + "start": 1530.32, + "end": 1530.38 + }, + { + "word": "going", + "start": 1530.38, + "end": 1530.46 + }, + { + "word": "to", + "start": 1530.46, + "end": 1530.58 + }, + { + "word": "start", + "start": 1530.58, + "end": 1530.7 + }, + { + "word": "wrapping", + "start": 1530.7, + "end": 1530.94 + }, + { + "word": "up", + "start": 1530.94, + "end": 1531.18 + }, + { + "word": "here", + "start": 1531.18, + "end": 1531.54 + }, + { + "word": "and", + "start": 1531.54, + "end": 1532.06 + }, + { + "word": "I", + "start": 1532.06, + "end": 1532.3 + }, + { + "word": "just", + "start": 1532.3, + "end": 1532.46 + }, + { + "word": "want", + "start": 1532.46, + "end": 1532.58 + }, + { + "word": "to", + "start": 1532.58, + "end": 1532.78 + }, + { + "word": "like", + "start": 1532.78, + "end": 1532.98 + }, + { + "word": "leave", + "start": 1532.98, + "end": 1533.1 + }, + { + "word": "you", + "start": 1533.1, + "end": 1533.4 + } + ] + }, + { + "start": 1533.4, + "end": 1539.28, + "text": "with some like good rules to follow. These are really hard fault for me. All of these are blood,", + "words": [ + { + "word": "with", + "start": 1533.4, + "end": 1533.66 + }, + { + "word": "some", + "start": 1533.66, + "end": 1534.22 + }, + { + "word": "like", + "start": 1534.22, + "end": 1534.64 + }, + { + "word": "good", + "start": 1534.64, + "end": 1534.84 + }, + { + "word": "rules", + "start": 1534.84, + "end": 1535.14 + }, + { + "word": "to", + "start": 1535.14, + "end": 1535.38 + }, + { + "word": "follow.", + "start": 1535.38, + "end": 1535.66 + }, + { + "word": "These", + "start": 1535.68, + "end": 1536.14 + }, + { + "word": "are", + "start": 1536.14, + "end": 1536.78 + }, + { + "word": "really", + "start": 1536.78, + "end": 1537.08 + }, + { + "word": "hard", + "start": 1537.08, + "end": 1537.34 + }, + { + "word": "fault", + "start": 1537.34, + "end": 1537.48 + }, + { + "word": "for", + "start": 1537.48, + "end": 1537.7 + }, + { + "word": "me.", + "start": 1537.7, + "end": 1538.02 + }, + { + "word": "All", + "start": 1538.1, + "end": 1538.58 + }, + { + "word": "of", + "start": 1538.58, + "end": 1538.78 + }, + { + "word": "these", + "start": 1538.78, + "end": 1538.96 + }, + { + "word": "are", + "start": 1538.96, + "end": 1539.12 + }, + { + "word": "blood,", + "start": 1539.12, + "end": 1539.28 + } + ] + }, + { + "start": 1539.42, + "end": 1548.28, + "text": "sweat and tears. So when possible, use tagged enums. A tagged enum is like a discriminated union.", + "words": [ + { + "word": "sweat", + "start": 1539.42, + "end": 1539.42 + }, + { + "word": "and", + "start": 1539.42, + "end": 1539.64 + }, + { + "word": "tears.", + "start": 1539.64, + "end": 1540.06 + }, + { + "word": "So", + "start": 1541.46, + "end": 1541.94 + }, + { + "word": "when", + "start": 1541.94, + "end": 1542.14 + }, + { + "word": "possible,", + "start": 1542.14, + "end": 1542.74 + }, + { + "word": "use", + "start": 1542.74, + "end": 1543.44 + }, + { + "word": "tagged", + "start": 1543.44, + "end": 1544.0 + }, + { + "word": "enums.", + "start": 1544.0, + "end": 1544.38 + }, + { + "word": "A", + "start": 1544.52, + "end": 1544.7 + }, + { + "word": "tagged", + "start": 1544.7, + "end": 1544.84 + }, + { + "word": "enum", + "start": 1544.84, + "end": 1545.28 + }, + { + "word": "is", + "start": 1545.28, + "end": 1545.5 + }, + { + "word": "like", + "start": 1545.5, + "end": 1546.96 + }, + { + "word": "a", + "start": 1546.96, + "end": 1547.52 + }, + { + "word": "discriminated", + "start": 1547.52, + "end": 1547.94 + }, + { + "word": "union.", + "start": 1547.94, + "end": 1548.28 + } + ] + }, + { + "start": 1548.52, + "end": 1554.38, + "text": "You have like type, I don't know, size or whatever as a key. And every object that you have is like", + "words": [ + { + "word": "You", + "start": 1548.52, + "end": 1548.52 + }, + { + "word": "have", + "start": 1548.52, + "end": 1548.78 + }, + { + "word": "like", + "start": 1548.78, + "end": 1549.4 + }, + { + "word": "type,", + "start": 1549.4, + "end": 1550.14 + }, + { + "word": "I", + "start": 1550.94, + "end": 1551.14 + }, + { + "word": "don't", + "start": 1551.14, + "end": 1551.28 + }, + { + "word": "know,", + "start": 1551.28, + "end": 1551.5 + }, + { + "word": "size", + "start": 1551.68, + "end": 1552.1 + }, + { + "word": "or", + "start": 1552.1, + "end": 1552.42 + }, + { + "word": "whatever", + "start": 1552.42, + "end": 1552.72 + }, + { + "word": "as", + "start": 1552.72, + "end": 1553.04 + }, + { + "word": "a", + "start": 1553.04, + "end": 1553.26 + }, + { + "word": "key.", + "start": 1553.26, + "end": 1553.48 + }, + { + "word": "And", + "start": 1553.58, + "end": 1553.84 + }, + { + "word": "every", + "start": 1553.84, + "end": 1554.22 + }, + { + "word": "object", + "start": 1554.22, + "end": 1554.38 + }, + { + "word": "that", + "start": 1554.38, + "end": 1554.38 + }, + { + "word": "you", + "start": 1554.38, + "end": 1554.38 + }, + { + "word": "have", + "start": 1554.38, + "end": 1554.38 + }, + { + "word": "is", + "start": 1554.38, + "end": 1554.38 + }, + { + "word": "like", + "start": 1554.38, + "end": 1554.38 + } + ] + }, + { + "start": 1554.38, + "end": 1555.96, + "text": "a type. So if you have a type, you're like, you know, you're a type object and your union has type", + "words": [ + { + "word": "a", + "start": 1554.38, + "end": 1554.66 + }, + { + "word": "type.", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "So", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "if", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "you", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "have", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "a", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "type,", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "you're", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "like,", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "you", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "know,", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "you're", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "a", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "type", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "object", + "start": 1554.66, + "end": 1554.66 + }, + { + "word": "and", + "start": 1554.66, + "end": 1554.82 + }, + { + "word": "your", + "start": 1554.82, + "end": 1555.02 + }, + { + "word": "union", + "start": 1555.02, + "end": 1555.36 + }, + { + "word": "has", + "start": 1555.36, + "end": 1555.66 + }, + { + "word": "type", + "start": 1555.66, + "end": 1555.96 + } + ] + }, + { + "start": 1555.96, + "end": 1561.02, + "text": "something. And it makes it very easy to at any point understand the data structure that you're", + "words": [ + { + "word": "something.", + "start": 1555.96, + "end": 1556.4 + }, + { + "word": "And", + "start": 1556.88, + "end": 1557.0 + }, + { + "word": "it", + "start": 1557.0, + "end": 1557.06 + }, + { + "word": "makes", + "start": 1557.06, + "end": 1557.24 + }, + { + "word": "it", + "start": 1557.24, + "end": 1557.46 + }, + { + "word": "very", + "start": 1557.46, + "end": 1557.78 + }, + { + "word": "easy", + "start": 1557.78, + "end": 1558.26 + }, + { + "word": "to", + "start": 1558.26, + "end": 1558.54 + }, + { + "word": "at", + "start": 1558.54, + "end": 1558.72 + }, + { + "word": "any", + "start": 1558.72, + "end": 1559.0 + }, + { + "word": "point", + "start": 1559.0, + "end": 1559.36 + }, + { + "word": "understand", + "start": 1559.36, + "end": 1560.08 + }, + { + "word": "the", + "start": 1560.08, + "end": 1560.28 + }, + { + "word": "data", + "start": 1560.28, + "end": 1560.48 + }, + { + "word": "structure", + "start": 1560.48, + "end": 1560.74 + }, + { + "word": "that", + "start": 1560.74, + "end": 1560.88 + }, + { + "word": "you're", + "start": 1560.88, + "end": 1561.02 + } + ] + }, + { + "start": 1561.02, + "end": 1565.66, + "text": "working with. This does not make very ergonomic APIs if every time you're like constructing", + "words": [ + { + "word": "working", + "start": 1561.02, + "end": 1561.28 + }, + { + "word": "with.", + "start": 1561.28, + "end": 1561.6 + }, + { + "word": "This", + "start": 1562.04, + "end": 1562.22 + }, + { + "word": "does", + "start": 1562.22, + "end": 1562.48 + }, + { + "word": "not", + "start": 1562.48, + "end": 1562.66 + }, + { + "word": "make", + "start": 1562.66, + "end": 1562.84 + }, + { + "word": "very", + "start": 1562.84, + "end": 1563.16 + }, + { + "word": "ergonomic", + "start": 1563.16, + "end": 1563.62 + }, + { + "word": "APIs", + "start": 1563.62, + "end": 1564.14 + }, + { + "word": "if", + "start": 1564.14, + "end": 1564.58 + }, + { + "word": "every", + "start": 1564.58, + "end": 1564.82 + }, + { + "word": "time", + "start": 1564.82, + "end": 1565.0 + }, + { + "word": "you're", + "start": 1565.0, + "end": 1565.2 + }, + { + "word": "like", + "start": 1565.2, + "end": 1565.36 + }, + { + "word": "constructing", + "start": 1565.36, + "end": 1565.66 + } + ] + }, + { + "start": 1565.66, + "end": 1570.9, + "text": "something, you have to say type whatever, that sucks. That's the reason when you like try, you", + "words": [ + { + "word": "something,", + "start": 1565.66, + "end": 1566.04 + }, + { + "word": "you", + "start": 1566.18, + "end": 1566.18 + }, + { + "word": "have", + "start": 1566.18, + "end": 1566.3 + }, + { + "word": "to", + "start": 1566.3, + "end": 1566.44 + }, + { + "word": "say", + "start": 1566.44, + "end": 1566.54 + }, + { + "word": "type", + "start": 1566.54, + "end": 1566.84 + }, + { + "word": "whatever,", + "start": 1566.84, + "end": 1567.18 + }, + { + "word": "that", + "start": 1567.28, + "end": 1567.46 + }, + { + "word": "sucks.", + "start": 1567.46, + "end": 1567.88 + }, + { + "word": "That's", + "start": 1568.68, + "end": 1569.06 + }, + { + "word": "the", + "start": 1569.06, + "end": 1569.14 + }, + { + "word": "reason", + "start": 1569.14, + "end": 1569.32 + }, + { + "word": "when", + "start": 1569.32, + "end": 1569.56 + }, + { + "word": "you", + "start": 1569.56, + "end": 1570.28 + }, + { + "word": "like", + "start": 1570.28, + "end": 1570.3 + }, + { + "word": "try,", + "start": 1570.3, + "end": 1570.66 + }, + { + "word": "you", + "start": 1570.78, + "end": 1570.9 + } + ] + }, + { + "start": 1570.9, + "end": 1578.94, + "text": "end up having to avoid it. But if you're passing data around, just use tagged enums. Like I was", + "words": [ + { + "word": "end", + "start": 1570.9, + "end": 1571.08 + }, + { + "word": "up", + "start": 1571.08, + "end": 1571.22 + }, + { + "word": "having", + "start": 1571.22, + "end": 1571.42 + }, + { + "word": "to", + "start": 1571.42, + "end": 1571.62 + }, + { + "word": "avoid", + "start": 1571.62, + "end": 1571.78 + }, + { + "word": "it.", + "start": 1571.78, + "end": 1571.96 + }, + { + "word": "But", + "start": 1572.02, + "end": 1572.14 + }, + { + "word": "if", + "start": 1572.14, + "end": 1572.3 + }, + { + "word": "you're", + "start": 1572.3, + "end": 1572.46 + }, + { + "word": "passing", + "start": 1572.46, + "end": 1572.84 + }, + { + "word": "data", + "start": 1572.84, + "end": 1573.18 + }, + { + "word": "around,", + "start": 1573.18, + "end": 1573.72 + }, + { + "word": "just", + "start": 1574.26, + "end": 1574.84 + }, + { + "word": "use", + "start": 1574.84, + "end": 1575.84 + }, + { + "word": "tagged", + "start": 1575.84, + "end": 1576.88 + }, + { + "word": "enums.", + "start": 1576.88, + "end": 1577.34 + }, + { + "word": "Like", + "start": 1578.44, + "end": 1578.74 + }, + { + "word": "I", + "start": 1578.74, + "end": 1578.94 + }, + { + "word": "was", + "start": 1578.94, + "end": 1578.94 + } + ] + }, + { + "start": 1578.94, + "end": 1585.16, + "text": "showing in the last example, try to avoid mixing different enum variant types, like different", + "words": [ + { + "word": "showing", + "start": 1578.94, + "end": 1579.06 + }, + { + "word": "in", + "start": 1579.06, + "end": 1579.18 + }, + { + "word": "the", + "start": 1579.18, + "end": 1579.24 + }, + { + "word": "last", + "start": 1579.24, + "end": 1579.48 + }, + { + "word": "example,", + "start": 1579.48, + "end": 1579.86 + }, + { + "word": "try", + "start": 1580.1, + "end": 1580.58 + }, + { + "word": "to", + "start": 1580.58, + "end": 1581.04 + }, + { + "word": "avoid", + "start": 1581.04, + "end": 1581.76 + }, + { + "word": "mixing", + "start": 1581.76, + "end": 1582.62 + }, + { + "word": "different", + "start": 1582.62, + "end": 1583.28 + }, + { + "word": "enum", + "start": 1583.28, + "end": 1583.58 + }, + { + "word": "variant", + "start": 1583.58, + "end": 1583.92 + }, + { + "word": "types,", + "start": 1583.92, + "end": 1584.4 + }, + { + "word": "like", + "start": 1584.62, + "end": 1584.72 + }, + { + "word": "different", + "start": 1584.72, + "end": 1585.16 + } + ] + }, + { + "start": 1585.16, + "end": 1592.06, + "text": "variant arms. Again, just like other languages are not as expressive as Rustus and you'll end up", + "words": [ + { + "word": "variant", + "start": 1585.16, + "end": 1585.48 + }, + { + "word": "arms.", + "start": 1585.48, + "end": 1585.96 + }, + { + "word": "Again,", + "start": 1586.82, + "end": 1587.14 + }, + { + "word": "just", + "start": 1587.34, + "end": 1587.46 + }, + { + "word": "like", + "start": 1587.46, + "end": 1587.78 + }, + { + "word": "other", + "start": 1587.78, + "end": 1587.98 + }, + { + "word": "languages", + "start": 1587.98, + "end": 1588.34 + }, + { + "word": "are", + "start": 1588.34, + "end": 1588.74 + }, + { + "word": "not", + "start": 1588.74, + "end": 1589.04 + }, + { + "word": "as", + "start": 1589.04, + "end": 1589.44 + }, + { + "word": "expressive", + "start": 1589.44, + "end": 1589.88 + }, + { + "word": "as", + "start": 1589.88, + "end": 1590.44 + }, + { + "word": "Rustus", + "start": 1590.44, + "end": 1590.9 + }, + { + "word": "and", + "start": 1590.9, + "end": 1591.4 + }, + { + "word": "you'll", + "start": 1591.4, + "end": 1591.8 + }, + { + "word": "end", + "start": 1591.8, + "end": 1591.94 + }, + { + "word": "up", + "start": 1591.94, + "end": 1592.06 + } + ] + }, + { + "start": 1592.06, + "end": 1596.2, + "text": "hitting all these weird corner cases. Sometimes you have to do it and sometimes it's okay. Just", + "words": [ + { + "word": "hitting", + "start": 1592.06, + "end": 1592.2 + }, + { + "word": "all", + "start": 1592.2, + "end": 1592.42 + }, + { + "word": "these", + "start": 1592.42, + "end": 1592.66 + }, + { + "word": "weird", + "start": 1592.66, + "end": 1592.78 + }, + { + "word": "corner", + "start": 1592.78, + "end": 1593.02 + }, + { + "word": "cases.", + "start": 1593.02, + "end": 1593.3 + }, + { + "word": "Sometimes", + "start": 1593.48, + "end": 1593.82 + }, + { + "word": "you", + "start": 1593.82, + "end": 1593.96 + }, + { + "word": "have", + "start": 1593.96, + "end": 1594.14 + }, + { + "word": "to", + "start": 1594.14, + "end": 1594.26 + }, + { + "word": "do", + "start": 1594.26, + "end": 1594.4 + }, + { + "word": "it", + "start": 1594.4, + "end": 1594.6 + }, + { + "word": "and", + "start": 1594.6, + "end": 1594.7 + }, + { + "word": "sometimes", + "start": 1594.7, + "end": 1595.0 + }, + { + "word": "it's", + "start": 1595.0, + "end": 1595.22 + }, + { + "word": "okay.", + "start": 1595.22, + "end": 1595.68 + }, + { + "word": "Just", + "start": 1596.02, + "end": 1596.2 + } + ] + }, + { + "start": 1596.2, + "end": 1602.98, + "text": "like think very deeply about it. And also there's a lot of ambiguity problems as you grow. So you", + "words": [ + { + "word": "like", + "start": 1596.2, + "end": 1596.46 + }, + { + "word": "think", + "start": 1596.46, + "end": 1596.6 + }, + { + "word": "very", + "start": 1596.6, + "end": 1596.96 + }, + { + "word": "deeply", + "start": 1596.96, + "end": 1597.3 + }, + { + "word": "about", + "start": 1597.3, + "end": 1597.56 + }, + { + "word": "it.", + "start": 1597.56, + "end": 1597.68 + }, + { + "word": "And", + "start": 1597.68, + "end": 1597.88 + }, + { + "word": "also", + "start": 1597.88, + "end": 1598.28 + }, + { + "word": "there's", + "start": 1598.28, + "end": 1599.18 + }, + { + "word": "a", + "start": 1599.18, + "end": 1599.24 + }, + { + "word": "lot", + "start": 1599.24, + "end": 1599.4 + }, + { + "word": "of", + "start": 1599.4, + "end": 1599.94 + }, + { + "word": "ambiguity", + "start": 1599.94, + "end": 1600.6 + }, + { + "word": "problems", + "start": 1600.6, + "end": 1601.14 + }, + { + "word": "as", + "start": 1601.14, + "end": 1601.58 + }, + { + "word": "you", + "start": 1601.58, + "end": 1601.8 + }, + { + "word": "grow.", + "start": 1601.8, + "end": 1602.24 + }, + { + "word": "So", + "start": 1602.58, + "end": 1602.86 + }, + { + "word": "you", + "start": 1602.86, + "end": 1602.98 + } + ] + }, + { + "start": 1602.98, + "end": 1607.9, + "text": "have to think about like, will there be like keys and two variant arms that like overlap or", + "words": [ + { + "word": "have", + "start": 1602.98, + "end": 1603.1 + }, + { + "word": "to", + "start": 1603.1, + "end": 1603.24 + }, + { + "word": "think", + "start": 1603.24, + "end": 1603.36 + }, + { + "word": "about", + "start": 1603.36, + "end": 1603.6 + }, + { + "word": "like,", + "start": 1603.6, + "end": 1604.14 + }, + { + "word": "will", + "start": 1604.52, + "end": 1604.52 + }, + { + "word": "there", + "start": 1604.52, + "end": 1604.74 + }, + { + "word": "be", + "start": 1604.74, + "end": 1605.0 + }, + { + "word": "like", + "start": 1605.0, + "end": 1605.2 + }, + { + "word": "keys", + "start": 1605.2, + "end": 1605.42 + }, + { + "word": "and", + "start": 1605.42, + "end": 1605.68 + }, + { + "word": "two", + "start": 1605.68, + "end": 1605.88 + }, + { + "word": "variant", + "start": 1605.88, + "end": 1606.12 + }, + { + "word": "arms", + "start": 1606.12, + "end": 1606.46 + }, + { + "word": "that", + "start": 1606.46, + "end": 1606.64 + }, + { + "word": "like", + "start": 1606.64, + "end": 1606.9 + }, + { + "word": "overlap", + "start": 1606.9, + "end": 1607.4 + }, + { + "word": "or", + "start": 1607.4, + "end": 1607.9 + } + ] + }, + { + "start": 1607.9, + "end": 1614.16, + "text": "stuff like that. So be careful with it. Flatten is the devil. Like avoid it at all costs.", + "words": [ + { + "word": "stuff", + "start": 1607.9, + "end": 1608.26 + }, + { + "word": "like", + "start": 1608.26, + "end": 1608.48 + }, + { + "word": "that.", + "start": 1608.48, + "end": 1608.66 + }, + { + "word": "So", + "start": 1609.02, + "end": 1609.02 + }, + { + "word": "be", + "start": 1609.02, + "end": 1609.2 + }, + { + "word": "careful", + "start": 1609.2, + "end": 1609.38 + }, + { + "word": "with", + "start": 1609.38, + "end": 1609.58 + }, + { + "word": "it.", + "start": 1609.58, + "end": 1610.2 + }, + { + "word": "Flatten", + "start": 1610.94, + "end": 1611.24 + }, + { + "word": "is", + "start": 1611.24, + "end": 1611.56 + }, + { + "word": "the", + "start": 1611.56, + "end": 1611.74 + }, + { + "word": "devil.", + "start": 1611.74, + "end": 1612.2 + }, + { + "word": "Like", + "start": 1612.64, + "end": 1612.88 + }, + { + "word": "avoid", + "start": 1612.88, + "end": 1613.04 + }, + { + "word": "it", + "start": 1613.04, + "end": 1613.28 + }, + { + "word": "at", + "start": 1613.28, + "end": 1613.38 + }, + { + "word": "all", + "start": 1613.38, + "end": 1613.62 + }, + { + "word": "costs.", + "start": 1613.62, + "end": 1614.16 + } + ] + }, + { + "start": 1615.36, + "end": 1623.08, + "text": "There are really times where like not doing flatten means you just have a worse API experience. It", + "words": [ + { + "word": "There", + "start": 1615.36, + "end": 1615.56 + }, + { + "word": "are", + "start": 1615.56, + "end": 1615.8 + }, + { + "word": "really", + "start": 1615.8, + "end": 1615.98 + }, + { + "word": "times", + "start": 1615.98, + "end": 1616.38 + }, + { + "word": "where", + "start": 1616.38, + "end": 1616.76 + }, + { + "word": "like", + "start": 1616.76, + "end": 1617.32 + }, + { + "word": "not", + "start": 1617.32, + "end": 1617.52 + }, + { + "word": "doing", + "start": 1617.52, + "end": 1617.82 + }, + { + "word": "flatten", + "start": 1617.82, + "end": 1618.16 + }, + { + "word": "means", + "start": 1618.16, + "end": 1618.64 + }, + { + "word": "you", + "start": 1618.64, + "end": 1619.04 + }, + { + "word": "just", + "start": 1619.04, + "end": 1619.38 + }, + { + "word": "have", + "start": 1619.38, + "end": 1619.88 + }, + { + "word": "a", + "start": 1619.88, + "end": 1621.12 + }, + { + "word": "worse", + "start": 1621.12, + "end": 1621.54 + }, + { + "word": "API", + "start": 1621.54, + "end": 1622.22 + }, + { + "word": "experience.", + "start": 1622.22, + "end": 1622.92 + }, + { + "word": "It", + "start": 1622.94, + "end": 1623.08 + } + ] + }, + { + "start": 1623.08, + "end": 1627.86, + "text": "just feels worse. So that example that I showed earlier where there's like this load object and", + "words": [ + { + "word": "just", + "start": 1623.08, + "end": 1623.32 + }, + { + "word": "feels", + "start": 1623.32, + "end": 1623.58 + }, + { + "word": "worse.", + "start": 1623.58, + "end": 1623.96 + }, + { + "word": "So", + "start": 1624.32, + "end": 1624.4 + }, + { + "word": "that", + "start": 1624.4, + "end": 1624.56 + }, + { + "word": "example", + "start": 1624.56, + "end": 1624.9 + }, + { + "word": "that", + "start": 1624.9, + "end": 1625.1 + }, + { + "word": "I", + "start": 1625.1, + "end": 1625.28 + }, + { + "word": "showed", + "start": 1625.28, + "end": 1625.5 + }, + { + "word": "earlier", + "start": 1625.5, + "end": 1625.96 + }, + { + "word": "where", + "start": 1625.96, + "end": 1626.16 + }, + { + "word": "there's", + "start": 1626.16, + "end": 1626.32 + }, + { + "word": "like", + "start": 1626.32, + "end": 1626.74 + }, + { + "word": "this", + "start": 1626.74, + "end": 1626.94 + }, + { + "word": "load", + "start": 1626.94, + "end": 1627.22 + }, + { + "word": "object", + "start": 1627.22, + "end": 1627.72 + }, + { + "word": "and", + "start": 1627.72, + "end": 1627.86 + } + ] + }, + { + "start": 1627.86, + "end": 1634.22, + "text": "I'm passing HTML in there, initially I had flatten there and it was like, nice, Python can't express", + "words": [ + { + "word": "I'm", + "start": 1627.86, + "end": 1627.98 + }, + { + "word": "passing", + "start": 1627.98, + "end": 1628.24 + }, + { + "word": "HTML", + "start": 1628.24, + "end": 1628.66 + }, + { + "word": "in", + "start": 1628.66, + "end": 1628.84 + }, + { + "word": "there,", + "start": 1628.84, + "end": 1629.36 + }, + { + "word": "initially", + "start": 1629.58, + "end": 1629.96 + }, + { + "word": "I", + "start": 1629.96, + "end": 1630.16 + }, + { + "word": "had", + "start": 1630.16, + "end": 1630.4 + }, + { + "word": "flatten", + "start": 1630.4, + "end": 1630.62 + }, + { + "word": "there", + "start": 1630.62, + "end": 1631.0 + }, + { + "word": "and", + "start": 1631.0, + "end": 1631.08 + }, + { + "word": "it", + "start": 1631.08, + "end": 1631.18 + }, + { + "word": "was", + "start": 1631.18, + "end": 1631.34 + }, + { + "word": "like,", + "start": 1631.34, + "end": 1631.5 + }, + { + "word": "nice,", + "start": 1631.58, + "end": 1632.2 + }, + { + "word": "Python", + "start": 1632.44, + "end": 1632.9 + }, + { + "word": "can't", + "start": 1632.9, + "end": 1633.84 + }, + { + "word": "express", + "start": 1633.84, + "end": 1634.22 + } + ] + }, + { + "start": 1634.22, + "end": 1639.04, + "text": "the kind of thing that I was wanting to. Not simply. And so there are some times where the", + "words": [ + { + "word": "the", + "start": 1634.22, + "end": 1634.32 + }, + { + "word": "kind", + "start": 1634.32, + "end": 1634.48 + }, + { + "word": "of", + "start": 1634.48, + "end": 1634.66 + }, + { + "word": "thing", + "start": 1634.66, + "end": 1634.78 + }, + { + "word": "that", + "start": 1634.78, + "end": 1634.88 + }, + { + "word": "I", + "start": 1634.88, + "end": 1634.96 + }, + { + "word": "was", + "start": 1634.96, + "end": 1635.02 + }, + { + "word": "wanting", + "start": 1635.02, + "end": 1635.22 + }, + { + "word": "to.", + "start": 1635.22, + "end": 1635.44 + }, + { + "word": "Not", + "start": 1635.76, + "end": 1635.78 + }, + { + "word": "simply.", + "start": 1635.78, + "end": 1636.32 + }, + { + "word": "And", + "start": 1637.3, + "end": 1637.46 + }, + { + "word": "so", + "start": 1637.46, + "end": 1637.78 + }, + { + "word": "there", + "start": 1637.78, + "end": 1637.96 + }, + { + "word": "are", + "start": 1637.96, + "end": 1638.04 + }, + { + "word": "some", + "start": 1638.04, + "end": 1638.22 + }, + { + "word": "times", + "start": 1638.22, + "end": 1638.48 + }, + { + "word": "where", + "start": 1638.48, + "end": 1638.8 + }, + { + "word": "the", + "start": 1638.8, + "end": 1639.04 + } + ] + }, + { + "start": 1639.04, + "end": 1645.12, + "text": "trade off of having this extra key is absolutely worth it. Again, use with caution, use with care.", + "words": [ + { + "word": "trade", + "start": 1639.04, + "end": 1639.22 + }, + { + "word": "off", + "start": 1639.22, + "end": 1639.42 + }, + { + "word": "of", + "start": 1639.42, + "end": 1639.66 + }, + { + "word": "having", + "start": 1639.66, + "end": 1639.86 + }, + { + "word": "this", + "start": 1639.86, + "end": 1640.12 + }, + { + "word": "extra", + "start": 1640.12, + "end": 1640.38 + }, + { + "word": "key", + "start": 1640.38, + "end": 1640.68 + }, + { + "word": "is", + "start": 1640.68, + "end": 1641.06 + }, + { + "word": "absolutely", + "start": 1641.06, + "end": 1641.54 + }, + { + "word": "worth", + "start": 1641.54, + "end": 1641.84 + }, + { + "word": "it.", + "start": 1641.84, + "end": 1642.2 + }, + { + "word": "Again,", + "start": 1642.42, + "end": 1642.78 + }, + { + "word": "use", + "start": 1643.26, + "end": 1643.62 + }, + { + "word": "with", + "start": 1643.62, + "end": 1643.96 + }, + { + "word": "caution,", + "start": 1643.96, + "end": 1644.32 + }, + { + "word": "use", + "start": 1644.4, + "end": 1644.56 + }, + { + "word": "with", + "start": 1644.56, + "end": 1644.8 + }, + { + "word": "care.", + "start": 1644.8, + "end": 1645.12 + } + ] + }, + { + "start": 1645.52, + "end": 1650.98, + "text": "This is one of those things where I think it's like worth having a lint rule that points out every", + "words": [ + { + "word": "This", + "start": 1645.52, + "end": 1645.6 + }, + { + "word": "is", + "start": 1645.6, + "end": 1645.76 + }, + { + "word": "one", + "start": 1645.76, + "end": 1645.88 + }, + { + "word": "of", + "start": 1645.88, + "end": 1645.98 + }, + { + "word": "those", + "start": 1645.98, + "end": 1646.14 + }, + { + "word": "things", + "start": 1646.14, + "end": 1646.34 + }, + { + "word": "where", + "start": 1646.34, + "end": 1646.58 + }, + { + "word": "I", + "start": 1646.58, + "end": 1646.64 + }, + { + "word": "think", + "start": 1646.64, + "end": 1646.84 + }, + { + "word": "it's", + "start": 1646.84, + "end": 1648.2 + }, + { + "word": "like", + "start": 1648.2, + "end": 1648.38 + }, + { + "word": "worth", + "start": 1648.38, + "end": 1648.62 + }, + { + "word": "having", + "start": 1648.62, + "end": 1648.9 + }, + { + "word": "a", + "start": 1648.9, + "end": 1649.14 + }, + { + "word": "lint", + "start": 1649.14, + "end": 1649.32 + }, + { + "word": "rule", + "start": 1649.32, + "end": 1649.64 + }, + { + "word": "that", + "start": 1649.64, + "end": 1649.98 + }, + { + "word": "points", + "start": 1649.98, + "end": 1650.2 + }, + { + "word": "out", + "start": 1650.2, + "end": 1650.5 + }, + { + "word": "every", + "start": 1650.5, + "end": 1650.98 + } + ] + }, + { + "start": 1650.98, + "end": 1655.98, + "text": "flatten in your code base and requires you to put an explicit message of like why this thing is", + "words": [ + { + "word": "flatten", + "start": 1650.98, + "end": 1651.28 + }, + { + "word": "in", + "start": 1651.28, + "end": 1651.54 + }, + { + "word": "your", + "start": 1651.54, + "end": 1651.74 + }, + { + "word": "code", + "start": 1651.74, + "end": 1651.96 + }, + { + "word": "base", + "start": 1651.96, + "end": 1652.24 + }, + { + "word": "and", + "start": 1652.24, + "end": 1652.56 + }, + { + "word": "requires", + "start": 1652.56, + "end": 1653.12 + }, + { + "word": "you", + "start": 1653.12, + "end": 1653.42 + }, + { + "word": "to", + "start": 1653.42, + "end": 1653.54 + }, + { + "word": "put", + "start": 1653.54, + "end": 1653.66 + }, + { + "word": "an", + "start": 1653.66, + "end": 1653.86 + }, + { + "word": "explicit", + "start": 1653.86, + "end": 1654.28 + }, + { + "word": "message", + "start": 1654.28, + "end": 1654.76 + }, + { + "word": "of", + "start": 1654.76, + "end": 1654.96 + }, + { + "word": "like", + "start": 1654.96, + "end": 1655.16 + }, + { + "word": "why", + "start": 1655.16, + "end": 1655.4 + }, + { + "word": "this", + "start": 1655.4, + "end": 1655.66 + }, + { + "word": "thing", + "start": 1655.66, + "end": 1655.78 + }, + { + "word": "is", + "start": 1655.78, + "end": 1655.98 + } + ] + }, + { + "start": 1655.98, + "end": 1664.2, + "text": "necessary. I feel that strongly about it because it can really cause some big problems. And the", + "words": [ + { + "word": "necessary.", + "start": 1655.98, + "end": 1656.42 + }, + { + "word": "I", + "start": 1656.48, + "end": 1656.62 + }, + { + "word": "feel", + "start": 1656.62, + "end": 1656.76 + }, + { + "word": "that", + "start": 1656.76, + "end": 1657.1 + }, + { + "word": "strongly", + "start": 1657.1, + "end": 1657.34 + }, + { + "word": "about", + "start": 1657.34, + "end": 1657.58 + }, + { + "word": "it", + "start": 1657.58, + "end": 1657.76 + }, + { + "word": "because", + "start": 1657.76, + "end": 1658.14 + }, + { + "word": "it", + "start": 1658.14, + "end": 1658.4 + }, + { + "word": "can", + "start": 1658.4, + "end": 1658.62 + }, + { + "word": "really", + "start": 1658.62, + "end": 1659.62 + }, + { + "word": "cause", + "start": 1659.62, + "end": 1660.36 + }, + { + "word": "some", + "start": 1660.36, + "end": 1660.74 + }, + { + "word": "big", + "start": 1660.74, + "end": 1660.94 + }, + { + "word": "problems.", + "start": 1660.94, + "end": 1661.46 + }, + { + "word": "And", + "start": 1662.28, + "end": 1662.44 + }, + { + "word": "the", + "start": 1662.44, + "end": 1664.2 + } + ] + }, + { + "start": 1664.2, + "end": 1669.58, + "text": "thing is, if you're building code gen and a larger code base, like Oxide's code base, be very careful", + "words": [ + { + "word": "thing", + "start": 1664.2, + "end": 1664.76 + }, + { + "word": "is,", + "start": 1664.76, + "end": 1664.76 + }, + { + "word": "if", + "start": 1664.76, + "end": 1664.76 + }, + { + "word": "you're", + "start": 1664.76, + "end": 1664.76 + }, + { + "word": "building", + "start": 1664.76, + "end": 1664.76 + }, + { + "word": "code", + "start": 1664.76, + "end": 1665.88 + }, + { + "word": "gen", + "start": 1665.88, + "end": 1666.08 + }, + { + "word": "and", + "start": 1666.08, + "end": 1666.34 + }, + { + "word": "a", + "start": 1666.34, + "end": 1666.36 + }, + { + "word": "larger", + "start": 1666.36, + "end": 1666.72 + }, + { + "word": "code", + "start": 1666.72, + "end": 1666.96 + }, + { + "word": "base,", + "start": 1666.96, + "end": 1667.28 + }, + { + "word": "like", + "start": 1667.46, + "end": 1667.54 + }, + { + "word": "Oxide's", + "start": 1667.54, + "end": 1667.98 + }, + { + "word": "code", + "start": 1667.98, + "end": 1668.1 + }, + { + "word": "base,", + "start": 1668.1, + "end": 1668.3 + }, + { + "word": "be", + "start": 1668.4, + "end": 1668.64 + }, + { + "word": "very", + "start": 1668.64, + "end": 1669.12 + }, + { + "word": "careful", + "start": 1669.12, + "end": 1669.58 + } + ] + }, + { + "start": 1669.58, + "end": 1676.84, + "text": "about having pieces of generated code depending on each other. Because you can get in this loop", + "words": [ + { + "word": "about", + "start": 1669.58, + "end": 1670.36 + }, + { + "word": "having", + "start": 1670.36, + "end": 1671.02 + }, + { + "word": "pieces", + "start": 1671.02, + "end": 1673.16 + }, + { + "word": "of", + "start": 1673.16, + "end": 1673.46 + }, + { + "word": "generated", + "start": 1673.46, + "end": 1673.66 + }, + { + "word": "code", + "start": 1673.66, + "end": 1673.88 + }, + { + "word": "depending", + "start": 1673.88, + "end": 1674.14 + }, + { + "word": "on", + "start": 1674.14, + "end": 1674.26 + }, + { + "word": "each", + "start": 1674.26, + "end": 1674.46 + }, + { + "word": "other.", + "start": 1674.46, + "end": 1674.72 + }, + { + "word": "Because", + "start": 1674.96, + "end": 1675.04 + }, + { + "word": "you", + "start": 1675.04, + "end": 1675.08 + }, + { + "word": "can", + "start": 1675.08, + "end": 1675.32 + }, + { + "word": "get", + "start": 1675.32, + "end": 1675.5 + }, + { + "word": "in", + "start": 1675.5, + "end": 1675.64 + }, + { + "word": "this", + "start": 1675.64, + "end": 1676.3 + }, + { + "word": "loop", + "start": 1676.3, + "end": 1676.84 + } + ] + }, + { + "start": 1676.84, + "end": 1681.76, + "text": "where code gen breaks on one thing and you can't build because another code gen thing depends on", + "words": [ + { + "word": "where", + "start": 1676.84, + "end": 1677.62 + }, + { + "word": "code", + "start": 1677.62, + "end": 1677.92 + }, + { + "word": "gen", + "start": 1677.92, + "end": 1678.08 + }, + { + "word": "breaks", + "start": 1678.08, + "end": 1678.34 + }, + { + "word": "on", + "start": 1678.34, + "end": 1678.54 + }, + { + "word": "one", + "start": 1678.54, + "end": 1678.74 + }, + { + "word": "thing", + "start": 1678.74, + "end": 1678.92 + }, + { + "word": "and", + "start": 1678.92, + "end": 1679.06 + }, + { + "word": "you", + "start": 1679.06, + "end": 1679.16 + }, + { + "word": "can't", + "start": 1679.16, + "end": 1679.48 + }, + { + "word": "build", + "start": 1679.48, + "end": 1679.94 + }, + { + "word": "because", + "start": 1679.94, + "end": 1680.32 + }, + { + "word": "another", + "start": 1680.32, + "end": 1680.7 + }, + { + "word": "code", + "start": 1680.7, + "end": 1680.92 + }, + { + "word": "gen", + "start": 1680.92, + "end": 1681.12 + }, + { + "word": "thing", + "start": 1681.12, + "end": 1681.32 + }, + { + "word": "depends", + "start": 1681.32, + "end": 1681.62 + }, + { + "word": "on", + "start": 1681.62, + "end": 1681.76 + } + ] + }, + { + "start": 1681.76, + "end": 1686.52, + "text": "the first thing existing. And Oxide definitely had that. Whereas this bootstrapping problem,", + "words": [ + { + "word": "the", + "start": 1681.76, + "end": 1681.88 + }, + { + "word": "first", + "start": 1681.88, + "end": 1682.08 + }, + { + "word": "thing", + "start": 1682.08, + "end": 1682.28 + }, + { + "word": "existing.", + "start": 1682.28, + "end": 1682.7 + }, + { + "word": "And", + "start": 1683.42, + "end": 1683.56 + }, + { + "word": "Oxide", + "start": 1683.56, + "end": 1683.86 + }, + { + "word": "definitely", + "start": 1683.86, + "end": 1684.26 + }, + { + "word": "had", + "start": 1684.26, + "end": 1684.54 + }, + { + "word": "that.", + "start": 1684.54, + "end": 1684.88 + }, + { + "word": "Whereas", + "start": 1685.22, + "end": 1685.22 + }, + { + "word": "this", + "start": 1685.22, + "end": 1685.62 + }, + { + "word": "bootstrapping", + "start": 1685.62, + "end": 1686.16 + }, + { + "word": "problem,", + "start": 1686.16, + "end": 1686.52 + } + ] + }, + { + "start": 1686.7, + "end": 1693.16, + "text": "you're like, how do I build? And we'd have like 45 minute long debugging sessions where we're", + "words": [ + { + "word": "you're", + "start": 1686.7, + "end": 1686.74 + }, + { + "word": "like,", + "start": 1686.74, + "end": 1686.94 + }, + { + "word": "how", + "start": 1687.54, + "end": 1687.58 + }, + { + "word": "do", + "start": 1687.58, + "end": 1687.76 + }, + { + "word": "I", + "start": 1687.76, + "end": 1687.88 + }, + { + "word": "build?", + "start": 1687.88, + "end": 1688.26 + }, + { + "word": "And", + "start": 1689.0, + "end": 1689.18 + }, + { + "word": "we'd", + "start": 1689.18, + "end": 1689.46 + }, + { + "word": "have", + "start": 1689.46, + "end": 1689.9 + }, + { + "word": "like", + "start": 1689.9, + "end": 1690.26 + }, + { + "word": "45", + "start": 1690.26, + "end": 1690.58 + }, + { + "word": "minute", + "start": 1690.58, + "end": 1690.88 + }, + { + "word": "long", + "start": 1690.88, + "end": 1691.24 + }, + { + "word": "debugging", + "start": 1691.24, + "end": 1691.66 + }, + { + "word": "sessions", + "start": 1691.66, + "end": 1692.12 + }, + { + "word": "where", + "start": 1692.12, + "end": 1692.42 + }, + { + "word": "we're", + "start": 1692.42, + "end": 1693.16 + } + ] + }, + { + "start": 1693.16, + "end": 1697.88, + "text": "out the right sequences of events to delete or whatever to get it to work. They're in a much", + "words": [ + { + "word": "out", + "start": 1693.16, + "end": 1693.26 + }, + { + "word": "the", + "start": 1693.26, + "end": 1693.46 + }, + { + "word": "right", + "start": 1693.46, + "end": 1693.84 + }, + { + "word": "sequences", + "start": 1693.84, + "end": 1694.38 + }, + { + "word": "of", + "start": 1694.38, + "end": 1694.84 + }, + { + "word": "events", + "start": 1694.84, + "end": 1695.02 + }, + { + "word": "to", + "start": 1695.02, + "end": 1695.5 + }, + { + "word": "delete", + "start": 1695.5, + "end": 1695.82 + }, + { + "word": "or", + "start": 1695.82, + "end": 1695.98 + }, + { + "word": "whatever", + "start": 1695.98, + "end": 1696.26 + }, + { + "word": "to", + "start": 1696.26, + "end": 1696.4 + }, + { + "word": "get", + "start": 1696.4, + "end": 1696.64 + }, + { + "word": "it", + "start": 1696.64, + "end": 1696.82 + }, + { + "word": "to", + "start": 1696.82, + "end": 1696.94 + }, + { + "word": "work.", + "start": 1696.94, + "end": 1697.18 + }, + { + "word": "They're", + "start": 1697.46, + "end": 1697.58 + }, + { + "word": "in", + "start": 1697.58, + "end": 1697.68 + }, + { + "word": "a", + "start": 1697.68, + "end": 1697.68 + }, + { + "word": "much", + "start": 1697.68, + "end": 1697.88 + } + ] + }, + { + "start": 1697.88, + "end": 1702.66, + "text": "better spot now. They actually fixed it architecturally. But that's a problem.", + "words": [ + { + "word": "better", + "start": 1697.88, + "end": 1698.08 + }, + { + "word": "spot", + "start": 1698.08, + "end": 1698.3 + }, + { + "word": "now.", + "start": 1698.3, + "end": 1698.6 + }, + { + "word": "They", + "start": 1698.66, + "end": 1698.76 + }, + { + "word": "actually", + "start": 1698.76, + "end": 1699.1 + }, + { + "word": "fixed", + "start": 1699.1, + "end": 1699.24 + }, + { + "word": "it", + "start": 1699.24, + "end": 1699.44 + }, + { + "word": "architecturally.", + "start": 1699.44, + "end": 1699.94 + }, + { + "word": "But", + "start": 1700.8, + "end": 1700.92 + }, + { + "word": "that's", + "start": 1700.92, + "end": 1702.34 + }, + { + "word": "a", + "start": 1702.34, + "end": 1702.4 + }, + { + "word": "problem.", + "start": 1702.4, + "end": 1702.66 + } + ] + }, + { + "start": 1704.9, + "end": 1708.58, + "text": "I guess as I wrap up, I think it's worth talking about the elephant in the room.", + "words": [ + { + "word": "I", + "start": 1704.9, + "end": 1705.28 + }, + { + "word": "guess", + "start": 1705.28, + "end": 1705.54 + }, + { + "word": "as", + "start": 1705.54, + "end": 1705.88 + }, + { + "word": "I", + "start": 1705.88, + "end": 1706.08 + }, + { + "word": "wrap", + "start": 1706.08, + "end": 1706.28 + }, + { + "word": "up,", + "start": 1706.28, + "end": 1706.6 + }, + { + "word": "I", + "start": 1706.72, + "end": 1706.84 + }, + { + "word": "think", + "start": 1706.84, + "end": 1706.98 + }, + { + "word": "it's", + "start": 1706.98, + "end": 1707.18 + }, + { + "word": "worth", + "start": 1707.18, + "end": 1707.28 + }, + { + "word": "talking", + "start": 1707.28, + "end": 1707.56 + }, + { + "word": "about", + "start": 1707.56, + "end": 1707.74 + }, + { + "word": "the", + "start": 1707.74, + "end": 1707.9 + }, + { + "word": "elephant", + "start": 1707.9, + "end": 1708.08 + }, + { + "word": "in", + "start": 1708.08, + "end": 1708.22 + }, + { + "word": "the", + "start": 1708.22, + "end": 1708.32 + }, + { + "word": "room.", + "start": 1708.32, + "end": 1708.58 + } + ] + }, + { + "start": 1710.22, + "end": 1716.28, + "text": "Why write code to write code when there's code that will write code for you? Why go through all", + "words": [ + { + "word": "Why", + "start": 1710.22, + "end": 1710.62 + }, + { + "word": "write", + "start": 1710.62, + "end": 1711.02 + }, + { + "word": "code", + "start": 1711.02, + "end": 1711.3 + }, + { + "word": "to", + "start": 1711.3, + "end": 1711.52 + }, + { + "word": "write", + "start": 1711.52, + "end": 1711.74 + }, + { + "word": "code", + "start": 1711.74, + "end": 1712.18 + }, + { + "word": "when", + "start": 1712.18, + "end": 1712.54 + }, + { + "word": "there's", + "start": 1712.54, + "end": 1712.9 + }, + { + "word": "code", + "start": 1712.9, + "end": 1713.16 + }, + { + "word": "that", + "start": 1713.16, + "end": 1713.32 + }, + { + "word": "will", + "start": 1713.32, + "end": 1713.48 + }, + { + "word": "write", + "start": 1713.48, + "end": 1713.64 + }, + { + "word": "code", + "start": 1713.64, + "end": 1713.82 + }, + { + "word": "for", + "start": 1713.82, + "end": 1714.04 + }, + { + "word": "you?", + "start": 1714.04, + "end": 1714.24 + }, + { + "word": "Why", + "start": 1715.2, + "end": 1715.6 + }, + { + "word": "go", + "start": 1715.6, + "end": 1715.96 + }, + { + "word": "through", + "start": 1715.96, + "end": 1716.14 + }, + { + "word": "all", + "start": 1716.14, + "end": 1716.28 + } + ] + }, + { + "start": 1716.28, + "end": 1721.54, + "text": "the work? The LLMs are good. You can, you know, magic black box, just ask it to do things for you.", + "words": [ + { + "word": "the", + "start": 1716.28, + "end": 1716.44 + }, + { + "word": "work?", + "start": 1716.44, + "end": 1716.74 + }, + { + "word": "The", + "start": 1717.38, + "end": 1717.58 + }, + { + "word": "LLMs", + "start": 1717.58, + "end": 1717.76 + }, + { + "word": "are", + "start": 1717.76, + "end": 1717.98 + }, + { + "word": "good.", + "start": 1717.98, + "end": 1718.2 + }, + { + "word": "You", + "start": 1718.54, + "end": 1718.6 + }, + { + "word": "can,", + "start": 1718.6, + "end": 1719.06 + }, + { + "word": "you", + "start": 1719.06, + "end": 1719.06 + }, + { + "word": "know,", + "start": 1719.06, + "end": 1719.28 + }, + { + "word": "magic", + "start": 1719.38, + "end": 1719.56 + }, + { + "word": "black", + "start": 1719.56, + "end": 1719.76 + }, + { + "word": "box,", + "start": 1719.76, + "end": 1720.08 + }, + { + "word": "just", + "start": 1720.12, + "end": 1720.5 + }, + { + "word": "ask", + "start": 1720.5, + "end": 1720.66 + }, + { + "word": "it", + "start": 1720.66, + "end": 1720.74 + }, + { + "word": "to", + "start": 1720.74, + "end": 1720.88 + }, + { + "word": "do", + "start": 1720.88, + "end": 1720.94 + }, + { + "word": "things", + "start": 1720.94, + "end": 1721.12 + }, + { + "word": "for", + "start": 1721.12, + "end": 1721.32 + }, + { + "word": "you.", + "start": 1721.32, + "end": 1721.54 + } + ] + }, + { + "start": 1722.24, + "end": 1727.06, + "text": "And so here's my case for like why this matters and why you should care and why you should do it.", + "words": [ + { + "word": "And", + "start": 1722.24, + "end": 1722.7 + }, + { + "word": "so", + "start": 1722.7, + "end": 1723.14 + }, + { + "word": "here's", + "start": 1723.14, + "end": 1723.36 + }, + { + "word": "my", + "start": 1723.36, + "end": 1723.74 + }, + { + "word": "case", + "start": 1723.74, + "end": 1724.2 + }, + { + "word": "for", + "start": 1724.2, + "end": 1724.54 + }, + { + "word": "like", + "start": 1724.54, + "end": 1724.82 + }, + { + "word": "why", + "start": 1724.82, + "end": 1724.94 + }, + { + "word": "this", + "start": 1724.94, + "end": 1725.14 + }, + { + "word": "matters", + "start": 1725.14, + "end": 1725.44 + }, + { + "word": "and", + "start": 1725.44, + "end": 1725.56 + }, + { + "word": "why", + "start": 1725.56, + "end": 1725.78 + }, + { + "word": "you", + "start": 1725.78, + "end": 1725.92 + }, + { + "word": "should", + "start": 1725.92, + "end": 1726.12 + }, + { + "word": "care", + "start": 1726.12, + "end": 1726.44 + }, + { + "word": "and", + "start": 1726.44, + "end": 1726.58 + }, + { + "word": "why", + "start": 1726.58, + "end": 1726.68 + }, + { + "word": "you", + "start": 1726.68, + "end": 1726.8 + }, + { + "word": "should", + "start": 1726.8, + "end": 1726.9 + }, + { + "word": "do", + "start": 1726.9, + "end": 1727.04 + }, + { + "word": "it.", + "start": 1727.04, + "end": 1727.27 + } + ] + }, + { + "start": 1728.5, + "end": 1733.94, + "text": "So when you're building an interface, be it an SDK or an API, that is a thing that another human", + "words": [ + { + "word": "So", + "start": 1728.5, + "end": 1728.96 + }, + { + "word": "when", + "start": 1728.96, + "end": 1729.32 + }, + { + "word": "you're", + "start": 1729.32, + "end": 1729.42 + }, + { + "word": "building", + "start": 1729.42, + "end": 1729.62 + }, + { + "word": "an", + "start": 1729.62, + "end": 1729.84 + }, + { + "word": "interface,", + "start": 1729.84, + "end": 1730.3 + }, + { + "word": "be", + "start": 1730.6, + "end": 1730.68 + }, + { + "word": "it", + "start": 1730.68, + "end": 1730.78 + }, + { + "word": "an", + "start": 1730.78, + "end": 1730.92 + }, + { + "word": "SDK", + "start": 1730.92, + "end": 1731.16 + }, + { + "word": "or", + "start": 1731.16, + "end": 1731.34 + }, + { + "word": "an", + "start": 1731.34, + "end": 1731.48 + }, + { + "word": "API,", + "start": 1731.48, + "end": 1731.74 + }, + { + "word": "that", + "start": 1732.04, + "end": 1732.34 + }, + { + "word": "is", + "start": 1732.34, + "end": 1732.56 + }, + { + "word": "a", + "start": 1732.56, + "end": 1732.76 + }, + { + "word": "thing", + "start": 1732.76, + "end": 1732.96 + }, + { + "word": "that", + "start": 1732.96, + "end": 1733.18 + }, + { + "word": "another", + "start": 1733.18, + "end": 1733.44 + }, + { + "word": "human", + "start": 1733.44, + "end": 1733.94 + } + ] + }, + { + "start": 1733.94, + "end": 1738.54, + "text": "hopefully will touch or hopefully will care about. And if they don't care, then generate away. But", + "words": [ + { + "word": "hopefully", + "start": 1733.94, + "end": 1734.52 + }, + { + "word": "will", + "start": 1734.52, + "end": 1734.78 + }, + { + "word": "touch", + "start": 1734.78, + "end": 1735.04 + }, + { + "word": "or", + "start": 1735.04, + "end": 1735.3 + }, + { + "word": "hopefully", + "start": 1735.3, + "end": 1735.64 + }, + { + "word": "will", + "start": 1735.64, + "end": 1735.8 + }, + { + "word": "care", + "start": 1735.8, + "end": 1735.96 + }, + { + "word": "about.", + "start": 1735.96, + "end": 1736.24 + }, + { + "word": "And", + "start": 1736.42, + "end": 1736.54 + }, + { + "word": "if", + "start": 1736.54, + "end": 1736.58 + }, + { + "word": "they", + "start": 1736.58, + "end": 1736.72 + }, + { + "word": "don't", + "start": 1736.72, + "end": 1736.88 + }, + { + "word": "care,", + "start": 1736.88, + "end": 1737.22 + }, + { + "word": "then", + "start": 1737.34, + "end": 1737.54 + }, + { + "word": "generate", + "start": 1737.54, + "end": 1737.82 + }, + { + "word": "away.", + "start": 1737.82, + "end": 1738.14 + }, + { + "word": "But", + "start": 1738.42, + "end": 1738.54 + } + ] + }, + { + "start": 1738.54, + "end": 1744.02, + "text": "if they, if it ever has to be read or used by another human being, please for the love of God,", + "words": [ + { + "word": "if", + "start": 1738.54, + "end": 1738.64 + }, + { + "word": "they,", + "start": 1738.64, + "end": 1738.96 + }, + { + "word": "if", + "start": 1739.06, + "end": 1739.18 + }, + { + "word": "it", + "start": 1739.18, + "end": 1739.36 + }, + { + "word": "ever", + "start": 1739.36, + "end": 1739.76 + }, + { + "word": "has", + "start": 1739.76, + "end": 1740.52 + }, + { + "word": "to", + "start": 1740.52, + "end": 1740.7 + }, + { + "word": "be", + "start": 1740.7, + "end": 1741.04 + }, + { + "word": "read", + "start": 1741.04, + "end": 1741.32 + }, + { + "word": "or", + "start": 1741.32, + "end": 1741.64 + }, + { + "word": "used", + "start": 1741.64, + "end": 1741.88 + }, + { + "word": "by", + "start": 1741.88, + "end": 1742.1 + }, + { + "word": "another", + "start": 1742.1, + "end": 1742.26 + }, + { + "word": "human", + "start": 1742.26, + "end": 1742.5 + }, + { + "word": "being,", + "start": 1742.5, + "end": 1742.88 + }, + { + "word": "please", + "start": 1743.28, + "end": 1743.32 + }, + { + "word": "for", + "start": 1743.32, + "end": 1743.46 + }, + { + "word": "the", + "start": 1743.46, + "end": 1743.62 + }, + { + "word": "love", + "start": 1743.62, + "end": 1743.7 + }, + { + "word": "of", + "start": 1743.7, + "end": 1743.86 + }, + { + "word": "God,", + "start": 1743.86, + "end": 1744.02 + } + ] + }, + { + "start": 1744.04, + "end": 1750.1, + "text": "care about them and make it not hellacious. Because there are so many really bad APIs out there.", + "words": [ + { + "word": "care", + "start": 1744.04, + "end": 1744.32 + }, + { + "word": "about", + "start": 1744.32, + "end": 1744.56 + }, + { + "word": "them", + "start": 1744.56, + "end": 1744.96 + }, + { + "word": "and", + "start": 1744.96, + "end": 1745.38 + }, + { + "word": "make", + "start": 1745.38, + "end": 1745.6 + }, + { + "word": "it", + "start": 1745.6, + "end": 1746.24 + }, + { + "word": "not", + "start": 1746.24, + "end": 1746.72 + }, + { + "word": "hellacious.", + "start": 1746.72, + "end": 1747.36 + }, + { + "word": "Because", + "start": 1747.5, + "end": 1747.74 + }, + { + "word": "there", + "start": 1747.74, + "end": 1747.94 + }, + { + "word": "are", + "start": 1747.94, + "end": 1748.06 + }, + { + "word": "so", + "start": 1748.06, + "end": 1748.3 + }, + { + "word": "many", + "start": 1748.3, + "end": 1748.46 + }, + { + "word": "really", + "start": 1748.46, + "end": 1748.78 + }, + { + "word": "bad", + "start": 1748.78, + "end": 1749.12 + }, + { + "word": "APIs", + "start": 1749.12, + "end": 1749.46 + }, + { + "word": "out", + "start": 1749.46, + "end": 1749.74 + }, + { + "word": "there.", + "start": 1749.74, + "end": 1750.1 + } + ] + }, + { + "start": 1750.1, + "end": 1755.8, + "text": "And the companies that do really, really well often have pretty decent APIs. Not as a rule,", + "words": [ + { + "word": "And", + "start": 1750.1, + "end": 1750.46 + }, + { + "word": "the", + "start": 1750.46, + "end": 1750.68 + }, + { + "word": "companies", + "start": 1750.68, + "end": 1751.02 + }, + { + "word": "that", + "start": 1751.02, + "end": 1751.26 + }, + { + "word": "do", + "start": 1751.26, + "end": 1751.58 + }, + { + "word": "really,", + "start": 1751.58, + "end": 1751.9 + }, + { + "word": "really", + "start": 1751.9, + "end": 1752.14 + }, + { + "word": "well", + "start": 1752.14, + "end": 1752.5 + }, + { + "word": "often", + "start": 1752.5, + "end": 1752.86 + }, + { + "word": "have", + "start": 1752.86, + "end": 1753.28 + }, + { + "word": "pretty", + "start": 1753.28, + "end": 1753.52 + }, + { + "word": "decent", + "start": 1753.52, + "end": 1753.96 + }, + { + "word": "APIs.", + "start": 1753.96, + "end": 1754.3 + }, + { + "word": "Not", + "start": 1754.64, + "end": 1754.82 + }, + { + "word": "as", + "start": 1754.82, + "end": 1755.44 + }, + { + "word": "a", + "start": 1755.44, + "end": 1755.52 + }, + { + "word": "rule,", + "start": 1755.52, + "end": 1755.8 + } + ] + }, + { + "start": 1755.84, + "end": 1760.66, + "text": "but like often. Stripe, for example, fantastic API, well, for what they are.", + "words": [ + { + "word": "but", + "start": 1755.84, + "end": 1756.04 + }, + { + "word": "like", + "start": 1756.04, + "end": 1756.24 + }, + { + "word": "often.", + "start": 1756.24, + "end": 1756.72 + }, + { + "word": "Stripe,", + "start": 1757.28, + "end": 1757.44 + }, + { + "word": "for", + "start": 1757.64, + "end": 1757.64 + }, + { + "word": "example,", + "start": 1757.64, + "end": 1758.02 + }, + { + "word": "fantastic", + "start": 1758.22, + "end": 1758.58 + }, + { + "word": "API,", + "start": 1758.58, + "end": 1759.16 + }, + { + "word": "well,", + "start": 1759.62, + "end": 1759.96 + }, + { + "word": "for", + "start": 1760.2, + "end": 1760.3 + }, + { + "word": "what", + "start": 1760.3, + "end": 1760.42 + }, + { + "word": "they", + "start": 1760.42, + "end": 1760.64 + }, + { + "word": "are.", + "start": 1760.64, + "end": 1760.96 + } + ] + }, + { + "start": 1766.76, + "end": 1773.72, + "text": "One of the major tradeoffs here is that you are forced to face these translation constraints", + "words": [ + { + "word": "One", + "start": 1766.76, + "end": 1767.2 + }, + { + "word": "of", + "start": 1767.2, + "end": 1767.32 + }, + { + "word": "the", + "start": 1767.32, + "end": 1767.56 + }, + { + "word": "major", + "start": 1767.56, + "end": 1767.78 + }, + { + "word": "tradeoffs", + "start": 1767.78, + "end": 1768.16 + }, + { + "word": "here", + "start": 1768.16, + "end": 1768.76 + }, + { + "word": "is", + "start": 1768.76, + "end": 1769.62 + }, + { + "word": "that", + "start": 1769.62, + "end": 1769.86 + }, + { + "word": "you", + "start": 1769.86, + "end": 1770.06 + }, + { + "word": "are", + "start": 1770.06, + "end": 1770.3 + }, + { + "word": "forced", + "start": 1770.3, + "end": 1770.74 + }, + { + "word": "to", + "start": 1770.74, + "end": 1771.46 + }, + { + "word": "face", + "start": 1771.46, + "end": 1772.3 + }, + { + "word": "these", + "start": 1772.3, + "end": 1772.86 + }, + { + "word": "translation", + "start": 1772.86, + "end": 1773.3 + }, + { + "word": "constraints", + "start": 1773.3, + "end": 1773.72 + } + ] + }, + { + "start": 1773.72, + "end": 1779.88, + "text": "early. But it's also a positive because you really have to think about the complexity of your code", + "words": [ + { + "word": "early.", + "start": 1773.72, + "end": 1774.18 + }, + { + "word": "But", + "start": 1774.44, + "end": 1774.98 + }, + { + "word": "it's", + "start": 1774.98, + "end": 1776.2 + }, + { + "word": "also", + "start": 1776.2, + "end": 1776.7 + }, + { + "word": "a", + "start": 1776.7, + "end": 1776.98 + }, + { + "word": "positive", + "start": 1776.98, + "end": 1777.32 + }, + { + "word": "because", + "start": 1777.32, + "end": 1777.58 + }, + { + "word": "you", + "start": 1777.58, + "end": 1777.76 + }, + { + "word": "really", + "start": 1777.76, + "end": 1777.92 + }, + { + "word": "have", + "start": 1777.92, + "end": 1778.04 + }, + { + "word": "to", + "start": 1778.04, + "end": 1778.18 + }, + { + "word": "think", + "start": 1778.18, + "end": 1778.3 + }, + { + "word": "about", + "start": 1778.3, + "end": 1778.48 + }, + { + "word": "the", + "start": 1778.48, + "end": 1778.7 + }, + { + "word": "complexity", + "start": 1778.7, + "end": 1779.1 + }, + { + "word": "of", + "start": 1779.1, + "end": 1779.36 + }, + { + "word": "your", + "start": 1779.36, + "end": 1779.56 + }, + { + "word": "code", + "start": 1779.56, + "end": 1779.88 + } + ] + }, + { + "start": 1780.1, + "end": 1785.76, + "text": "and you have to land on these like simpler patterns and the constraints actually become", + "words": [ + { + "word": "and", + "start": 1780.1, + "end": 1780.42 + }, + { + "word": "you", + "start": 1780.42, + "end": 1780.56 + }, + { + "word": "have", + "start": 1780.56, + "end": 1780.9 + }, + { + "word": "to", + "start": 1780.9, + "end": 1781.82 + }, + { + "word": "land", + "start": 1781.82, + "end": 1782.26 + }, + { + "word": "on", + "start": 1782.26, + "end": 1782.56 + }, + { + "word": "these", + "start": 1782.56, + "end": 1783.0 + }, + { + "word": "like", + "start": 1783.0, + "end": 1783.1 + }, + { + "word": "simpler", + "start": 1783.1, + "end": 1783.42 + }, + { + "word": "patterns", + "start": 1783.42, + "end": 1784.0 + }, + { + "word": "and", + "start": 1784.0, + "end": 1784.32 + }, + { + "word": "the", + "start": 1784.32, + "end": 1784.56 + }, + { + "word": "constraints", + "start": 1784.56, + "end": 1784.94 + }, + { + "word": "actually", + "start": 1784.94, + "end": 1785.5 + }, + { + "word": "become", + "start": 1785.5, + "end": 1785.76 + } + ] + }, + { + "start": 1785.76, + "end": 1790.28, + "text": "a superpower. It just makes it easier to think about like, if I'm building this new data structure,", + "words": [ + { + "word": "a", + "start": 1785.76, + "end": 1785.94 + }, + { + "word": "superpower.", + "start": 1785.94, + "end": 1786.28 + }, + { + "word": "It", + "start": 1786.6, + "end": 1786.68 + }, + { + "word": "just", + "start": 1786.68, + "end": 1786.92 + }, + { + "word": "makes", + "start": 1786.92, + "end": 1787.06 + }, + { + "word": "it", + "start": 1787.06, + "end": 1787.3 + }, + { + "word": "easier", + "start": 1787.3, + "end": 1787.62 + }, + { + "word": "to", + "start": 1787.62, + "end": 1787.84 + }, + { + "word": "think", + "start": 1787.84, + "end": 1787.98 + }, + { + "word": "about", + "start": 1787.98, + "end": 1788.28 + }, + { + "word": "like,", + "start": 1788.28, + "end": 1788.74 + }, + { + "word": "if", + "start": 1788.84, + "end": 1788.94 + }, + { + "word": "I'm", + "start": 1788.94, + "end": 1789.04 + }, + { + "word": "building", + "start": 1789.04, + "end": 1789.26 + }, + { + "word": "this", + "start": 1789.26, + "end": 1789.48 + }, + { + "word": "new", + "start": 1789.48, + "end": 1789.64 + }, + { + "word": "data", + "start": 1789.64, + "end": 1789.82 + }, + { + "word": "structure,", + "start": 1789.82, + "end": 1790.28 + } + ] + }, + { + "start": 1790.6, + "end": 1794.8, + "text": "what is the patterns in the rest of my code base of like how I limit how I shape data structures.", + "words": [ + { + "word": "what", + "start": 1790.6, + "end": 1790.72 + }, + { + "word": "is", + "start": 1790.72, + "end": 1790.9 + }, + { + "word": "the", + "start": 1790.9, + "end": 1791.1 + }, + { + "word": "patterns", + "start": 1791.1, + "end": 1791.46 + }, + { + "word": "in", + "start": 1791.46, + "end": 1791.74 + }, + { + "word": "the", + "start": 1791.74, + "end": 1791.84 + }, + { + "word": "rest", + "start": 1791.84, + "end": 1791.98 + }, + { + "word": "of", + "start": 1791.98, + "end": 1792.12 + }, + { + "word": "my", + "start": 1792.12, + "end": 1792.26 + }, + { + "word": "code", + "start": 1792.26, + "end": 1792.42 + }, + { + "word": "base", + "start": 1792.42, + "end": 1792.68 + }, + { + "word": "of", + "start": 1792.68, + "end": 1792.9 + }, + { + "word": "like", + "start": 1792.9, + "end": 1793.06 + }, + { + "word": "how", + "start": 1793.06, + "end": 1793.24 + }, + { + "word": "I", + "start": 1793.24, + "end": 1793.44 + }, + { + "word": "limit", + "start": 1793.44, + "end": 1793.64 + }, + { + "word": "how", + "start": 1793.64, + "end": 1793.84 + }, + { + "word": "I", + "start": 1793.84, + "end": 1794.08 + }, + { + "word": "shape", + "start": 1794.08, + "end": 1794.18 + }, + { + "word": "data", + "start": 1794.18, + "end": 1794.42 + }, + { + "word": "structures.", + "start": 1794.42, + "end": 1794.8 + } + ] + }, + { + "start": 1794.86, + "end": 1799.72, + "text": "And overall, the consistency actually will help you a lot, especially when you're in a very", + "words": [ + { + "word": "And", + "start": 1794.86, + "end": 1795.18 + }, + { + "word": "overall,", + "start": 1795.18, + "end": 1795.66 + }, + { + "word": "the", + "start": 1796.04, + "end": 1796.28 + }, + { + "word": "consistency", + "start": 1796.28, + "end": 1796.86 + }, + { + "word": "actually", + "start": 1796.86, + "end": 1797.52 + }, + { + "word": "will", + "start": 1797.52, + "end": 1797.72 + }, + { + "word": "help", + "start": 1797.72, + "end": 1797.82 + }, + { + "word": "you", + "start": 1797.82, + "end": 1798.0 + }, + { + "word": "a", + "start": 1798.0, + "end": 1798.1 + }, + { + "word": "lot,", + "start": 1798.1, + "end": 1798.28 + }, + { + "word": "especially", + "start": 1798.4, + "end": 1798.84 + }, + { + "word": "when", + "start": 1798.84, + "end": 1799.16 + }, + { + "word": "you're", + "start": 1799.16, + "end": 1799.28 + }, + { + "word": "in", + "start": 1799.28, + "end": 1799.36 + }, + { + "word": "a", + "start": 1799.36, + "end": 1799.46 + }, + { + "word": "very", + "start": 1799.46, + "end": 1799.72 + } + ] + }, + { + "start": 1799.72, + "end": 1803.62, + "text": "expressive language like Rust. And there's like 20 different ways to express the same thing.", + "words": [ + { + "word": "expressive", + "start": 1799.72, + "end": 1800.04 + }, + { + "word": "language", + "start": 1800.04, + "end": 1800.36 + }, + { + "word": "like", + "start": 1800.36, + "end": 1800.58 + }, + { + "word": "Rust.", + "start": 1800.58, + "end": 1800.82 + }, + { + "word": "And", + "start": 1800.92, + "end": 1800.98 + }, + { + "word": "there's", + "start": 1800.98, + "end": 1801.18 + }, + { + "word": "like", + "start": 1801.18, + "end": 1801.4 + }, + { + "word": "20", + "start": 1801.4, + "end": 1801.62 + }, + { + "word": "different", + "start": 1801.62, + "end": 1801.88 + }, + { + "word": "ways", + "start": 1801.88, + "end": 1802.44 + }, + { + "word": "to", + "start": 1802.44, + "end": 1802.88 + }, + { + "word": "express", + "start": 1802.88, + "end": 1803.1 + }, + { + "word": "the", + "start": 1803.1, + "end": 1803.32 + }, + { + "word": "same", + "start": 1803.32, + "end": 1803.48 + }, + { + "word": "thing.", + "start": 1803.48, + "end": 1803.72 + } + ] + }, + { + "start": 1805.38, + "end": 1809.28, + "text": "Meta programming is a superpower. Macros by extension are a superpower, but", + "words": [ + { + "word": "Meta", + "start": 1805.38, + "end": 1805.58 + }, + { + "word": "programming", + "start": 1805.58, + "end": 1805.86 + }, + { + "word": "is", + "start": 1805.86, + "end": 1806.1 + }, + { + "word": "a", + "start": 1806.1, + "end": 1806.24 + }, + { + "word": "superpower.", + "start": 1806.24, + "end": 1806.68 + }, + { + "word": "Macros", + "start": 1806.96, + "end": 1807.3 + }, + { + "word": "by", + "start": 1807.3, + "end": 1807.52 + }, + { + "word": "extension", + "start": 1807.52, + "end": 1807.88 + }, + { + "word": "are", + "start": 1807.88, + "end": 1808.16 + }, + { + "word": "a", + "start": 1808.16, + "end": 1808.28 + }, + { + "word": "superpower,", + "start": 1808.28, + "end": 1808.6 + }, + { + "word": "but", + "start": 1808.84, + "end": 1809.28 + } + ] + }, + { + "start": 1809.28, + "end": 1815.58, + "text": "use with care, use with caution. Also, we all know that Rust compile times are atrocious sometimes.", + "words": [ + { + "word": "use", + "start": 1809.28, + "end": 1809.84 + }, + { + "word": "with", + "start": 1809.84, + "end": 1810.1 + }, + { + "word": "care,", + "start": 1810.1, + "end": 1810.3 + }, + { + "word": "use", + "start": 1810.42, + "end": 1810.54 + }, + { + "word": "with", + "start": 1810.54, + "end": 1810.7 + }, + { + "word": "caution.", + "start": 1810.7, + "end": 1811.04 + }, + { + "word": "Also,", + "start": 1811.6, + "end": 1811.82 + }, + { + "word": "we", + "start": 1811.92, + "end": 1812.36 + }, + { + "word": "all", + "start": 1812.36, + "end": 1812.54 + }, + { + "word": "know", + "start": 1812.54, + "end": 1812.7 + }, + { + "word": "that", + "start": 1812.7, + "end": 1812.84 + }, + { + "word": "Rust", + "start": 1812.84, + "end": 1812.96 + }, + { + "word": "compile", + "start": 1812.96, + "end": 1813.3 + }, + { + "word": "times", + "start": 1813.3, + "end": 1813.56 + }, + { + "word": "are", + "start": 1813.56, + "end": 1813.98 + }, + { + "word": "atrocious", + "start": 1813.98, + "end": 1814.58 + }, + { + "word": "sometimes.", + "start": 1814.58, + "end": 1815.58 + } + ] + }, + { + "start": 1815.7, + "end": 1821.32, + "text": "They're working on it. But macros can make that a lot worse. But you can also do really magic", + "words": [ + { + "word": "They're", + "start": 1815.7, + "end": 1816.16 + }, + { + "word": "working", + "start": 1816.16, + "end": 1816.38 + }, + { + "word": "on", + "start": 1816.38, + "end": 1816.56 + }, + { + "word": "it.", + "start": 1816.56, + "end": 1816.78 + }, + { + "word": "But", + "start": 1817.42, + "end": 1817.82 + }, + { + "word": "macros", + "start": 1817.82, + "end": 1818.18 + }, + { + "word": "can", + "start": 1818.18, + "end": 1818.44 + }, + { + "word": "make", + "start": 1818.44, + "end": 1818.6 + }, + { + "word": "that", + "start": 1818.6, + "end": 1818.88 + }, + { + "word": "a", + "start": 1818.88, + "end": 1818.98 + }, + { + "word": "lot", + "start": 1818.98, + "end": 1819.08 + }, + { + "word": "worse.", + "start": 1819.08, + "end": 1819.58 + }, + { + "word": "But", + "start": 1820.12, + "end": 1820.34 + }, + { + "word": "you", + "start": 1820.34, + "end": 1820.5 + }, + { + "word": "can", + "start": 1820.5, + "end": 1820.62 + }, + { + "word": "also", + "start": 1820.62, + "end": 1820.78 + }, + { + "word": "do", + "start": 1820.78, + "end": 1820.94 + }, + { + "word": "really", + "start": 1820.94, + "end": 1821.12 + }, + { + "word": "magic", + "start": 1821.12, + "end": 1821.32 + } + ] + }, + { + "start": 1821.32, + "end": 1825.76, + "text": "things and it prevents a lot of boilerplate. So, definite tradeoff, but worth exploring.", + "words": [ + { + "word": "things", + "start": 1821.32, + "end": 1821.72 + }, + { + "word": "and", + "start": 1821.72, + "end": 1821.96 + }, + { + "word": "it", + "start": 1821.96, + "end": 1822.18 + }, + { + "word": "prevents", + "start": 1822.18, + "end": 1822.46 + }, + { + "word": "a", + "start": 1822.46, + "end": 1822.54 + }, + { + "word": "lot", + "start": 1822.54, + "end": 1822.74 + }, + { + "word": "of", + "start": 1822.74, + "end": 1822.86 + }, + { + "word": "boilerplate.", + "start": 1822.86, + "end": 1823.24 + }, + { + "word": "So,", + "start": 1823.62, + "end": 1823.94 + }, + { + "word": "definite", + "start": 1823.94, + "end": 1824.14 + }, + { + "word": "tradeoff,", + "start": 1824.14, + "end": 1824.58 + }, + { + "word": "but", + "start": 1824.7, + "end": 1824.94 + }, + { + "word": "worth", + "start": 1824.94, + "end": 1825.32 + }, + { + "word": "exploring.", + "start": 1825.32, + "end": 1825.76 + } + ] + }, + { + "start": 1827.74, + "end": 1831.68, + "text": "And lastly, I guess if you want to use LLMs, you can always just generate your generators.", + "words": [ + { + "word": "And", + "start": 1827.74, + "end": 1828.2 + }, + { + "word": "lastly,", + "start": 1828.2, + "end": 1828.54 + }, + { + "word": "I", + "start": 1828.72, + "end": 1828.72 + }, + { + "word": "guess", + "start": 1828.72, + "end": 1829.02 + }, + { + "word": "if", + "start": 1829.02, + "end": 1829.16 + }, + { + "word": "you", + "start": 1829.16, + "end": 1829.3 + }, + { + "word": "want", + "start": 1829.3, + "end": 1829.4 + }, + { + "word": "to", + "start": 1829.4, + "end": 1829.54 + }, + { + "word": "use", + "start": 1829.54, + "end": 1829.72 + }, + { + "word": "LLMs,", + "start": 1829.72, + "end": 1830.06 + }, + { + "word": "you", + "start": 1830.14, + "end": 1830.16 + }, + { + "word": "can", + "start": 1830.16, + "end": 1830.34 + }, + { + "word": "always", + "start": 1830.34, + "end": 1830.58 + }, + { + "word": "just", + "start": 1830.58, + "end": 1830.86 + }, + { + "word": "generate", + "start": 1830.86, + "end": 1831.08 + }, + { + "word": "your", + "start": 1831.08, + "end": 1831.3 + }, + { + "word": "generators.", + "start": 1831.3, + "end": 1831.68 + } + ] + }, + { + "start": 1832.36, + "end": 1836.6, + "text": "Do the meta thing and like metacode without metacoding? I don't know.", + "words": [ + { + "word": "Do", + "start": 1832.36, + "end": 1832.82 + }, + { + "word": "the", + "start": 1832.82, + "end": 1833.04 + }, + { + "word": "meta", + "start": 1833.04, + "end": 1833.2 + }, + { + "word": "thing", + "start": 1833.2, + "end": 1833.68 + }, + { + "word": "and", + "start": 1833.68, + "end": 1834.4 + }, + { + "word": "like", + "start": 1834.4, + "end": 1834.68 + }, + { + "word": "metacode", + "start": 1834.68, + "end": 1835.0 + }, + { + "word": "without", + "start": 1835.0, + "end": 1835.3 + }, + { + "word": "metacoding?", + "start": 1835.3, + "end": 1835.86 + }, + { + "word": "I", + "start": 1836.02, + "end": 1836.08 + }, + { + "word": "don't", + "start": 1836.08, + "end": 1836.22 + }, + { + "word": "know.", + "start": 1836.22, + "end": 1836.6 + } + ] + }, + { + "start": 1838.02, + "end": 1844.28, + "text": "So, I think that's mostly all I have. I have a bunch of links here for you if you're interested.", + "words": [ + { + "word": "So,", + "start": 1838.02, + "end": 1838.46 + }, + { + "word": "I", + "start": 1839.62, + "end": 1839.7 + }, + { + "word": "think", + "start": 1839.7, + "end": 1839.84 + }, + { + "word": "that's", + "start": 1839.84, + "end": 1840.14 + }, + { + "word": "mostly", + "start": 1840.14, + "end": 1840.46 + }, + { + "word": "all", + "start": 1840.46, + "end": 1840.86 + }, + { + "word": "I", + "start": 1840.86, + "end": 1841.16 + }, + { + "word": "have.", + "start": 1841.16, + "end": 1841.46 + }, + { + "word": "I", + "start": 1841.6, + "end": 1841.66 + }, + { + "word": "have", + "start": 1841.66, + "end": 1842.0 + }, + { + "word": "a", + "start": 1842.0, + "end": 1842.78 + }, + { + "word": "bunch", + "start": 1842.78, + "end": 1842.92 + }, + { + "word": "of", + "start": 1842.92, + "end": 1843.04 + }, + { + "word": "links", + "start": 1843.04, + "end": 1843.14 + }, + { + "word": "here", + "start": 1843.14, + "end": 1843.38 + }, + { + "word": "for", + "start": 1843.38, + "end": 1843.58 + }, + { + "word": "you", + "start": 1843.58, + "end": 1843.68 + }, + { + "word": "if", + "start": 1843.68, + "end": 1843.7 + }, + { + "word": "you're", + "start": 1843.7, + "end": 1843.84 + }, + { + "word": "interested.", + "start": 1843.84, + "end": 1844.28 + } + ] + }, + { + "start": 1844.44, + "end": 1848.78, + "text": "So, my personal site's on the top. I am looking for a job. So, if you want to hire someone, hire me.", + "words": [ + { + "word": "So,", + "start": 1844.44, + "end": 1844.64 + }, + { + "word": "my", + "start": 1844.64, + "end": 1844.76 + }, + { + "word": "personal", + "start": 1844.76, + "end": 1845.02 + }, + { + "word": "site's", + "start": 1845.02, + "end": 1845.3 + }, + { + "word": "on", + "start": 1845.3, + "end": 1845.38 + }, + { + "word": "the", + "start": 1845.38, + "end": 1845.52 + }, + { + "word": "top.", + "start": 1845.52, + "end": 1845.84 + }, + { + "word": "I", + "start": 1846.24, + "end": 1846.6 + }, + { + "word": "am", + "start": 1846.6, + "end": 1846.76 + }, + { + "word": "looking", + "start": 1846.76, + "end": 1846.9 + }, + { + "word": "for", + "start": 1846.9, + "end": 1847.1 + }, + { + "word": "a", + "start": 1847.1, + "end": 1847.18 + }, + { + "word": "job.", + "start": 1847.18, + "end": 1847.36 + }, + { + "word": "So,", + "start": 1847.4, + "end": 1847.54 + }, + { + "word": "if", + "start": 1847.54, + "end": 1847.6 + }, + { + "word": "you", + "start": 1847.6, + "end": 1847.7 + }, + { + "word": "want", + "start": 1847.7, + "end": 1847.78 + }, + { + "word": "to", + "start": 1847.78, + "end": 1847.88 + }, + { + "word": "hire", + "start": 1847.88, + "end": 1847.94 + }, + { + "word": "someone,", + "start": 1847.94, + "end": 1848.26 + }, + { + "word": "hire", + "start": 1848.34, + "end": 1848.42 + }, + { + "word": "me.", + "start": 1848.42, + "end": 1848.78 + } + ] + }, + { + "start": 1849.66, + "end": 1858.24, + "text": "I do run this meetup called Side Project Saturday. I know. I do run this meetup called Side Project", + "words": [ + { + "word": "I", + "start": 1849.66, + "end": 1850.04 + }, + { + "word": "do", + "start": 1850.04, + "end": 1850.28 + }, + { + "word": "run", + "start": 1850.28, + "end": 1850.56 + }, + { + "word": "this", + "start": 1850.56, + "end": 1851.08 + }, + { + "word": "meetup", + "start": 1851.08, + "end": 1851.3 + }, + { + "word": "called", + "start": 1851.3, + "end": 1851.52 + }, + { + "word": "Side", + "start": 1851.52, + "end": 1851.72 + }, + { + "word": "Project", + "start": 1851.72, + "end": 1851.98 + }, + { + "word": "Saturday.", + "start": 1851.98, + "end": 1852.42 + }, + { + "word": "I", + "start": 1854.5, + "end": 1854.94 + }, + { + "word": "know.", + "start": 1854.94, + "end": 1855.16 + }, + { + "word": "I", + "start": 1856.58, + "end": 1857.02 + }, + { + "word": "do", + "start": 1857.02, + "end": 1857.18 + }, + { + "word": "run", + "start": 1857.18, + "end": 1857.3 + }, + { + "word": "this", + "start": 1857.3, + "end": 1857.5 + }, + { + "word": "meetup", + "start": 1857.5, + "end": 1857.72 + }, + { + "word": "called", + "start": 1857.72, + "end": 1857.88 + }, + { + "word": "Side", + "start": 1857.88, + "end": 1858.08 + }, + { + "word": "Project", + "start": 1858.08, + "end": 1858.24 + } + ] + }, + { + "start": 1858.24, + "end": 1866.58, + "text": "Saturday. It's a Saturday morning meetup in downtown Brooklyn from 9 a.m. to noon. If you", + "words": [ + { + "word": "Saturday.", + "start": 1858.24, + "end": 1858.7 + }, + { + "word": "It's", + "start": 1858.92, + "end": 1859.3 + }, + { + "word": "a", + "start": 1859.3, + "end": 1859.4 + }, + { + "word": "Saturday", + "start": 1859.4, + "end": 1859.56 + }, + { + "word": "morning", + "start": 1859.56, + "end": 1859.86 + }, + { + "word": "meetup", + "start": 1859.86, + "end": 1860.12 + }, + { + "word": "in", + "start": 1860.12, + "end": 1860.26 + }, + { + "word": "downtown", + "start": 1860.26, + "end": 1860.54 + }, + { + "word": "Brooklyn", + "start": 1860.54, + "end": 1860.94 + }, + { + "word": "from", + "start": 1860.94, + "end": 1861.48 + }, + { + "word": "9", + "start": 1861.48, + "end": 1861.72 + }, + { + "word": "a", + "start": 1861.72, + "end": 1861.76 + }, + { + "word": ".m.", + "start": 1861.76, + "end": 1861.84 + }, + { + "word": "to", + "start": 1861.84, + "end": 1862.04 + }, + { + "word": "noon.", + "start": 1862.04, + "end": 1862.44 + }, + { + "word": "If", + "start": 1862.68, + "end": 1862.8 + }, + { + "word": "you", + "start": 1862.8, + "end": 1866.58 + } + ] + }, + { + "start": 1866.58, + "end": 1871.96, + "text": "want to check that out, I have a podcast called DevTools FM. Reekers Center. People banging each", + "words": [ + { + "word": "want", + "start": 1866.58, + "end": 1866.74 + }, + { + "word": "to", + "start": 1866.74, + "end": 1866.74 + }, + { + "word": "check", + "start": 1866.74, + "end": 1866.74 + }, + { + "word": "that", + "start": 1866.74, + "end": 1866.74 + }, + { + "word": "out,", + "start": 1866.74, + "end": 1866.74 + }, + { + "word": "I", + "start": 1866.74, + "end": 1866.74 + }, + { + "word": "have", + "start": 1866.74, + "end": 1867.08 + }, + { + "word": "a", + "start": 1867.08, + "end": 1867.16 + }, + { + "word": "podcast", + "start": 1867.16, + "end": 1867.52 + }, + { + "word": "called", + "start": 1867.52, + "end": 1867.76 + }, + { + "word": "DevTools", + "start": 1867.76, + "end": 1868.08 + }, + { + "word": "FM.", + "start": 1868.08, + "end": 1868.44 + }, + { + "word": "Reekers", + "start": 1869.62, + "end": 1869.98 + }, + { + "word": "Center.", + "start": 1869.98, + "end": 1870.42 + }, + { + "word": "People", + "start": 1870.86, + "end": 1870.94 + }, + { + "word": "banging", + "start": 1870.94, + "end": 1871.76 + }, + { + "word": "each", + "start": 1871.76, + "end": 1871.96 + } + ] + }, + { + "start": 1871.96, + "end": 1878.68, + "text": "other back there. That's definitely one to check out. And then again, Oxides repo and my WebView", + "words": [ + { + "word": "other", + "start": 1871.96, + "end": 1872.1 + }, + { + "word": "back", + "start": 1872.1, + "end": 1872.24 + }, + { + "word": "there.", + "start": 1872.24, + "end": 1872.48 + }, + { + "word": "That's", + "start": 1872.86, + "end": 1873.3 + }, + { + "word": "definitely", + "start": 1873.3, + "end": 1873.52 + }, + { + "word": "one", + "start": 1873.52, + "end": 1873.64 + }, + { + "word": "to", + "start": 1873.64, + "end": 1873.74 + }, + { + "word": "check", + "start": 1873.74, + "end": 1873.94 + }, + { + "word": "out.", + "start": 1873.94, + "end": 1874.24 + }, + { + "word": "And", + "start": 1874.6, + "end": 1874.6 + }, + { + "word": "then", + "start": 1874.6, + "end": 1874.76 + }, + { + "word": "again,", + "start": 1874.76, + "end": 1875.52 + }, + { + "word": "Oxides", + "start": 1875.62, + "end": 1876.42 + }, + { + "word": "repo", + "start": 1876.42, + "end": 1877.04 + }, + { + "word": "and", + "start": 1877.04, + "end": 1877.86 + }, + { + "word": "my", + "start": 1877.86, + "end": 1878.42 + }, + { + "word": "WebView", + "start": 1878.42, + "end": 1878.68 + } + ] + }, + { + "start": 1878.68, + "end": 1882.78, + "text": "project is open source. If you think it's interesting and want to contribute to it, I would like that.", + "words": [ + { + "word": "project", + "start": 1878.68, + "end": 1879.06 + }, + { + "word": "is", + "start": 1879.06, + "end": 1879.26 + }, + { + "word": "open", + "start": 1879.26, + "end": 1879.42 + }, + { + "word": "source.", + "start": 1879.42, + "end": 1879.68 + }, + { + "word": "If", + "start": 1879.96, + "end": 1879.96 + }, + { + "word": "you", + "start": 1879.96, + "end": 1880.22 + }, + { + "word": "think", + "start": 1880.22, + "end": 1880.32 + }, + { + "word": "it's", + "start": 1880.32, + "end": 1880.5 + }, + { + "word": "interesting", + "start": 1880.5, + "end": 1880.82 + }, + { + "word": "and", + "start": 1880.82, + "end": 1880.88 + }, + { + "word": "want", + "start": 1880.88, + "end": 1881.04 + }, + { + "word": "to", + "start": 1881.04, + "end": 1881.12 + }, + { + "word": "contribute", + "start": 1881.12, + "end": 1881.38 + }, + { + "word": "to", + "start": 1881.38, + "end": 1881.52 + }, + { + "word": "it,", + "start": 1881.52, + "end": 1881.7 + }, + { + "word": "I", + "start": 1881.96, + "end": 1882.06 + }, + { + "word": "would", + "start": 1882.06, + "end": 1882.3 + }, + { + "word": "like", + "start": 1882.3, + "end": 1882.46 + }, + { + "word": "that.", + "start": 1882.46, + "end": 1882.78 + } + ] + }, + { + "start": 1884.32, + "end": 1888.3, + "text": "My socials is there and that's all I got. Thanks, everybody.", + "words": [ + { + "word": "My", + "start": 1884.32, + "end": 1884.84 + }, + { + "word": "socials", + "start": 1884.84, + "end": 1885.36 + }, + { + "word": "is", + "start": 1885.36, + "end": 1885.5 + }, + { + "word": "there", + "start": 1885.5, + "end": 1885.72 + }, + { + "word": "and", + "start": 1885.72, + "end": 1886.0 + }, + { + "word": "that's", + "start": 1886.0, + "end": 1886.76 + }, + { + "word": "all", + "start": 1886.76, + "end": 1887.02 + }, + { + "word": "I", + "start": 1887.02, + "end": 1887.2 + }, + { + "word": "got.", + "start": 1887.2, + "end": 1887.44 + }, + { + "word": "Thanks,", + "start": 1887.72, + "end": 1887.92 + }, + { + "word": "everybody.", + "start": 1887.98, + "end": 1888.3 + } + ] + }, + { + "start": 1892.78, + "end": 1897.1, + "text": "Any questions? Yeah, sure. Happy to take questions. Yeah, any questions?", + "words": [ + { + "word": "Any", + "start": 1892.78, + "end": 1893.28 + }, + { + "word": "questions?", + "start": 1893.28, + "end": 1893.78 + }, + { + "word": "Yeah,", + "start": 1893.78, + "end": 1893.78 + }, + { + "word": "sure.", + "start": 1894.28, + "end": 1894.32 + }, + { + "word": "Happy", + "start": 1895.0, + "end": 1895.28 + }, + { + "word": "to", + "start": 1895.28, + "end": 1895.4 + }, + { + "word": "take", + "start": 1895.4, + "end": 1895.42 + }, + { + "word": "questions.", + "start": 1895.42, + "end": 1895.78 + }, + { + "word": "Yeah,", + "start": 1896.18, + "end": 1896.26 + }, + { + "word": "any", + "start": 1896.26, + "end": 1896.56 + }, + { + "word": "questions?", + "start": 1896.56, + "end": 1897.1 + } + ] + }, + { + "start": 1900.4, + "end": 1906.24, + "text": "So, this seems a little more bespoke than using something like GRPC or Protobufs or Captain Proto", + "words": [ + { + "word": "So,", + "start": 1900.4, + "end": 1900.9 + }, + { + "word": "this", + "start": 1901.0, + "end": 1901.16 + }, + { + "word": "seems", + "start": 1901.16, + "end": 1901.4 + }, + { + "word": "a", + "start": 1901.4, + "end": 1901.56 + }, + { + "word": "little", + "start": 1901.56, + "end": 1901.66 + }, + { + "word": "more", + "start": 1901.66, + "end": 1901.9 + }, + { + "word": "bespoke", + "start": 1901.9, + "end": 1902.24 + }, + { + "word": "than", + "start": 1902.24, + "end": 1902.44 + }, + { + "word": "using", + "start": 1902.44, + "end": 1902.68 + }, + { + "word": "something", + "start": 1902.68, + "end": 1902.96 + }, + { + "word": "like", + "start": 1902.96, + "end": 1903.22 + }, + { + "word": "GRPC", + "start": 1903.22, + "end": 1903.92 + }, + { + "word": "or", + "start": 1903.92, + "end": 1904.32 + }, + { + "word": "Protobufs", + "start": 1904.32, + "end": 1904.98 + }, + { + "word": "or", + "start": 1904.98, + "end": 1905.42 + }, + { + "word": "Captain", + "start": 1905.42, + "end": 1905.76 + }, + { + "word": "Proto", + "start": 1905.76, + "end": 1906.24 + } + ] + }, + { + "start": 1906.24, + "end": 1911.8, + "text": "or something like that. Is there a reason why you chose not to use those? Yeah, I think it really", + "words": [ + { + "word": "or", + "start": 1906.24, + "end": 1906.48 + }, + { + "word": "something", + "start": 1906.48, + "end": 1906.74 + }, + { + "word": "like", + "start": 1906.74, + "end": 1907.08 + }, + { + "word": "that.", + "start": 1907.08, + "end": 1907.24 + }, + { + "word": "Is", + "start": 1907.26, + "end": 1907.42 + }, + { + "word": "there", + "start": 1907.42, + "end": 1907.58 + }, + { + "word": "a", + "start": 1907.58, + "end": 1907.64 + }, + { + "word": "reason", + "start": 1907.64, + "end": 1907.82 + }, + { + "word": "why", + "start": 1907.82, + "end": 1907.96 + }, + { + "word": "you", + "start": 1907.96, + "end": 1908.14 + }, + { + "word": "chose", + "start": 1908.14, + "end": 1908.48 + }, + { + "word": "not", + "start": 1908.48, + "end": 1908.94 + }, + { + "word": "to", + "start": 1908.94, + "end": 1909.16 + }, + { + "word": "use", + "start": 1909.16, + "end": 1909.3 + }, + { + "word": "those?", + "start": 1909.3, + "end": 1909.82 + }, + { + "word": "Yeah,", + "start": 1910.42, + "end": 1910.84 + }, + { + "word": "I", + "start": 1910.84, + "end": 1911.0 + }, + { + "word": "think", + "start": 1911.0, + "end": 1911.24 + }, + { + "word": "it", + "start": 1911.24, + "end": 1911.54 + }, + { + "word": "really", + "start": 1911.54, + "end": 1911.8 + } + ] + }, + { + "start": 1911.8, + "end": 1917.8, + "text": "depends on like what your use case is. So, the WebView project, I wanted to just keep as simple", + "words": [ + { + "word": "depends", + "start": 1911.8, + "end": 1912.42 + }, + { + "word": "on", + "start": 1912.42, + "end": 1912.94 + }, + { + "word": "like", + "start": 1912.94, + "end": 1913.1 + }, + { + "word": "what", + "start": 1913.1, + "end": 1913.22 + }, + { + "word": "your", + "start": 1913.22, + "end": 1913.4 + }, + { + "word": "use", + "start": 1913.4, + "end": 1913.6 + }, + { + "word": "case", + "start": 1913.6, + "end": 1913.78 + }, + { + "word": "is.", + "start": 1913.78, + "end": 1914.1 + }, + { + "word": "So,", + "start": 1914.26, + "end": 1914.76 + }, + { + "word": "the", + "start": 1915.4, + "end": 1915.6 + }, + { + "word": "WebView", + "start": 1915.6, + "end": 1915.88 + }, + { + "word": "project,", + "start": 1915.88, + "end": 1916.38 + }, + { + "word": "I", + "start": 1916.42, + "end": 1916.58 + }, + { + "word": "wanted", + "start": 1916.58, + "end": 1916.7 + }, + { + "word": "to", + "start": 1916.7, + "end": 1916.9 + }, + { + "word": "just", + "start": 1916.9, + "end": 1917.06 + }, + { + "word": "keep", + "start": 1917.06, + "end": 1917.2 + }, + { + "word": "as", + "start": 1917.2, + "end": 1917.5 + }, + { + "word": "simple", + "start": 1917.5, + "end": 1917.8 + } + ] + }, + { + "start": 1917.8, + "end": 1923.62, + "text": "as possible, as few dependencies as possible. And the thing like JSON is not a good communication", + "words": [ + { + "word": "as", + "start": 1917.8, + "end": 1918.0 + }, + { + "word": "possible,", + "start": 1918.0, + "end": 1918.4 + }, + { + "word": "as", + "start": 1918.54, + "end": 1918.74 + }, + { + "word": "few", + "start": 1918.74, + "end": 1919.02 + }, + { + "word": "dependencies", + "start": 1919.02, + "end": 1919.5 + }, + { + "word": "as", + "start": 1919.5, + "end": 1919.76 + }, + { + "word": "possible.", + "start": 1919.76, + "end": 1920.16 + }, + { + "word": "And", + "start": 1920.82, + "end": 1920.82 + }, + { + "word": "the", + "start": 1920.82, + "end": 1920.94 + }, + { + "word": "thing", + "start": 1920.94, + "end": 1921.24 + }, + { + "word": "like", + "start": 1921.24, + "end": 1921.46 + }, + { + "word": "JSON", + "start": 1921.46, + "end": 1921.7 + }, + { + "word": "is", + "start": 1921.7, + "end": 1921.94 + }, + { + "word": "not", + "start": 1921.94, + "end": 1922.32 + }, + { + "word": "a", + "start": 1922.32, + "end": 1922.62 + }, + { + "word": "good", + "start": 1922.62, + "end": 1923.1 + }, + { + "word": "communication", + "start": 1923.1, + "end": 1923.62 + } + ] + }, + { + "start": 1923.62, + "end": 1928.66, + "text": "protocol generally, but like it is simple and everything talks it. And I don't have to install", + "words": [ + { + "word": "protocol", + "start": 1923.62, + "end": 1924.14 + }, + { + "word": "generally,", + "start": 1924.14, + "end": 1924.64 + }, + { + "word": "but", + "start": 1924.82, + "end": 1925.06 + }, + { + "word": "like", + "start": 1925.06, + "end": 1925.34 + }, + { + "word": "it", + "start": 1925.34, + "end": 1925.44 + }, + { + "word": "is", + "start": 1925.44, + "end": 1925.68 + }, + { + "word": "simple", + "start": 1925.68, + "end": 1926.02 + }, + { + "word": "and", + "start": 1926.02, + "end": 1926.24 + }, + { + "word": "everything", + "start": 1926.24, + "end": 1926.54 + }, + { + "word": "talks", + "start": 1926.54, + "end": 1926.82 + }, + { + "word": "it.", + "start": 1926.82, + "end": 1927.08 + }, + { + "word": "And", + "start": 1927.3, + "end": 1927.5 + }, + { + "word": "I", + "start": 1927.5, + "end": 1927.62 + }, + { + "word": "don't", + "start": 1927.62, + "end": 1927.76 + }, + { + "word": "have", + "start": 1927.76, + "end": 1928.0 + }, + { + "word": "to", + "start": 1928.0, + "end": 1928.22 + }, + { + "word": "install", + "start": 1928.22, + "end": 1928.66 + } + ] + }, + { + "start": 1928.66, + "end": 1932.9, + "text": "or make sure that there's a custom binary translation layer for whatever language that I'm", + "words": [ + { + "word": "or", + "start": 1928.66, + "end": 1928.98 + }, + { + "word": "make", + "start": 1928.98, + "end": 1929.14 + }, + { + "word": "sure", + "start": 1929.14, + "end": 1929.4 + }, + { + "word": "that", + "start": 1929.4, + "end": 1929.52 + }, + { + "word": "there's", + "start": 1929.52, + "end": 1929.74 + }, + { + "word": "a", + "start": 1929.74, + "end": 1929.92 + }, + { + "word": "custom", + "start": 1929.92, + "end": 1930.34 + }, + { + "word": "binary", + "start": 1930.34, + "end": 1930.92 + }, + { + "word": "translation", + "start": 1930.92, + "end": 1931.44 + }, + { + "word": "layer", + "start": 1931.44, + "end": 1931.74 + }, + { + "word": "for", + "start": 1931.74, + "end": 1932.0 + }, + { + "word": "whatever", + "start": 1932.0, + "end": 1932.3 + }, + { + "word": "language", + "start": 1932.3, + "end": 1932.62 + }, + { + "word": "that", + "start": 1932.62, + "end": 1932.8 + }, + { + "word": "I'm", + "start": 1932.8, + "end": 1932.9 + } + ] + }, + { + "start": 1932.9, + "end": 1939.32, + "text": "using to be able to support it. And for my project, that was what's important. For Oxide, they wanted", + "words": [ + { + "word": "using", + "start": 1932.9, + "end": 1933.14 + }, + { + "word": "to", + "start": 1933.14, + "end": 1933.28 + }, + { + "word": "be", + "start": 1933.28, + "end": 1933.38 + }, + { + "word": "able", + "start": 1933.38, + "end": 1933.48 + }, + { + "word": "to", + "start": 1933.48, + "end": 1933.66 + }, + { + "word": "support", + "start": 1933.66, + "end": 1933.82 + }, + { + "word": "it.", + "start": 1933.82, + "end": 1934.1 + }, + { + "word": "And", + "start": 1934.46, + "end": 1934.64 + }, + { + "word": "for", + "start": 1934.64, + "end": 1934.78 + }, + { + "word": "my", + "start": 1934.78, + "end": 1934.98 + }, + { + "word": "project,", + "start": 1934.98, + "end": 1935.28 + }, + { + "word": "that", + "start": 1935.32, + "end": 1935.42 + }, + { + "word": "was", + "start": 1935.42, + "end": 1935.58 + }, + { + "word": "what's", + "start": 1935.58, + "end": 1935.86 + }, + { + "word": "important.", + "start": 1935.86, + "end": 1936.22 + }, + { + "word": "For", + "start": 1937.14, + "end": 1937.66 + }, + { + "word": "Oxide,", + "start": 1937.66, + "end": 1938.48 + }, + { + "word": "they", + "start": 1938.86, + "end": 1939.14 + }, + { + "word": "wanted", + "start": 1939.14, + "end": 1939.32 + } + ] + }, + { + "start": 1939.32, + "end": 1946.78, + "text": "to make restful APIs and the standard is open API for like expressing those in a schema. So,", + "words": [ + { + "word": "to", + "start": 1939.32, + "end": 1939.54 + }, + { + "word": "make", + "start": 1939.54, + "end": 1940.58 + }, + { + "word": "restful", + "start": 1940.58, + "end": 1941.04 + }, + { + "word": "APIs", + "start": 1941.04, + "end": 1941.5 + }, + { + "word": "and", + "start": 1941.5, + "end": 1942.16 + }, + { + "word": "the", + "start": 1942.16, + "end": 1942.42 + }, + { + "word": "standard", + "start": 1942.42, + "end": 1942.78 + }, + { + "word": "is", + "start": 1942.78, + "end": 1943.12 + }, + { + "word": "open", + "start": 1943.12, + "end": 1943.34 + }, + { + "word": "API", + "start": 1943.34, + "end": 1943.82 + }, + { + "word": "for", + "start": 1943.82, + "end": 1944.56 + }, + { + "word": "like", + "start": 1944.56, + "end": 1945.16 + }, + { + "word": "expressing", + "start": 1945.16, + "end": 1945.48 + }, + { + "word": "those", + "start": 1945.48, + "end": 1945.98 + }, + { + "word": "in", + "start": 1945.98, + "end": 1946.16 + }, + { + "word": "a", + "start": 1946.16, + "end": 1946.28 + }, + { + "word": "schema.", + "start": 1946.28, + "end": 1946.48 + }, + { + "word": "So,", + "start": 1946.66, + "end": 1946.78 + } + ] + }, + { + "start": 1946.78, + "end": 1953.72, + "text": "that was the big thing. They just like wanted to target the language or the, yeah, what every other", + "words": [ + { + "word": "that", + "start": 1946.78, + "end": 1946.98 + }, + { + "word": "was", + "start": 1946.98, + "end": 1947.06 + }, + { + "word": "the", + "start": 1947.06, + "end": 1947.3 + }, + { + "word": "big", + "start": 1947.3, + "end": 1947.54 + }, + { + "word": "thing.", + "start": 1947.54, + "end": 1947.8 + }, + { + "word": "They", + "start": 1947.82, + "end": 1947.94 + }, + { + "word": "just", + "start": 1947.94, + "end": 1948.1 + }, + { + "word": "like", + "start": 1948.1, + "end": 1948.44 + }, + { + "word": "wanted", + "start": 1948.44, + "end": 1948.68 + }, + { + "word": "to", + "start": 1948.68, + "end": 1949.6 + }, + { + "word": "target", + "start": 1949.6, + "end": 1949.94 + }, + { + "word": "the", + "start": 1949.94, + "end": 1950.4 + }, + { + "word": "language", + "start": 1950.4, + "end": 1950.9 + }, + { + "word": "or", + "start": 1950.9, + "end": 1951.26 + }, + { + "word": "the,", + "start": 1951.26, + "end": 1951.64 + }, + { + "word": "yeah,", + "start": 1951.82, + "end": 1952.68 + }, + { + "word": "what", + "start": 1952.7, + "end": 1952.96 + }, + { + "word": "every", + "start": 1952.96, + "end": 1953.34 + }, + { + "word": "other", + "start": 1953.34, + "end": 1953.72 + } + ] + }, + { + "start": 1953.72, + "end": 1957.78, + "text": "major enterprise company would understand. And I mean, I think in a large part that's worked out", + "words": [ + { + "word": "major", + "start": 1953.72, + "end": 1954.02 + }, + { + "word": "enterprise", + "start": 1954.02, + "end": 1954.36 + }, + { + "word": "company", + "start": 1954.36, + "end": 1954.66 + }, + { + "word": "would", + "start": 1954.66, + "end": 1954.82 + }, + { + "word": "understand.", + "start": 1954.82, + "end": 1955.5 + }, + { + "word": "And", + "start": 1955.62, + "end": 1955.92 + }, + { + "word": "I", + "start": 1955.92, + "end": 1956.14 + }, + { + "word": "mean,", + "start": 1956.14, + "end": 1956.26 + }, + { + "word": "I", + "start": 1956.26, + "end": 1956.38 + }, + { + "word": "think", + "start": 1956.38, + "end": 1956.66 + }, + { + "word": "in", + "start": 1956.66, + "end": 1956.92 + }, + { + "word": "a", + "start": 1956.92, + "end": 1956.96 + }, + { + "word": "large", + "start": 1956.96, + "end": 1957.12 + }, + { + "word": "part", + "start": 1957.12, + "end": 1957.26 + }, + { + "word": "that's", + "start": 1957.26, + "end": 1957.48 + }, + { + "word": "worked", + "start": 1957.48, + "end": 1957.6 + }, + { + "word": "out", + "start": 1957.6, + "end": 1957.78 + } + ] + }, + { + "start": 1957.78, + "end": 1963.9, + "text": "for them. One thing that I will say is like internally inside Oxide, they're like service", + "words": [ + { + "word": "for", + "start": 1957.78, + "end": 1957.9 + }, + { + "word": "them.", + "start": 1957.9, + "end": 1958.3 + }, + { + "word": "One", + "start": 1959.22, + "end": 1959.7 + }, + { + "word": "thing", + "start": 1959.7, + "end": 1959.88 + }, + { + "word": "that", + "start": 1959.88, + "end": 1960.0 + }, + { + "word": "I", + "start": 1960.0, + "end": 1960.14 + }, + { + "word": "will", + "start": 1960.14, + "end": 1960.26 + }, + { + "word": "say", + "start": 1960.26, + "end": 1960.56 + }, + { + "word": "is", + "start": 1960.56, + "end": 1960.7 + }, + { + "word": "like", + "start": 1960.7, + "end": 1961.06 + }, + { + "word": "internally", + "start": 1961.06, + "end": 1961.58 + }, + { + "word": "inside", + "start": 1961.58, + "end": 1962.54 + }, + { + "word": "Oxide,", + "start": 1962.54, + "end": 1963.12 + }, + { + "word": "they're", + "start": 1963.22, + "end": 1963.32 + }, + { + "word": "like", + "start": 1963.32, + "end": 1963.62 + }, + { + "word": "service", + "start": 1963.62, + "end": 1963.9 + } + ] + }, + { + "start": 1963.9, + "end": 1967.94, + "text": "to service communications using the same technology, which I'm like, that's like a really", + "words": [ + { + "word": "to", + "start": 1963.9, + "end": 1964.06 + }, + { + "word": "service", + "start": 1964.06, + "end": 1964.24 + }, + { + "word": "communications", + "start": 1964.24, + "end": 1964.82 + }, + { + "word": "using", + "start": 1964.82, + "end": 1965.1 + }, + { + "word": "the", + "start": 1965.1, + "end": 1965.32 + }, + { + "word": "same", + "start": 1965.32, + "end": 1965.46 + }, + { + "word": "technology,", + "start": 1965.46, + "end": 1966.0 + }, + { + "word": "which", + "start": 1966.04, + "end": 1966.2 + }, + { + "word": "I'm", + "start": 1966.2, + "end": 1966.56 + }, + { + "word": "like,", + "start": 1966.56, + "end": 1966.88 + }, + { + "word": "that's", + "start": 1967.4, + "end": 1967.54 + }, + { + "word": "like", + "start": 1967.54, + "end": 1967.68 + }, + { + "word": "a", + "start": 1967.68, + "end": 1967.78 + }, + { + "word": "really", + "start": 1967.78, + "end": 1967.94 + } + ] + }, + { + "start": 1967.94, + "end": 1973.1, + "text": "great case for using, you know, Protobufs or something, but it's working for them for now.", + "words": [ + { + "word": "great", + "start": 1967.94, + "end": 1968.28 + }, + { + "word": "case", + "start": 1968.28, + "end": 1968.64 + }, + { + "word": "for", + "start": 1968.64, + "end": 1969.02 + }, + { + "word": "using,", + "start": 1969.02, + "end": 1969.52 + }, + { + "word": "you", + "start": 1969.52, + "end": 1969.52 + }, + { + "word": "know,", + "start": 1969.52, + "end": 1970.18 + }, + { + "word": "Protobufs", + "start": 1970.28, + "end": 1970.58 + }, + { + "word": "or", + "start": 1970.58, + "end": 1970.68 + }, + { + "word": "something,", + "start": 1970.68, + "end": 1970.96 + }, + { + "word": "but", + "start": 1971.02, + "end": 1971.56 + }, + { + "word": "it's", + "start": 1971.56, + "end": 1972.3 + }, + { + "word": "working", + "start": 1972.3, + "end": 1972.48 + }, + { + "word": "for", + "start": 1972.48, + "end": 1972.62 + }, + { + "word": "them", + "start": 1972.62, + "end": 1972.76 + }, + { + "word": "for", + "start": 1972.76, + "end": 1972.92 + }, + { + "word": "now.", + "start": 1972.92, + "end": 1973.1 + } + ] + }, + { + "start": 1977.8, + "end": 1981.72, + "text": "So, you mentioned briefly earlier that there are a lot of projects or companies out there who are", + "words": [ + { + "word": "So,", + "start": 1977.8, + "end": 1978.2 + }, + { + "word": "you", + "start": 1978.26, + "end": 1978.46 + }, + { + "word": "mentioned", + "start": 1978.46, + "end": 1978.72 + }, + { + "word": "briefly", + "start": 1978.72, + "end": 1979.1 + }, + { + "word": "earlier", + "start": 1979.1, + "end": 1979.42 + }, + { + "word": "that", + "start": 1979.42, + "end": 1979.62 + }, + { + "word": "there", + "start": 1979.62, + "end": 1979.8 + }, + { + "word": "are", + "start": 1979.8, + "end": 1979.94 + }, + { + "word": "a", + "start": 1979.94, + "end": 1980.02 + }, + { + "word": "lot", + "start": 1980.02, + "end": 1980.02 + }, + { + "word": "of", + "start": 1980.02, + "end": 1980.2 + }, + { + "word": "projects", + "start": 1980.2, + "end": 1980.42 + }, + { + "word": "or", + "start": 1980.42, + "end": 1980.64 + }, + { + "word": "companies", + "start": 1980.64, + "end": 1980.94 + }, + { + "word": "out", + "start": 1980.94, + "end": 1981.14 + }, + { + "word": "there", + "start": 1981.14, + "end": 1981.26 + }, + { + "word": "who", + "start": 1981.26, + "end": 1981.42 + }, + { + "word": "are", + "start": 1981.42, + "end": 1981.72 + } + ] + }, + { + "start": 1981.72, + "end": 1988.62, + "text": "doing coaching for you. So, Stainless, OpenAPI Generator, Swagger. So, when someone who's picking", + "words": [ + { + "word": "doing", + "start": 1981.72, + "end": 1981.88 + }, + { + "word": "coaching", + "start": 1981.88, + "end": 1982.08 + }, + { + "word": "for", + "start": 1982.08, + "end": 1982.34 + }, + { + "word": "you.", + "start": 1982.34, + "end": 1982.48 + }, + { + "word": "So,", + "start": 1982.64, + "end": 1982.76 + }, + { + "word": "Stainless,", + "start": 1982.82, + "end": 1983.52 + }, + { + "word": "OpenAPI", + "start": 1984.54, + "end": 1985.02 + }, + { + "word": "Generator,", + "start": 1985.02, + "end": 1986.06 + }, + { + "word": "Swagger.", + "start": 1986.3, + "end": 1986.66 + }, + { + "word": "So,", + "start": 1987.34, + "end": 1987.48 + }, + { + "word": "when", + "start": 1987.62, + "end": 1987.7 + }, + { + "word": "someone", + "start": 1987.7, + "end": 1987.9 + }, + { + "word": "who's", + "start": 1987.9, + "end": 1988.32 + }, + { + "word": "picking", + "start": 1988.32, + "end": 1988.62 + } + ] + }, + { + "start": 1988.62, + "end": 1992.28, + "text": "tools for the job to do coaching for them, what are the few things you're looking at to say,", + "words": [ + { + "word": "tools", + "start": 1988.62, + "end": 1988.98 + }, + { + "word": "for", + "start": 1988.98, + "end": 1989.18 + }, + { + "word": "the", + "start": 1989.18, + "end": 1989.34 + }, + { + "word": "job", + "start": 1989.34, + "end": 1989.5 + }, + { + "word": "to", + "start": 1989.5, + "end": 1989.66 + }, + { + "word": "do", + "start": 1989.66, + "end": 1989.84 + }, + { + "word": "coaching", + "start": 1989.84, + "end": 1990.08 + }, + { + "word": "for", + "start": 1990.08, + "end": 1990.32 + }, + { + "word": "them,", + "start": 1990.32, + "end": 1990.56 + }, + { + "word": "what", + "start": 1990.8, + "end": 1990.9 + }, + { + "word": "are", + "start": 1990.9, + "end": 1991.0 + }, + { + "word": "the", + "start": 1991.0, + "end": 1991.1 + }, + { + "word": "few", + "start": 1991.1, + "end": 1991.24 + }, + { + "word": "things", + "start": 1991.24, + "end": 1991.46 + }, + { + "word": "you're", + "start": 1991.46, + "end": 1991.58 + }, + { + "word": "looking", + "start": 1991.58, + "end": 1991.82 + }, + { + "word": "at", + "start": 1991.82, + "end": 1992.0 + }, + { + "word": "to", + "start": 1992.0, + "end": 1992.16 + }, + { + "word": "say,", + "start": 1992.16, + "end": 1992.28 + } + ] + }, + { + "start": 1992.34, + "end": 1996.32, + "text": "okay, this might be better or this is what I really want the tool to have?", + "words": [ + { + "word": "okay,", + "start": 1992.34, + "end": 1992.48 + }, + { + "word": "this", + "start": 1992.5, + "end": 1992.72 + }, + { + "word": "might", + "start": 1992.72, + "end": 1992.86 + }, + { + "word": "be", + "start": 1992.86, + "end": 1993.04 + }, + { + "word": "better", + "start": 1993.04, + "end": 1993.32 + }, + { + "word": "or", + "start": 1993.32, + "end": 1993.74 + }, + { + "word": "this", + "start": 1993.74, + "end": 1994.3 + }, + { + "word": "is", + "start": 1994.3, + "end": 1994.54 + }, + { + "word": "what", + "start": 1994.54, + "end": 1994.68 + }, + { + "word": "I", + "start": 1994.68, + "end": 1994.8 + }, + { + "word": "really", + "start": 1994.8, + "end": 1994.98 + }, + { + "word": "want", + "start": 1994.98, + "end": 1995.24 + }, + { + "word": "the", + "start": 1995.24, + "end": 1995.68 + }, + { + "word": "tool", + "start": 1995.68, + "end": 1995.82 + }, + { + "word": "to", + "start": 1995.82, + "end": 1996.04 + }, + { + "word": "have?", + "start": 1996.04, + "end": 1996.32 + } + ] + }, + { + "start": 1998.14, + "end": 2002.4, + "text": "Yeah, it's a really good question. If you're just slapping together a prototype, just using", + "words": [ + { + "word": "Yeah,", + "start": 1998.14, + "end": 1998.5 + }, + { + "word": "it's", + "start": 1998.5, + "end": 1998.68 + }, + { + "word": "a", + "start": 1998.68, + "end": 1998.8 + }, + { + "word": "really", + "start": 1998.8, + "end": 1999.0 + }, + { + "word": "good", + "start": 1999.0, + "end": 1999.18 + }, + { + "word": "question.", + "start": 1999.18, + "end": 1999.82 + }, + { + "word": "If", + "start": 2000.02, + "end": 2000.18 + }, + { + "word": "you're", + "start": 2000.18, + "end": 2000.36 + }, + { + "word": "just", + "start": 2000.36, + "end": 2000.6 + }, + { + "word": "slapping", + "start": 2000.6, + "end": 2000.86 + }, + { + "word": "together", + "start": 2000.86, + "end": 2001.24 + }, + { + "word": "a", + "start": 2001.24, + "end": 2001.42 + }, + { + "word": "prototype,", + "start": 2001.42, + "end": 2001.74 + }, + { + "word": "just", + "start": 2002.12, + "end": 2002.22 + }, + { + "word": "using", + "start": 2002.22, + "end": 2002.4 + } + ] + }, + { + "start": 2002.4, + "end": 2006.76, + "text": "open source packages, fine. Things are going to be bad and things are going to be weird, but that's", + "words": [ + { + "word": "open", + "start": 2002.4, + "end": 2002.6 + }, + { + "word": "source", + "start": 2002.6, + "end": 2002.84 + }, + { + "word": "packages,", + "start": 2002.84, + "end": 2003.18 + }, + { + "word": "fine.", + "start": 2003.3, + "end": 2003.64 + }, + { + "word": "Things", + "start": 2003.72, + "end": 2003.94 + }, + { + "word": "are", + "start": 2003.94, + "end": 2004.1 + }, + { + "word": "going", + "start": 2004.1, + "end": 2004.16 + }, + { + "word": "to", + "start": 2004.16, + "end": 2004.26 + }, + { + "word": "be", + "start": 2004.26, + "end": 2004.76 + }, + { + "word": "bad", + "start": 2004.76, + "end": 2005.2 + }, + { + "word": "and", + "start": 2005.2, + "end": 2005.6 + }, + { + "word": "things", + "start": 2005.6, + "end": 2005.78 + }, + { + "word": "are", + "start": 2005.78, + "end": 2005.92 + }, + { + "word": "going", + "start": 2005.92, + "end": 2006.0 + }, + { + "word": "to", + "start": 2006.0, + "end": 2006.0 + }, + { + "word": "be", + "start": 2006.0, + "end": 2006.18 + }, + { + "word": "weird,", + "start": 2006.18, + "end": 2006.48 + }, + { + "word": "but", + "start": 2006.48, + "end": 2006.6 + }, + { + "word": "that's", + "start": 2006.6, + "end": 2006.76 + } + ] + }, + { + "start": 2006.76, + "end": 2010.7, + "text": "okay. You're just like trying to get somewhere. If you're doing anything serious and you're", + "words": [ + { + "word": "okay.", + "start": 2006.76, + "end": 2007.06 + }, + { + "word": "You're", + "start": 2007.06, + "end": 2007.34 + }, + { + "word": "just", + "start": 2007.34, + "end": 2007.5 + }, + { + "word": "like", + "start": 2007.5, + "end": 2007.94 + }, + { + "word": "trying", + "start": 2007.94, + "end": 2008.12 + }, + { + "word": "to", + "start": 2008.12, + "end": 2008.18 + }, + { + "word": "get", + "start": 2008.18, + "end": 2008.38 + }, + { + "word": "somewhere.", + "start": 2008.38, + "end": 2008.86 + }, + { + "word": "If", + "start": 2009.22, + "end": 2009.46 + }, + { + "word": "you're", + "start": 2009.46, + "end": 2009.64 + }, + { + "word": "doing", + "start": 2009.64, + "end": 2009.74 + }, + { + "word": "anything", + "start": 2009.74, + "end": 2010.08 + }, + { + "word": "serious", + "start": 2010.08, + "end": 2010.46 + }, + { + "word": "and", + "start": 2010.46, + "end": 2010.6 + }, + { + "word": "you're", + "start": 2010.6, + "end": 2010.7 + } + ] + }, + { + "start": 2010.7, + "end": 2015.64, + "text": "building a product, either pay someone who's like really, really good and can tailor the solution", + "words": [ + { + "word": "building", + "start": 2010.7, + "end": 2010.9 + }, + { + "word": "a", + "start": 2010.9, + "end": 2011.22 + }, + { + "word": "product,", + "start": 2011.22, + "end": 2011.62 + }, + { + "word": "either", + "start": 2011.96, + "end": 2012.24 + }, + { + "word": "pay", + "start": 2012.24, + "end": 2012.5 + }, + { + "word": "someone", + "start": 2012.5, + "end": 2012.9 + }, + { + "word": "who's", + "start": 2012.9, + "end": 2013.16 + }, + { + "word": "like", + "start": 2013.16, + "end": 2013.44 + }, + { + "word": "really,", + "start": 2013.44, + "end": 2013.68 + }, + { + "word": "really", + "start": 2013.68, + "end": 2013.96 + }, + { + "word": "good", + "start": 2013.96, + "end": 2014.4 + }, + { + "word": "and", + "start": 2014.4, + "end": 2014.66 + }, + { + "word": "can", + "start": 2014.66, + "end": 2014.84 + }, + { + "word": "tailor", + "start": 2014.84, + "end": 2015.06 + }, + { + "word": "the", + "start": 2015.06, + "end": 2015.3 + }, + { + "word": "solution", + "start": 2015.3, + "end": 2015.64 + } + ] + }, + { + "start": 2015.64, + "end": 2020.88, + "text": "to your product or build it yourself because it's not actually that hard. It'll take you a", + "words": [ + { + "word": "to", + "start": 2015.64, + "end": 2015.88 + }, + { + "word": "your", + "start": 2015.88, + "end": 2016.1 + }, + { + "word": "product", + "start": 2016.1, + "end": 2016.6 + }, + { + "word": "or", + "start": 2016.6, + "end": 2017.08 + }, + { + "word": "build", + "start": 2017.08, + "end": 2017.24 + }, + { + "word": "it", + "start": 2017.24, + "end": 2017.42 + }, + { + "word": "yourself", + "start": 2017.42, + "end": 2017.84 + }, + { + "word": "because", + "start": 2017.84, + "end": 2018.02 + }, + { + "word": "it's", + "start": 2018.02, + "end": 2018.32 + }, + { + "word": "not", + "start": 2018.32, + "end": 2018.64 + }, + { + "word": "actually", + "start": 2018.64, + "end": 2019.02 + }, + { + "word": "that", + "start": 2019.02, + "end": 2019.3 + }, + { + "word": "hard.", + "start": 2019.3, + "end": 2019.72 + }, + { + "word": "It'll", + "start": 2020.06, + "end": 2020.5 + }, + { + "word": "take", + "start": 2020.5, + "end": 2020.6 + }, + { + "word": "you", + "start": 2020.6, + "end": 2020.78 + }, + { + "word": "a", + "start": 2020.78, + "end": 2020.88 + } + ] + }, + { + "start": 2020.88, + "end": 2027.02, + "text": "little bit of time, but especially with LLMs, it's like so much faster because like I said earlier,", + "words": [ + { + "word": "little", + "start": 2020.88, + "end": 2020.98 + }, + { + "word": "bit", + "start": 2020.98, + "end": 2021.12 + }, + { + "word": "of", + "start": 2021.12, + "end": 2021.3 + }, + { + "word": "time,", + "start": 2021.3, + "end": 2021.56 + }, + { + "word": "but", + "start": 2021.56, + "end": 2021.7 + }, + { + "word": "especially", + "start": 2021.7, + "end": 2022.02 + }, + { + "word": "with", + "start": 2022.02, + "end": 2022.28 + }, + { + "word": "LLMs,", + "start": 2022.28, + "end": 2022.62 + }, + { + "word": "it's", + "start": 2022.76, + "end": 2022.88 + }, + { + "word": "like", + "start": 2022.88, + "end": 2023.04 + }, + { + "word": "so", + "start": 2023.04, + "end": 2023.24 + }, + { + "word": "much", + "start": 2023.24, + "end": 2023.38 + }, + { + "word": "faster", + "start": 2023.38, + "end": 2023.98 + }, + { + "word": "because", + "start": 2023.98, + "end": 2025.52 + }, + { + "word": "like", + "start": 2025.52, + "end": 2025.96 + }, + { + "word": "I", + "start": 2025.96, + "end": 2026.14 + }, + { + "word": "said", + "start": 2026.14, + "end": 2026.34 + }, + { + "word": "earlier,", + "start": 2026.34, + "end": 2027.02 + } + ] + }, + { + "start": 2027.38, + "end": 2031.82, + "text": "start with the end in mind. Like what is the SDK that you want? What is the output generation", + "words": [ + { + "word": "start", + "start": 2027.38, + "end": 2027.82 + }, + { + "word": "with", + "start": 2027.82, + "end": 2028.02 + }, + { + "word": "the", + "start": 2028.02, + "end": 2028.1 + }, + { + "word": "end", + "start": 2028.1, + "end": 2028.18 + }, + { + "word": "in", + "start": 2028.18, + "end": 2028.38 + }, + { + "word": "mind.", + "start": 2028.38, + "end": 2028.58 + }, + { + "word": "Like", + "start": 2028.6, + "end": 2028.82 + }, + { + "word": "what", + "start": 2028.82, + "end": 2028.98 + }, + { + "word": "is", + "start": 2028.98, + "end": 2029.32 + }, + { + "word": "the", + "start": 2029.32, + "end": 2029.58 + }, + { + "word": "SDK", + "start": 2029.58, + "end": 2029.84 + }, + { + "word": "that", + "start": 2029.84, + "end": 2030.1 + }, + { + "word": "you", + "start": 2030.1, + "end": 2030.34 + }, + { + "word": "want?", + "start": 2030.34, + "end": 2030.48 + }, + { + "word": "What", + "start": 2030.5, + "end": 2030.62 + }, + { + "word": "is", + "start": 2030.62, + "end": 2030.78 + }, + { + "word": "the", + "start": 2030.78, + "end": 2030.98 + }, + { + "word": "output", + "start": 2030.98, + "end": 2031.38 + }, + { + "word": "generation", + "start": 2031.38, + "end": 2031.82 + } + ] + }, + { + "start": 2031.82, + "end": 2036.36, + "text": "that you want? And you really want to use that as a North Star. So, yes, there are sharp edges and", + "words": [ + { + "word": "that", + "start": 2031.82, + "end": 2032.0 + }, + { + "word": "you", + "start": 2032.0, + "end": 2032.22 + }, + { + "word": "want?", + "start": 2032.22, + "end": 2032.4 + }, + { + "word": "And", + "start": 2032.42, + "end": 2032.64 + }, + { + "word": "you", + "start": 2032.64, + "end": 2032.78 + }, + { + "word": "really", + "start": 2032.78, + "end": 2033.0 + }, + { + "word": "want", + "start": 2033.0, + "end": 2033.14 + }, + { + "word": "to", + "start": 2033.14, + "end": 2033.28 + }, + { + "word": "use", + "start": 2033.28, + "end": 2033.38 + }, + { + "word": "that", + "start": 2033.38, + "end": 2033.56 + }, + { + "word": "as", + "start": 2033.56, + "end": 2033.7 + }, + { + "word": "a", + "start": 2033.7, + "end": 2033.82 + }, + { + "word": "North", + "start": 2033.82, + "end": 2033.98 + }, + { + "word": "Star.", + "start": 2033.98, + "end": 2034.7 + }, + { + "word": "So,", + "start": 2034.82, + "end": 2035.16 + }, + { + "word": "yes,", + "start": 2035.16, + "end": 2035.36 + }, + { + "word": "there", + "start": 2035.36, + "end": 2035.58 + }, + { + "word": "are", + "start": 2035.58, + "end": 2035.72 + }, + { + "word": "sharp", + "start": 2035.72, + "end": 2035.88 + }, + { + "word": "edges", + "start": 2035.88, + "end": 2036.14 + }, + { + "word": "and", + "start": 2036.14, + "end": 2036.36 + } + ] + }, + { + "start": 2036.36, + "end": 2040.84, + "text": "you have to figure out, but it's still worth, in most cases, just doing it yourself if you have the", + "words": [ + { + "word": "you", + "start": 2036.36, + "end": 2036.62 + }, + { + "word": "have", + "start": 2036.62, + "end": 2036.72 + }, + { + "word": "to", + "start": 2036.72, + "end": 2036.86 + }, + { + "word": "figure", + "start": 2036.86, + "end": 2037.08 + }, + { + "word": "out,", + "start": 2037.08, + "end": 2037.28 + }, + { + "word": "but", + "start": 2037.32, + "end": 2037.4 + }, + { + "word": "it's", + "start": 2037.4, + "end": 2037.74 + }, + { + "word": "still", + "start": 2037.74, + "end": 2038.06 + }, + { + "word": "worth,", + "start": 2038.06, + "end": 2038.52 + }, + { + "word": "in", + "start": 2038.66, + "end": 2038.74 + }, + { + "word": "most", + "start": 2038.74, + "end": 2038.96 + }, + { + "word": "cases,", + "start": 2038.96, + "end": 2039.24 + }, + { + "word": "just", + "start": 2039.26, + "end": 2039.54 + }, + { + "word": "doing", + "start": 2039.54, + "end": 2039.74 + }, + { + "word": "it", + "start": 2039.74, + "end": 2039.9 + }, + { + "word": "yourself", + "start": 2039.9, + "end": 2040.28 + }, + { + "word": "if", + "start": 2040.28, + "end": 2040.48 + }, + { + "word": "you", + "start": 2040.48, + "end": 2040.6 + }, + { + "word": "have", + "start": 2040.6, + "end": 2040.7 + }, + { + "word": "the", + "start": 2040.7, + "end": 2040.84 + } + ] + }, + { + "start": 2040.84, + "end": 2049.24, + "text": "time. Hey, also great DevTools episode with Richard Feldman for Rock. What is it? Rock is", + "words": [ + { + "word": "time.", + "start": 2040.84, + "end": 2041.24 + }, + { + "word": "Hey,", + "start": 2043.88, + "end": 2044.2 + }, + { + "word": "also", + "start": 2044.44, + "end": 2044.9 + }, + { + "word": "great", + "start": 2044.9, + "end": 2045.36 + }, + { + "word": "DevTools", + "start": 2045.36, + "end": 2045.78 + }, + { + "word": "episode", + "start": 2045.78, + "end": 2046.34 + }, + { + "word": "with", + "start": 2046.34, + "end": 2046.74 + }, + { + "word": "Richard", + "start": 2046.74, + "end": 2047.04 + }, + { + "word": "Feldman", + "start": 2047.04, + "end": 2047.36 + }, + { + "word": "for", + "start": 2047.36, + "end": 2047.6 + }, + { + "word": "Rock.", + "start": 2047.6, + "end": 2047.94 + }, + { + "word": "What", + "start": 2048.08, + "end": 2048.34 + }, + { + "word": "is", + "start": 2048.34, + "end": 2048.58 + }, + { + "word": "it?", + "start": 2048.58, + "end": 2048.86 + }, + { + "word": "Rock", + "start": 2048.88, + "end": 2049.08 + }, + { + "word": "is", + "start": 2049.08, + "end": 2049.24 + } + ] + }, + { + "start": 2049.24, + "end": 2055.7, + "text": "very exciting. There's a Russ meetup. With respect to your specific example with Python,", + "words": [ + { + "word": "very", + "start": 2049.24, + "end": 2049.42 + }, + { + "word": "exciting.", + "start": 2049.42, + "end": 2049.82 + }, + { + "word": "There's", + "start": 2050.26, + "end": 2050.44 + }, + { + "word": "a", + "start": 2050.44, + "end": 2050.54 + }, + { + "word": "Russ", + "start": 2050.54, + "end": 2050.68 + }, + { + "word": "meetup.", + "start": 2050.68, + "end": 2051.32 + }, + { + "word": "With", + "start": 2052.26, + "end": 2052.6 + }, + { + "word": "respect", + "start": 2052.6, + "end": 2053.32 + }, + { + "word": "to", + "start": 2053.32, + "end": 2053.72 + }, + { + "word": "your", + "start": 2053.72, + "end": 2053.92 + }, + { + "word": "specific", + "start": 2053.92, + "end": 2054.24 + }, + { + "word": "example", + "start": 2054.24, + "end": 2054.72 + }, + { + "word": "with", + "start": 2054.72, + "end": 2055.02 + }, + { + "word": "Python,", + "start": 2055.02, + "end": 2055.7 + } + ] + }, + { + "start": 2056.64, + "end": 2063.84, + "text": "why did you go with the union type versus just making like a really thin base class", + "words": [ + { + "word": "why", + "start": 2056.64, + "end": 2057.1 + }, + { + "word": "did", + "start": 2057.1, + "end": 2057.28 + }, + { + "word": "you", + "start": 2057.28, + "end": 2057.7 + }, + { + "word": "go", + "start": 2057.7, + "end": 2058.12 + }, + { + "word": "with", + "start": 2058.12, + "end": 2058.82 + }, + { + "word": "the", + "start": 2058.82, + "end": 2059.3 + }, + { + "word": "union", + "start": 2059.3, + "end": 2059.64 + }, + { + "word": "type", + "start": 2059.64, + "end": 2060.12 + }, + { + "word": "versus", + "start": 2060.12, + "end": 2060.7 + }, + { + "word": "just", + "start": 2060.7, + "end": 2061.04 + }, + { + "word": "making", + "start": 2061.04, + "end": 2061.22 + }, + { + "word": "like", + "start": 2061.22, + "end": 2061.44 + }, + { + "word": "a", + "start": 2061.44, + "end": 2061.74 + }, + { + "word": "really", + "start": 2061.74, + "end": 2062.18 + }, + { + "word": "thin", + "start": 2062.18, + "end": 2062.8 + }, + { + "word": "base", + "start": 2062.8, + "end": 2063.32 + }, + { + "word": "class", + "start": 2063.32, + "end": 2063.84 + } + ] + }, + { + "start": 2063.84, + "end": 2069.04, + "text": "and making the other subclasses of that? Was it so that you could have like exhaustive pattern", + "words": [ + { + "word": "and", + "start": 2063.84, + "end": 2064.02 + }, + { + "word": "making", + "start": 2064.02, + "end": 2064.66 + }, + { + "word": "the", + "start": 2064.66, + "end": 2064.96 + }, + { + "word": "other", + "start": 2064.96, + "end": 2065.3 + }, + { + "word": "subclasses", + "start": 2065.3, + "end": 2066.04 + }, + { + "word": "of", + "start": 2066.04, + "end": 2066.18 + }, + { + "word": "that?", + "start": 2066.18, + "end": 2066.34 + }, + { + "word": "Was", + "start": 2066.54, + "end": 2066.54 + }, + { + "word": "it", + "start": 2066.54, + "end": 2066.68 + }, + { + "word": "so", + "start": 2066.68, + "end": 2066.9 + }, + { + "word": "that", + "start": 2066.9, + "end": 2067.06 + }, + { + "word": "you", + "start": 2067.06, + "end": 2067.12 + }, + { + "word": "could", + "start": 2067.12, + "end": 2067.32 + }, + { + "word": "have", + "start": 2067.32, + "end": 2067.82 + }, + { + "word": "like", + "start": 2067.82, + "end": 2068.14 + }, + { + "word": "exhaustive", + "start": 2068.14, + "end": 2068.66 + }, + { + "word": "pattern", + "start": 2068.66, + "end": 2069.04 + } + ] + }, + { + "start": 2069.04, + "end": 2075.9, + "text": "matching? Also like kind of going with that, like how deep did you decide to go with the cogen? Like", + "words": [ + { + "word": "matching?", + "start": 2069.04, + "end": 2069.5 + }, + { + "word": "Also", + "start": 2069.98, + "end": 2070.14 + }, + { + "word": "like", + "start": 2070.14, + "end": 2070.38 + }, + { + "word": "kind", + "start": 2070.38, + "end": 2070.54 + }, + { + "word": "of", + "start": 2070.54, + "end": 2070.68 + }, + { + "word": "going", + "start": 2070.68, + "end": 2070.82 + }, + { + "word": "with", + "start": 2070.82, + "end": 2071.08 + }, + { + "word": "that,", + "start": 2071.08, + "end": 2071.2 + }, + { + "word": "like", + "start": 2071.48, + "end": 2071.76 + }, + { + "word": "how", + "start": 2071.76, + "end": 2072.06 + }, + { + "word": "deep", + "start": 2072.06, + "end": 2072.42 + }, + { + "word": "did", + "start": 2072.42, + "end": 2072.54 + }, + { + "word": "you", + "start": 2072.54, + "end": 2072.74 + }, + { + "word": "decide", + "start": 2072.74, + "end": 2073.04 + }, + { + "word": "to", + "start": 2073.04, + "end": 2073.28 + }, + { + "word": "go", + "start": 2073.28, + "end": 2073.7 + }, + { + "word": "with", + "start": 2073.7, + "end": 2074.56 + }, + { + "word": "the", + "start": 2074.56, + "end": 2075.06 + }, + { + "word": "cogen?", + "start": 2075.06, + "end": 2075.4 + }, + { + "word": "Like", + "start": 2075.7, + "end": 2075.9 + } + ] + }, + { + "start": 2075.9, + "end": 2082.56, + "text": "was it mostly like making a couple basic types for use or did you like try, was the exhaustive", + "words": [ + { + "word": "was", + "start": 2075.9, + "end": 2076.2 + }, + { + "word": "it", + "start": 2076.2, + "end": 2076.38 + }, + { + "word": "mostly", + "start": 2076.38, + "end": 2076.64 + }, + { + "word": "like", + "start": 2076.64, + "end": 2076.96 + }, + { + "word": "making", + "start": 2076.96, + "end": 2077.18 + }, + { + "word": "a", + "start": 2077.18, + "end": 2077.5 + }, + { + "word": "couple", + "start": 2077.5, + "end": 2077.9 + }, + { + "word": "basic", + "start": 2077.9, + "end": 2078.58 + }, + { + "word": "types", + "start": 2078.58, + "end": 2078.96 + }, + { + "word": "for", + "start": 2078.96, + "end": 2079.28 + }, + { + "word": "use", + "start": 2079.28, + "end": 2079.56 + }, + { + "word": "or", + "start": 2079.56, + "end": 2080.04 + }, + { + "word": "did", + "start": 2080.04, + "end": 2080.18 + }, + { + "word": "you", + "start": 2080.18, + "end": 2080.4 + }, + { + "word": "like", + "start": 2080.4, + "end": 2080.74 + }, + { + "word": "try,", + "start": 2080.74, + "end": 2081.04 + }, + { + "word": "was", + "start": 2081.34, + "end": 2081.86 + }, + { + "word": "the", + "start": 2081.86, + "end": 2082.14 + }, + { + "word": "exhaustive", + "start": 2082.14, + "end": 2082.56 + } + ] + }, + { + "start": 2082.56, + "end": 2089.6, + "text": "pattern matching useful for more advanced parts of the SDK? So for my project, everything that", + "words": [ + { + "word": "pattern", + "start": 2082.56, + "end": 2082.7 + }, + { + "word": "matching", + "start": 2082.7, + "end": 2083.22 + }, + { + "word": "useful", + "start": 2083.22, + "end": 2083.8 + }, + { + "word": "for", + "start": 2083.8, + "end": 2084.42 + }, + { + "word": "more", + "start": 2084.42, + "end": 2084.7 + }, + { + "word": "advanced", + "start": 2084.7, + "end": 2085.16 + }, + { + "word": "parts", + "start": 2085.16, + "end": 2085.48 + }, + { + "word": "of", + "start": 2085.48, + "end": 2085.64 + }, + { + "word": "the", + "start": 2085.64, + "end": 2085.84 + }, + { + "word": "SDK?", + "start": 2085.84, + "end": 2086.04 + }, + { + "word": "So", + "start": 2086.88, + "end": 2087.28 + }, + { + "word": "for", + "start": 2087.28, + "end": 2087.84 + }, + { + "word": "my", + "start": 2087.84, + "end": 2088.1 + }, + { + "word": "project,", + "start": 2088.1, + "end": 2088.52 + }, + { + "word": "everything", + "start": 2088.72, + "end": 2089.26 + }, + { + "word": "that", + "start": 2089.26, + "end": 2089.6 + } + ] + }, + { + "start": 2089.6, + "end": 2094.72, + "text": "goes across the wire is represented by these generated types. So anything in the communication", + "words": [ + { + "word": "goes", + "start": 2089.6, + "end": 2089.9 + }, + { + "word": "across", + "start": 2089.9, + "end": 2090.22 + }, + { + "word": "the", + "start": 2090.22, + "end": 2090.48 + }, + { + "word": "wire", + "start": 2090.48, + "end": 2090.84 + }, + { + "word": "is", + "start": 2090.84, + "end": 2091.16 + }, + { + "word": "represented", + "start": 2091.16, + "end": 2091.66 + }, + { + "word": "by", + "start": 2091.66, + "end": 2091.96 + }, + { + "word": "these", + "start": 2091.96, + "end": 2092.24 + }, + { + "word": "generated", + "start": 2092.24, + "end": 2092.6 + }, + { + "word": "types.", + "start": 2092.6, + "end": 2093.14 + }, + { + "word": "So", + "start": 2093.62, + "end": 2093.74 + }, + { + "word": "anything", + "start": 2093.74, + "end": 2094.0 + }, + { + "word": "in", + "start": 2094.0, + "end": 2094.14 + }, + { + "word": "the", + "start": 2094.14, + "end": 2094.3 + }, + { + "word": "communication", + "start": 2094.3, + "end": 2094.72 + } + ] + }, + { + "start": 2094.72, + "end": 2100.92, + "text": "layer. And as for why not using a light like base class, that was actually the first approach that", + "words": [ + { + "word": "layer.", + "start": 2094.72, + "end": 2095.08 + }, + { + "word": "And", + "start": 2096.38, + "end": 2096.6 + }, + { + "word": "as", + "start": 2096.6, + "end": 2096.78 + }, + { + "word": "for", + "start": 2096.78, + "end": 2097.0 + }, + { + "word": "why", + "start": 2097.0, + "end": 2097.4 + }, + { + "word": "not", + "start": 2097.4, + "end": 2097.6 + }, + { + "word": "using", + "start": 2097.6, + "end": 2097.92 + }, + { + "word": "a", + "start": 2097.92, + "end": 2098.56 + }, + { + "word": "light", + "start": 2098.56, + "end": 2098.56 + }, + { + "word": "like", + "start": 2098.56, + "end": 2099.26 + }, + { + "word": "base", + "start": 2099.26, + "end": 2099.46 + }, + { + "word": "class,", + "start": 2099.46, + "end": 2099.68 + }, + { + "word": "that", + "start": 2099.74, + "end": 2099.86 + }, + { + "word": "was", + "start": 2099.86, + "end": 2099.94 + }, + { + "word": "actually", + "start": 2099.94, + "end": 2100.16 + }, + { + "word": "the", + "start": 2100.16, + "end": 2100.32 + }, + { + "word": "first", + "start": 2100.32, + "end": 2100.48 + }, + { + "word": "approach", + "start": 2100.48, + "end": 2100.72 + }, + { + "word": "that", + "start": 2100.72, + "end": 2100.92 + } + ] + }, + { + "start": 2100.92, + "end": 2106.22, + "text": "I had. But the problem is you start with like, oh, there's just one intersection here. It's just like,", + "words": [ + { + "word": "I", + "start": 2100.92, + "end": 2101.0 + }, + { + "word": "had.", + "start": 2101.0, + "end": 2101.24 + }, + { + "word": "But", + "start": 2101.34, + "end": 2101.42 + }, + { + "word": "the", + "start": 2101.42, + "end": 2101.64 + }, + { + "word": "problem", + "start": 2101.64, + "end": 2101.84 + }, + { + "word": "is", + "start": 2101.84, + "end": 2102.44 + }, + { + "word": "you", + "start": 2102.44, + "end": 2103.22 + }, + { + "word": "start", + "start": 2103.22, + "end": 2103.64 + }, + { + "word": "with", + "start": 2103.64, + "end": 2103.9 + }, + { + "word": "like,", + "start": 2103.9, + "end": 2104.14 + }, + { + "word": "oh,", + "start": 2104.24, + "end": 2104.26 + }, + { + "word": "there's", + "start": 2104.28, + "end": 2104.42 + }, + { + "word": "just", + "start": 2104.42, + "end": 2104.66 + }, + { + "word": "one", + "start": 2104.66, + "end": 2104.88 + }, + { + "word": "intersection", + "start": 2104.88, + "end": 2105.26 + }, + { + "word": "here.", + "start": 2105.26, + "end": 2105.62 + }, + { + "word": "It's", + "start": 2105.74, + "end": 2105.88 + }, + { + "word": "just", + "start": 2105.88, + "end": 2106.06 + }, + { + "word": "like,", + "start": 2106.06, + "end": 2106.22 + } + ] + }, + { + "start": 2106.24, + "end": 2110.96, + "text": "I'm just mixing something in. And then you get another and another and another. And it kind of", + "words": [ + { + "word": "I'm", + "start": 2106.24, + "end": 2106.36 + }, + { + "word": "just", + "start": 2106.36, + "end": 2106.54 + }, + { + "word": "mixing", + "start": 2106.54, + "end": 2106.72 + }, + { + "word": "something", + "start": 2106.72, + "end": 2107.06 + }, + { + "word": "in.", + "start": 2107.06, + "end": 2107.34 + }, + { + "word": "And", + "start": 2107.36, + "end": 2107.56 + }, + { + "word": "then", + "start": 2107.56, + "end": 2107.82 + }, + { + "word": "you", + "start": 2107.82, + "end": 2108.02 + }, + { + "word": "get", + "start": 2108.02, + "end": 2108.26 + }, + { + "word": "another", + "start": 2108.26, + "end": 2108.52 + }, + { + "word": "and", + "start": 2108.52, + "end": 2108.7 + }, + { + "word": "another", + "start": 2108.7, + "end": 2108.9 + }, + { + "word": "and", + "start": 2108.9, + "end": 2109.1 + }, + { + "word": "another.", + "start": 2109.1, + "end": 2109.32 + }, + { + "word": "And", + "start": 2109.56, + "end": 2110.0 + }, + { + "word": "it", + "start": 2110.0, + "end": 2110.66 + }, + { + "word": "kind", + "start": 2110.66, + "end": 2110.78 + }, + { + "word": "of", + "start": 2110.78, + "end": 2110.96 + } + ] + }, + { + "start": 2110.96, + "end": 2115.8, + "text": "grows into this thing where it's like what worked at one time, like doesn't work when you just add", + "words": [ + { + "word": "grows", + "start": 2110.96, + "end": 2111.2 + }, + { + "word": "into", + "start": 2111.2, + "end": 2111.46 + }, + { + "word": "this", + "start": 2111.46, + "end": 2111.78 + }, + { + "word": "thing", + "start": 2111.78, + "end": 2111.96 + }, + { + "word": "where", + "start": 2111.96, + "end": 2112.18 + }, + { + "word": "it's", + "start": 2112.18, + "end": 2112.34 + }, + { + "word": "like", + "start": 2112.34, + "end": 2112.72 + }, + { + "word": "what", + "start": 2112.72, + "end": 2112.98 + }, + { + "word": "worked", + "start": 2112.98, + "end": 2113.44 + }, + { + "word": "at", + "start": 2113.44, + "end": 2113.86 + }, + { + "word": "one", + "start": 2113.86, + "end": 2114.08 + }, + { + "word": "time,", + "start": 2114.08, + "end": 2114.38 + }, + { + "word": "like", + "start": 2114.38, + "end": 2114.64 + }, + { + "word": "doesn't", + "start": 2114.64, + "end": 2114.9 + }, + { + "word": "work", + "start": 2114.9, + "end": 2115.14 + }, + { + "word": "when", + "start": 2115.14, + "end": 2115.26 + }, + { + "word": "you", + "start": 2115.26, + "end": 2115.42 + }, + { + "word": "just", + "start": 2115.42, + "end": 2115.6 + }, + { + "word": "add", + "start": 2115.6, + "end": 2115.8 + } + ] + }, + { + "start": 2115.8, + "end": 2121.88, + "text": "another configuration. So the Python that I generate now are actually just all unions. I've", + "words": [ + { + "word": "another", + "start": 2115.8, + "end": 2116.0 + }, + { + "word": "configuration.", + "start": 2116.0, + "end": 2116.58 + }, + { + "word": "So", + "start": 2117.74, + "end": 2117.92 + }, + { + "word": "the", + "start": 2117.92, + "end": 2118.68 + }, + { + "word": "Python", + "start": 2118.68, + "end": 2119.04 + }, + { + "word": "that", + "start": 2119.04, + "end": 2119.2 + }, + { + "word": "I", + "start": 2119.2, + "end": 2119.32 + }, + { + "word": "generate", + "start": 2119.32, + "end": 2119.56 + }, + { + "word": "now", + "start": 2119.56, + "end": 2119.86 + }, + { + "word": "are", + "start": 2119.86, + "end": 2120.12 + }, + { + "word": "actually", + "start": 2120.12, + "end": 2120.3 + }, + { + "word": "just", + "start": 2120.3, + "end": 2120.76 + }, + { + "word": "all", + "start": 2120.76, + "end": 2121.04 + }, + { + "word": "unions.", + "start": 2121.04, + "end": 2121.42 + }, + { + "word": "I've", + "start": 2121.54, + "end": 2121.88 + } + ] + }, + { + "start": 2121.88, + "end": 2126.56, + "text": "avoided intersections entirely. There are no base, pretty much there are no base classes.", + "words": [ + { + "word": "avoided", + "start": 2121.88, + "end": 2122.3 + }, + { + "word": "intersections", + "start": 2122.3, + "end": 2122.88 + }, + { + "word": "entirely.", + "start": 2122.88, + "end": 2123.36 + }, + { + "word": "There", + "start": 2123.54, + "end": 2123.54 + }, + { + "word": "are", + "start": 2123.54, + "end": 2123.76 + }, + { + "word": "no", + "start": 2123.76, + "end": 2123.9 + }, + { + "word": "base,", + "start": 2123.9, + "end": 2124.1 + }, + { + "word": "pretty", + "start": 2124.32, + "end": 2125.36 + }, + { + "word": "much", + "start": 2125.36, + "end": 2125.56 + }, + { + "word": "there", + "start": 2125.56, + "end": 2125.72 + }, + { + "word": "are", + "start": 2125.72, + "end": 2125.82 + }, + { + "word": "no", + "start": 2125.82, + "end": 2125.96 + }, + { + "word": "base", + "start": 2125.96, + "end": 2126.12 + }, + { + "word": "classes.", + "start": 2126.12, + "end": 2126.56 + } + ] + }, + { + "start": 2127.5, + "end": 2133.6, + "text": "And so it's constrained, but the overall code is significantly simpler. And I think that for me,", + "words": [ + { + "word": "And", + "start": 2127.5, + "end": 2128.02 + }, + { + "word": "so", + "start": 2128.02, + "end": 2128.54 + }, + { + "word": "it's", + "start": 2128.54, + "end": 2128.98 + }, + { + "word": "constrained,", + "start": 2128.98, + "end": 2129.54 + }, + { + "word": "but", + "start": 2129.56, + "end": 2130.0 + }, + { + "word": "the", + "start": 2130.0, + "end": 2130.26 + }, + { + "word": "overall", + "start": 2130.26, + "end": 2130.48 + }, + { + "word": "code", + "start": 2130.48, + "end": 2130.76 + }, + { + "word": "is", + "start": 2130.76, + "end": 2131.22 + }, + { + "word": "significantly", + "start": 2131.22, + "end": 2131.72 + }, + { + "word": "simpler.", + "start": 2131.72, + "end": 2132.18 + }, + { + "word": "And", + "start": 2132.18, + "end": 2132.44 + }, + { + "word": "I", + "start": 2132.44, + "end": 2132.6 + }, + { + "word": "think", + "start": 2132.6, + "end": 2132.76 + }, + { + "word": "that", + "start": 2132.76, + "end": 2133.1 + }, + { + "word": "for", + "start": 2133.1, + "end": 2133.28 + }, + { + "word": "me,", + "start": 2133.28, + "end": 2133.6 + } + ] + }, + { + "start": 2133.6, + "end": 2138.7, + "text": "that's a big win because again, I'm kind of thinking about like, how does any just person", + "words": [ + { + "word": "that's", + "start": 2133.6, + "end": 2133.84 + }, + { + "word": "a", + "start": 2133.84, + "end": 2133.92 + }, + { + "word": "big", + "start": 2133.92, + "end": 2134.1 + }, + { + "word": "win", + "start": 2134.1, + "end": 2134.38 + }, + { + "word": "because", + "start": 2134.38, + "end": 2134.72 + }, + { + "word": "again,", + "start": 2134.72, + "end": 2135.06 + }, + { + "word": "I'm", + "start": 2135.06, + "end": 2135.26 + }, + { + "word": "kind", + "start": 2135.26, + "end": 2135.38 + }, + { + "word": "of", + "start": 2135.38, + "end": 2135.48 + }, + { + "word": "thinking", + "start": 2135.48, + "end": 2135.68 + }, + { + "word": "about", + "start": 2135.68, + "end": 2135.94 + }, + { + "word": "like,", + "start": 2135.94, + "end": 2136.8 + }, + { + "word": "how", + "start": 2136.8, + "end": 2137.04 + }, + { + "word": "does", + "start": 2137.04, + "end": 2137.26 + }, + { + "word": "any", + "start": 2137.26, + "end": 2137.58 + }, + { + "word": "just", + "start": 2137.58, + "end": 2138.02 + }, + { + "word": "person", + "start": 2138.02, + "end": 2138.7 + } + ] + }, + { + "start": 2138.7, + "end": 2144.78, + "text": "make a simple interface to interact with this framework? And I think", + "words": [ + { + "word": "make", + "start": 2138.7, + "end": 2139.22 + }, + { + "word": "a", + "start": 2139.22, + "end": 2140.18 + }, + { + "word": "simple", + "start": 2140.18, + "end": 2140.84 + }, + { + "word": "interface", + "start": 2140.84, + "end": 2141.56 + }, + { + "word": "to", + "start": 2141.56, + "end": 2142.0 + }, + { + "word": "interact", + "start": 2142.0, + "end": 2142.32 + }, + { + "word": "with", + "start": 2142.32, + "end": 2142.62 + }, + { + "word": "this", + "start": 2142.62, + "end": 2143.06 + }, + { + "word": "framework?", + "start": 2143.06, + "end": 2143.58 + }, + { + "word": "And", + "start": 2144.48, + "end": 2144.48 + }, + { + "word": "I", + "start": 2144.48, + "end": 2144.74 + }, + { + "word": "think", + "start": 2144.74, + "end": 2145.08 + } + ] + }, + { + "start": 2145.8, + "end": 2151.14, + "text": "really going towards simplicity meant that I just had to think very deeply about how to keep the", + "words": [ + { + "word": "really", + "start": 2145.8, + "end": 2146.48 + }, + { + "word": "going", + "start": 2146.48, + "end": 2146.82 + }, + { + "word": "towards", + "start": 2146.82, + "end": 2147.08 + }, + { + "word": "simplicity", + "start": 2147.08, + "end": 2147.64 + }, + { + "word": "meant", + "start": 2147.64, + "end": 2148.26 + }, + { + "word": "that", + "start": 2148.26, + "end": 2148.64 + }, + { + "word": "I", + "start": 2148.64, + "end": 2148.8 + }, + { + "word": "just", + "start": 2148.8, + "end": 2148.94 + }, + { + "word": "had", + "start": 2148.94, + "end": 2149.06 + }, + { + "word": "to", + "start": 2149.06, + "end": 2149.2 + }, + { + "word": "think", + "start": 2149.2, + "end": 2149.3 + }, + { + "word": "very", + "start": 2149.3, + "end": 2149.56 + }, + { + "word": "deeply", + "start": 2149.56, + "end": 2149.84 + }, + { + "word": "about", + "start": 2149.84, + "end": 2150.18 + }, + { + "word": "how", + "start": 2150.18, + "end": 2150.64 + }, + { + "word": "to", + "start": 2150.64, + "end": 2150.86 + }, + { + "word": "keep", + "start": 2150.86, + "end": 2151.0 + }, + { + "word": "the", + "start": 2151.0, + "end": 2151.14 + } + ] + }, + { + "start": 2151.14, + "end": 2155.6, + "text": "overall interface as simple. Do we have any other questions?", + "words": [ + { + "word": "overall", + "start": 2151.14, + "end": 2151.42 + }, + { + "word": "interface", + "start": 2151.42, + "end": 2151.78 + }, + { + "word": "as", + "start": 2151.78, + "end": 2151.96 + }, + { + "word": "simple.", + "start": 2151.96, + "end": 2152.32 + }, + { + "word": "Do", + "start": 2154.18, + "end": 2154.34 + }, + { + "word": "we", + "start": 2154.34, + "end": 2154.42 + }, + { + "word": "have", + "start": 2154.42, + "end": 2154.52 + }, + { + "word": "any", + "start": 2154.52, + "end": 2154.66 + }, + { + "word": "other", + "start": 2154.66, + "end": 2155.0 + }, + { + "word": "questions?", + "start": 2155.0, + "end": 2155.6 + } + ] + }, + { + "start": 2164.42, + "end": 2169.6, + "text": "So one thing you highlighted again and again was like, you're kind of reducing to the lowest", + "words": [ + { + "word": "So", + "start": 2164.42, + "end": 2164.94 + }, + { + "word": "one", + "start": 2164.94, + "end": 2165.46 + }, + { + "word": "thing", + "start": 2165.46, + "end": 2165.62 + }, + { + "word": "you", + "start": 2165.62, + "end": 2165.92 + }, + { + "word": "highlighted", + "start": 2165.92, + "end": 2166.28 + }, + { + "word": "again", + "start": 2166.28, + "end": 2166.8 + }, + { + "word": "and", + "start": 2166.8, + "end": 2167.04 + }, + { + "word": "again", + "start": 2167.04, + "end": 2167.28 + }, + { + "word": "was", + "start": 2167.28, + "end": 2167.5 + }, + { + "word": "like,", + "start": 2167.5, + "end": 2167.88 + }, + { + "word": "you're", + "start": 2168.22, + "end": 2168.4 + }, + { + "word": "kind", + "start": 2168.4, + "end": 2168.54 + }, + { + "word": "of", + "start": 2168.54, + "end": 2168.68 + }, + { + "word": "reducing", + "start": 2168.68, + "end": 2169.0 + }, + { + "word": "to", + "start": 2169.0, + "end": 2169.28 + }, + { + "word": "the", + "start": 2169.28, + "end": 2169.42 + }, + { + "word": "lowest", + "start": 2169.42, + "end": 2169.6 + } + ] + }, + { + "start": 2169.6, + "end": 2174.04, + "text": "common denominator and like what languages you want to support, what they actually support.", + "words": [ + { + "word": "common", + "start": 2169.6, + "end": 2169.92 + }, + { + "word": "denominator", + "start": 2169.92, + "end": 2170.36 + }, + { + "word": "and", + "start": 2170.36, + "end": 2170.68 + }, + { + "word": "like", + "start": 2170.68, + "end": 2171.08 + }, + { + "word": "what", + "start": 2171.08, + "end": 2171.3 + }, + { + "word": "languages", + "start": 2171.3, + "end": 2171.7 + }, + { + "word": "you", + "start": 2171.7, + "end": 2172.02 + }, + { + "word": "want", + "start": 2172.02, + "end": 2172.14 + }, + { + "word": "to", + "start": 2172.14, + "end": 2172.42 + }, + { + "word": "support,", + "start": 2172.42, + "end": 2172.7 + }, + { + "word": "what", + "start": 2172.9, + "end": 2173.04 + }, + { + "word": "they", + "start": 2173.04, + "end": 2173.32 + }, + { + "word": "actually", + "start": 2173.32, + "end": 2173.58 + }, + { + "word": "support.", + "start": 2173.58, + "end": 2174.04 + } + ] + }, + { + "start": 2174.2, + "end": 2179.68, + "text": "But at what point do you kind of call it quits for a specific language and go in and maybe do", + "words": [ + { + "word": "But", + "start": 2174.2, + "end": 2174.6 + }, + { + "word": "at", + "start": 2174.6, + "end": 2174.82 + }, + { + "word": "what", + "start": 2174.82, + "end": 2175.08 + }, + { + "word": "point", + "start": 2175.08, + "end": 2175.34 + }, + { + "word": "do", + "start": 2175.34, + "end": 2175.52 + }, + { + "word": "you", + "start": 2175.52, + "end": 2175.68 + }, + { + "word": "kind", + "start": 2175.68, + "end": 2175.8 + }, + { + "word": "of", + "start": 2175.8, + "end": 2175.98 + }, + { + "word": "call", + "start": 2175.98, + "end": 2176.08 + }, + { + "word": "it", + "start": 2176.08, + "end": 2176.28 + }, + { + "word": "quits", + "start": 2176.28, + "end": 2176.4 + }, + { + "word": "for", + "start": 2176.4, + "end": 2176.58 + }, + { + "word": "a", + "start": 2176.58, + "end": 2176.66 + }, + { + "word": "specific", + "start": 2176.66, + "end": 2176.9 + }, + { + "word": "language", + "start": 2176.9, + "end": 2177.38 + }, + { + "word": "and", + "start": 2177.38, + "end": 2177.66 + }, + { + "word": "go", + "start": 2177.66, + "end": 2177.8 + }, + { + "word": "in", + "start": 2177.8, + "end": 2178.22 + }, + { + "word": "and", + "start": 2178.22, + "end": 2178.84 + }, + { + "word": "maybe", + "start": 2178.84, + "end": 2179.32 + }, + { + "word": "do", + "start": 2179.32, + "end": 2179.68 + } + ] + }, + { + "start": 2179.68, + "end": 2184.5, + "text": "something yourself that is like really hamstringing the API in other languages?", + "words": [ + { + "word": "something", + "start": 2179.68, + "end": 2180.16 + }, + { + "word": "yourself", + "start": 2180.16, + "end": 2180.78 + }, + { + "word": "that", + "start": 2180.78, + "end": 2181.5 + }, + { + "word": "is", + "start": 2181.5, + "end": 2181.86 + }, + { + "word": "like", + "start": 2181.86, + "end": 2181.94 + }, + { + "word": "really", + "start": 2181.94, + "end": 2182.18 + }, + { + "word": "hamstringing", + "start": 2182.18, + "end": 2182.86 + }, + { + "word": "the", + "start": 2182.86, + "end": 2183.28 + }, + { + "word": "API", + "start": 2183.28, + "end": 2183.6 + }, + { + "word": "in", + "start": 2183.6, + "end": 2183.82 + }, + { + "word": "other", + "start": 2183.82, + "end": 2183.96 + }, + { + "word": "languages?", + "start": 2183.96, + "end": 2184.5 + } + ] + }, + { + "start": 2185.16, + "end": 2190.32, + "text": "And how do you deal with like the interface between cogen and manually created APIs when", + "words": [ + { + "word": "And", + "start": 2185.16, + "end": 2185.64 + }, + { + "word": "how", + "start": 2185.64, + "end": 2185.8 + }, + { + "word": "do", + "start": 2185.8, + "end": 2185.9 + }, + { + "word": "you", + "start": 2185.9, + "end": 2186.0 + }, + { + "word": "deal", + "start": 2186.0, + "end": 2186.16 + }, + { + "word": "with", + "start": 2186.16, + "end": 2186.4 + }, + { + "word": "like", + "start": 2186.4, + "end": 2186.58 + }, + { + "word": "the", + "start": 2186.58, + "end": 2186.8 + }, + { + "word": "interface", + "start": 2186.8, + "end": 2187.12 + }, + { + "word": "between", + "start": 2187.12, + "end": 2187.48 + }, + { + "word": "cogen", + "start": 2187.48, + "end": 2187.9 + }, + { + "word": "and", + "start": 2187.9, + "end": 2188.9 + }, + { + "word": "manually", + "start": 2188.9, + "end": 2189.42 + }, + { + "word": "created", + "start": 2189.42, + "end": 2189.7 + }, + { + "word": "APIs", + "start": 2189.7, + "end": 2190.14 + }, + { + "word": "when", + "start": 2190.14, + "end": 2190.32 + } + ] + }, + { + "start": 2190.32, + "end": 2194.32, + "text": "you have to patch and things like that? I think a really good example of this is so", + "words": [ + { + "word": "you", + "start": 2190.32, + "end": 2190.46 + }, + { + "word": "have", + "start": 2190.46, + "end": 2190.56 + }, + { + "word": "to", + "start": 2190.56, + "end": 2190.74 + }, + { + "word": "patch", + "start": 2190.74, + "end": 2190.9 + }, + { + "word": "and", + "start": 2190.9, + "end": 2191.06 + }, + { + "word": "things", + "start": 2191.06, + "end": 2191.2 + }, + { + "word": "like", + "start": 2191.2, + "end": 2191.44 + }, + { + "word": "that?", + "start": 2191.44, + "end": 2191.72 + }, + { + "word": "I", + "start": 2191.98, + "end": 2192.06 + }, + { + "word": "think", + "start": 2192.06, + "end": 2192.16 + }, + { + "word": "a", + "start": 2192.16, + "end": 2192.34 + }, + { + "word": "really", + "start": 2192.34, + "end": 2192.52 + }, + { + "word": "good", + "start": 2192.52, + "end": 2192.7 + }, + { + "word": "example", + "start": 2192.7, + "end": 2193.24 + }, + { + "word": "of", + "start": 2193.24, + "end": 2193.48 + }, + { + "word": "this", + "start": 2193.48, + "end": 2193.78 + }, + { + "word": "is", + "start": 2193.78, + "end": 2194.02 + }, + { + "word": "so", + "start": 2194.02, + "end": 2194.32 + } + ] + }, + { + "start": 2194.32, + "end": 2201.62, + "text": "Oxide generates their CLI as well as the SDK. So if you go to their Oxide.rs repo,", + "words": [ + { + "word": "Oxide", + "start": 2194.32, + "end": 2194.68 + }, + { + "word": "generates", + "start": 2194.68, + "end": 2195.3 + }, + { + "word": "their", + "start": 2195.3, + "end": 2196.56 + }, + { + "word": "CLI", + "start": 2196.56, + "end": 2197.38 + }, + { + "word": "as", + "start": 2197.38, + "end": 2197.74 + }, + { + "word": "well", + "start": 2197.74, + "end": 2197.9 + }, + { + "word": "as", + "start": 2197.9, + "end": 2198.06 + }, + { + "word": "the", + "start": 2198.06, + "end": 2198.22 + }, + { + "word": "SDK.", + "start": 2198.22, + "end": 2198.4 + }, + { + "word": "So", + "start": 2198.54, + "end": 2198.66 + }, + { + "word": "if", + "start": 2198.66, + "end": 2198.76 + }, + { + "word": "you", + "start": 2198.76, + "end": 2198.86 + }, + { + "word": "go", + "start": 2198.86, + "end": 2199.04 + }, + { + "word": "to", + "start": 2199.04, + "end": 2199.64 + }, + { + "word": "their", + "start": 2199.64, + "end": 2199.94 + }, + { + "word": "Oxide", + "start": 2199.94, + "end": 2200.34 + }, + { + "word": ".rs", + "start": 2200.34, + "end": 2200.94 + }, + { + "word": "repo,", + "start": 2200.94, + "end": 2201.62 + } + ] + }, + { + "start": 2201.8, + "end": 2205.62, + "text": "you'll see that they have the SDK and the CLI in there together, but they don't generate the", + "words": [ + { + "word": "you'll", + "start": 2201.8, + "end": 2202.1 + }, + { + "word": "see", + "start": 2202.1, + "end": 2202.24 + }, + { + "word": "that", + "start": 2202.24, + "end": 2202.38 + }, + { + "word": "they", + "start": 2202.38, + "end": 2202.46 + }, + { + "word": "have", + "start": 2202.46, + "end": 2202.58 + }, + { + "word": "the", + "start": 2202.58, + "end": 2202.74 + }, + { + "word": "SDK", + "start": 2202.74, + "end": 2203.0 + }, + { + "word": "and", + "start": 2203.0, + "end": 2203.28 + }, + { + "word": "the", + "start": 2203.28, + "end": 2203.44 + }, + { + "word": "CLI", + "start": 2203.44, + "end": 2203.68 + }, + { + "word": "in", + "start": 2203.68, + "end": 2203.8 + }, + { + "word": "there", + "start": 2203.8, + "end": 2203.96 + }, + { + "word": "together,", + "start": 2203.96, + "end": 2204.26 + }, + { + "word": "but", + "start": 2204.26, + "end": 2204.7 + }, + { + "word": "they", + "start": 2204.7, + "end": 2204.86 + }, + { + "word": "don't", + "start": 2204.86, + "end": 2205.04 + }, + { + "word": "generate", + "start": 2205.04, + "end": 2205.34 + }, + { + "word": "the", + "start": 2205.34, + "end": 2205.62 + } + ] + }, + { + "start": 2205.62, + "end": 2210.46, + "text": "entire CLI. They generate as much as they can and they just like bail out for like certain", + "words": [ + { + "word": "entire", + "start": 2205.62, + "end": 2205.92 + }, + { + "word": "CLI.", + "start": 2205.92, + "end": 2206.4 + }, + { + "word": "They", + "start": 2206.54, + "end": 2206.56 + }, + { + "word": "generate", + "start": 2206.56, + "end": 2206.82 + }, + { + "word": "as", + "start": 2206.82, + "end": 2207.0 + }, + { + "word": "much", + "start": 2207.0, + "end": 2207.12 + }, + { + "word": "as", + "start": 2207.12, + "end": 2207.26 + }, + { + "word": "they", + "start": 2207.26, + "end": 2207.4 + }, + { + "word": "can", + "start": 2207.4, + "end": 2207.7 + }, + { + "word": "and", + "start": 2207.7, + "end": 2208.0 + }, + { + "word": "they", + "start": 2208.0, + "end": 2208.18 + }, + { + "word": "just", + "start": 2208.18, + "end": 2208.46 + }, + { + "word": "like", + "start": 2208.46, + "end": 2208.52 + }, + { + "word": "bail", + "start": 2208.52, + "end": 2208.64 + }, + { + "word": "out", + "start": 2208.64, + "end": 2209.2 + }, + { + "word": "for", + "start": 2209.2, + "end": 2210.06 + }, + { + "word": "like", + "start": 2210.06, + "end": 2210.26 + }, + { + "word": "certain", + "start": 2210.26, + "end": 2210.46 + } + ] + }, + { + "start": 2210.46, + "end": 2215.48, + "text": "commands that just have custom logic that can't be generated. And I think that it's okay to have", + "words": [ + { + "word": "commands", + "start": 2210.46, + "end": 2210.86 + }, + { + "word": "that", + "start": 2210.86, + "end": 2211.06 + }, + { + "word": "just", + "start": 2211.06, + "end": 2211.2 + }, + { + "word": "have", + "start": 2211.2, + "end": 2211.34 + }, + { + "word": "custom", + "start": 2211.34, + "end": 2211.62 + }, + { + "word": "logic", + "start": 2211.62, + "end": 2211.9 + }, + { + "word": "that", + "start": 2211.9, + "end": 2212.1 + }, + { + "word": "can't", + "start": 2212.1, + "end": 2212.3 + }, + { + "word": "be", + "start": 2212.3, + "end": 2212.44 + }, + { + "word": "generated.", + "start": 2212.44, + "end": 2212.86 + }, + { + "word": "And", + "start": 2213.4, + "end": 2213.9 + }, + { + "word": "I", + "start": 2213.9, + "end": 2214.1 + }, + { + "word": "think", + "start": 2214.1, + "end": 2214.28 + }, + { + "word": "that", + "start": 2214.28, + "end": 2214.44 + }, + { + "word": "it's", + "start": 2214.44, + "end": 2214.62 + }, + { + "word": "okay", + "start": 2214.62, + "end": 2215.0 + }, + { + "word": "to", + "start": 2215.0, + "end": 2215.28 + }, + { + "word": "have", + "start": 2215.28, + "end": 2215.48 + } + ] + }, + { + "start": 2215.48, + "end": 2221.04, + "text": "just like explicit places where you bail out so long as when you're doing an update to the source", + "words": [ + { + "word": "just", + "start": 2215.48, + "end": 2215.62 + }, + { + "word": "like", + "start": 2215.62, + "end": 2215.84 + }, + { + "word": "explicit", + "start": 2215.84, + "end": 2216.28 + }, + { + "word": "places", + "start": 2216.28, + "end": 2216.74 + }, + { + "word": "where", + "start": 2216.74, + "end": 2217.0 + }, + { + "word": "you", + "start": 2217.0, + "end": 2217.18 + }, + { + "word": "bail", + "start": 2217.18, + "end": 2217.34 + }, + { + "word": "out", + "start": 2217.34, + "end": 2217.66 + }, + { + "word": "so", + "start": 2217.66, + "end": 2217.96 + }, + { + "word": "long", + "start": 2217.96, + "end": 2218.24 + }, + { + "word": "as", + "start": 2218.24, + "end": 2218.56 + }, + { + "word": "when", + "start": 2218.56, + "end": 2218.68 + }, + { + "word": "you're", + "start": 2218.68, + "end": 2218.9 + }, + { + "word": "doing", + "start": 2218.9, + "end": 2219.12 + }, + { + "word": "an", + "start": 2219.12, + "end": 2219.36 + }, + { + "word": "update", + "start": 2219.36, + "end": 2219.8 + }, + { + "word": "to", + "start": 2219.8, + "end": 2220.5 + }, + { + "word": "the", + "start": 2220.5, + "end": 2220.76 + }, + { + "word": "source", + "start": 2220.76, + "end": 2221.04 + } + ] + }, + { + "start": 2221.04, + "end": 2226.2, + "text": "that like flows down that you have explicit points where like, okay, you must update this code or", + "words": [ + { + "word": "that", + "start": 2221.04, + "end": 2221.24 + }, + { + "word": "like", + "start": 2221.24, + "end": 2221.46 + }, + { + "word": "flows", + "start": 2221.46, + "end": 2221.68 + }, + { + "word": "down", + "start": 2221.68, + "end": 2222.18 + }, + { + "word": "that", + "start": 2222.18, + "end": 2222.6 + }, + { + "word": "you", + "start": 2222.6, + "end": 2222.76 + }, + { + "word": "have", + "start": 2222.76, + "end": 2222.88 + }, + { + "word": "explicit", + "start": 2222.88, + "end": 2223.42 + }, + { + "word": "points", + "start": 2223.42, + "end": 2223.8 + }, + { + "word": "where", + "start": 2223.8, + "end": 2223.98 + }, + { + "word": "like,", + "start": 2223.98, + "end": 2224.14 + }, + { + "word": "okay,", + "start": 2224.28, + "end": 2224.36 + }, + { + "word": "you", + "start": 2224.36, + "end": 2224.62 + }, + { + "word": "must", + "start": 2224.62, + "end": 2224.9 + }, + { + "word": "update", + "start": 2224.9, + "end": 2225.2 + }, + { + "word": "this", + "start": 2225.2, + "end": 2225.48 + }, + { + "word": "code", + "start": 2225.48, + "end": 2225.86 + }, + { + "word": "or", + "start": 2225.86, + "end": 2226.2 + } + ] + }, + { + "start": 2226.2, + "end": 2231.86, + "text": "this will not work. So long as you can keep the interfaces safe for iteration upstream. And that's", + "words": [ + { + "word": "this", + "start": 2226.2, + "end": 2226.38 + }, + { + "word": "will", + "start": 2226.38, + "end": 2226.56 + }, + { + "word": "not", + "start": 2226.56, + "end": 2226.76 + }, + { + "word": "work.", + "start": 2226.76, + "end": 2227.22 + }, + { + "word": "So", + "start": 2227.22, + "end": 2227.7 + }, + { + "word": "long", + "start": 2227.7, + "end": 2227.86 + }, + { + "word": "as", + "start": 2227.86, + "end": 2227.94 + }, + { + "word": "you", + "start": 2227.94, + "end": 2228.04 + }, + { + "word": "can", + "start": 2228.04, + "end": 2228.26 + }, + { + "word": "keep", + "start": 2228.26, + "end": 2228.58 + }, + { + "word": "the", + "start": 2228.58, + "end": 2228.84 + }, + { + "word": "interfaces", + "start": 2228.84, + "end": 2229.18 + }, + { + "word": "safe", + "start": 2229.18, + "end": 2229.56 + }, + { + "word": "for", + "start": 2229.56, + "end": 2229.82 + }, + { + "word": "iteration", + "start": 2229.82, + "end": 2230.14 + }, + { + "word": "upstream.", + "start": 2230.14, + "end": 2230.68 + }, + { + "word": "And", + "start": 2231.24, + "end": 2231.38 + }, + { + "word": "that's", + "start": 2231.38, + "end": 2231.86 + } + ] + }, + { + "start": 2231.86, + "end": 2237.02, + "text": "the real key to this because if you can't rely on the fact that like when you change something", + "words": [ + { + "word": "the", + "start": 2231.86, + "end": 2232.16 + }, + { + "word": "real", + "start": 2232.16, + "end": 2232.46 + }, + { + "word": "key", + "start": 2232.46, + "end": 2232.68 + }, + { + "word": "to", + "start": 2232.68, + "end": 2232.88 + }, + { + "word": "this", + "start": 2232.88, + "end": 2233.1 + }, + { + "word": "because", + "start": 2233.1, + "end": 2233.6 + }, + { + "word": "if", + "start": 2233.6, + "end": 2234.08 + }, + { + "word": "you", + "start": 2234.08, + "end": 2234.22 + }, + { + "word": "can't", + "start": 2234.22, + "end": 2234.54 + }, + { + "word": "rely", + "start": 2234.54, + "end": 2234.92 + }, + { + "word": "on", + "start": 2234.92, + "end": 2235.5 + }, + { + "word": "the", + "start": 2235.5, + "end": 2235.72 + }, + { + "word": "fact", + "start": 2235.72, + "end": 2235.92 + }, + { + "word": "that", + "start": 2235.92, + "end": 2236.12 + }, + { + "word": "like", + "start": 2236.12, + "end": 2236.3 + }, + { + "word": "when", + "start": 2236.3, + "end": 2236.38 + }, + { + "word": "you", + "start": 2236.38, + "end": 2236.58 + }, + { + "word": "change", + "start": 2236.58, + "end": 2236.7 + }, + { + "word": "something", + "start": 2236.7, + "end": 2237.02 + } + ] + }, + { + "start": 2237.02, + "end": 2242.14, + "text": "upstream, all the consumers of this will be updated. You don't have a good cogen system", + "words": [ + { + "word": "upstream,", + "start": 2237.02, + "end": 2237.44 + }, + { + "word": "all", + "start": 2237.74, + "end": 2238.16 + }, + { + "word": "the", + "start": 2238.16, + "end": 2238.78 + }, + { + "word": "consumers", + "start": 2238.78, + "end": 2239.16 + }, + { + "word": "of", + "start": 2239.16, + "end": 2239.32 + }, + { + "word": "this", + "start": 2239.32, + "end": 2239.46 + }, + { + "word": "will", + "start": 2239.46, + "end": 2239.6 + }, + { + "word": "be", + "start": 2239.6, + "end": 2239.78 + }, + { + "word": "updated.", + "start": 2239.78, + "end": 2240.16 + }, + { + "word": "You", + "start": 2240.6, + "end": 2240.88 + }, + { + "word": "don't", + "start": 2240.88, + "end": 2241.1 + }, + { + "word": "have", + "start": 2241.1, + "end": 2241.24 + }, + { + "word": "a", + "start": 2241.24, + "end": 2241.36 + }, + { + "word": "good", + "start": 2241.36, + "end": 2241.54 + }, + { + "word": "cogen", + "start": 2241.54, + "end": 2241.8 + }, + { + "word": "system", + "start": 2241.8, + "end": 2242.14 + } + ] + }, + { + "start": 2242.14, + "end": 2247.0, + "text": "and you shouldn't be doing this because that's like a fundamental requirement of like this being", + "words": [ + { + "word": "and", + "start": 2242.14, + "end": 2242.28 + }, + { + "word": "you", + "start": 2242.28, + "end": 2242.5 + }, + { + "word": "shouldn't", + "start": 2242.5, + "end": 2242.62 + }, + { + "word": "be", + "start": 2242.62, + "end": 2242.82 + }, + { + "word": "doing", + "start": 2242.82, + "end": 2242.96 + }, + { + "word": "this", + "start": 2242.96, + "end": 2243.56 + }, + { + "word": "because", + "start": 2243.56, + "end": 2243.92 + }, + { + "word": "that's", + "start": 2243.92, + "end": 2244.12 + }, + { + "word": "like", + "start": 2244.12, + "end": 2244.3 + }, + { + "word": "a", + "start": 2244.3, + "end": 2244.52 + }, + { + "word": "fundamental", + "start": 2244.52, + "end": 2245.14 + }, + { + "word": "requirement", + "start": 2245.14, + "end": 2245.98 + }, + { + "word": "of", + "start": 2245.98, + "end": 2246.34 + }, + { + "word": "like", + "start": 2246.34, + "end": 2246.54 + }, + { + "word": "this", + "start": 2246.54, + "end": 2246.7 + }, + { + "word": "being", + "start": 2246.7, + "end": 2247.0 + } + ] + }, + { + "start": 2255.6, + "end": 2260.84, + "text": "useful. So it's a little bit in the same spirit. You mentioned that you've built for TypeScript", + "words": [ + { + "word": "useful.", + "start": 2255.6, + "end": 2256.04 + }, + { + "word": "So", + "start": 2256.04, + "end": 2256.48 + }, + { + "word": "it's", + "start": 2256.48, + "end": 2256.64 + }, + { + "word": "a", + "start": 2256.64, + "end": 2256.74 + }, + { + "word": "little", + "start": 2256.74, + "end": 2256.84 + }, + { + "word": "bit", + "start": 2256.84, + "end": 2256.96 + }, + { + "word": "in", + "start": 2256.96, + "end": 2257.22 + }, + { + "word": "the", + "start": 2257.22, + "end": 2257.22 + }, + { + "word": "same", + "start": 2257.22, + "end": 2257.6 + }, + { + "word": "spirit.", + "start": 2257.6, + "end": 2258.06 + }, + { + "word": "You", + "start": 2258.62, + "end": 2258.84 + }, + { + "word": "mentioned", + "start": 2258.84, + "end": 2259.14 + }, + { + "word": "that", + "start": 2259.14, + "end": 2259.36 + }, + { + "word": "you've", + "start": 2259.36, + "end": 2259.78 + }, + { + "word": "built", + "start": 2259.78, + "end": 2259.96 + }, + { + "word": "for", + "start": 2259.96, + "end": 2260.4 + }, + { + "word": "TypeScript", + "start": 2260.4, + "end": 2260.84 + } + ] + }, + { + "start": 2260.84, + "end": 2265.48, + "text": "and Python. Was there any particular war stories you have to tell about like each of them? Like,", + "words": [ + { + "word": "and", + "start": 2260.84, + "end": 2261.02 + }, + { + "word": "Python.", + "start": 2261.02, + "end": 2261.4 + }, + { + "word": "Was", + "start": 2261.94, + "end": 2262.04 + }, + { + "word": "there", + "start": 2262.04, + "end": 2262.48 + }, + { + "word": "any", + "start": 2262.48, + "end": 2262.7 + }, + { + "word": "particular", + "start": 2262.7, + "end": 2263.06 + }, + { + "word": "war", + "start": 2263.06, + "end": 2263.32 + }, + { + "word": "stories", + "start": 2263.32, + "end": 2263.6 + }, + { + "word": "you", + "start": 2263.6, + "end": 2263.74 + }, + { + "word": "have", + "start": 2263.74, + "end": 2263.88 + }, + { + "word": "to", + "start": 2263.88, + "end": 2264.06 + }, + { + "word": "tell", + "start": 2264.06, + "end": 2264.2 + }, + { + "word": "about", + "start": 2264.2, + "end": 2264.46 + }, + { + "word": "like", + "start": 2264.46, + "end": 2264.86 + }, + { + "word": "each", + "start": 2264.86, + "end": 2265.06 + }, + { + "word": "of", + "start": 2265.06, + "end": 2265.2 + }, + { + "word": "them?", + "start": 2265.2, + "end": 2265.3 + }, + { + "word": "Like,", + "start": 2265.32, + "end": 2265.48 + } + ] + }, + { + "start": 2265.52, + "end": 2270.56, + "text": "was there any specifically harder than the other or is it like Python has like some very specific", + "words": [ + { + "word": "was", + "start": 2265.52, + "end": 2265.6 + }, + { + "word": "there", + "start": 2265.6, + "end": 2265.72 + }, + { + "word": "any", + "start": 2265.72, + "end": 2266.46 + }, + { + "word": "specifically", + "start": 2266.46, + "end": 2267.24 + }, + { + "word": "harder", + "start": 2267.24, + "end": 2267.68 + }, + { + "word": "than", + "start": 2267.68, + "end": 2267.88 + }, + { + "word": "the", + "start": 2267.88, + "end": 2268.06 + }, + { + "word": "other", + "start": 2268.06, + "end": 2268.3 + }, + { + "word": "or", + "start": 2268.3, + "end": 2268.66 + }, + { + "word": "is", + "start": 2268.66, + "end": 2268.82 + }, + { + "word": "it", + "start": 2268.82, + "end": 2268.92 + }, + { + "word": "like", + "start": 2268.92, + "end": 2269.1 + }, + { + "word": "Python", + "start": 2269.1, + "end": 2269.38 + }, + { + "word": "has", + "start": 2269.38, + "end": 2269.56 + }, + { + "word": "like", + "start": 2269.56, + "end": 2269.72 + }, + { + "word": "some", + "start": 2269.72, + "end": 2269.88 + }, + { + "word": "very", + "start": 2269.88, + "end": 2270.12 + }, + { + "word": "specific", + "start": 2270.12, + "end": 2270.56 + } + ] + }, + { + "start": 2270.56, + "end": 2278.02, + "text": "things that makes it difficult and then TypeScript and other areas have its own like complications?", + "words": [ + { + "word": "things", + "start": 2270.56, + "end": 2270.88 + }, + { + "word": "that", + "start": 2270.88, + "end": 2271.6 + }, + { + "word": "makes", + "start": 2271.6, + "end": 2272.0 + }, + { + "word": "it", + "start": 2272.0, + "end": 2272.66 + }, + { + "word": "difficult", + "start": 2272.66, + "end": 2273.2 + }, + { + "word": "and", + "start": 2273.2, + "end": 2273.48 + }, + { + "word": "then", + "start": 2273.48, + "end": 2273.9 + }, + { + "word": "TypeScript", + "start": 2273.9, + "end": 2274.28 + }, + { + "word": "and", + "start": 2274.28, + "end": 2274.76 + }, + { + "word": "other", + "start": 2274.76, + "end": 2275.02 + }, + { + "word": "areas", + "start": 2275.02, + "end": 2275.44 + }, + { + "word": "have", + "start": 2275.44, + "end": 2276.16 + }, + { + "word": "its", + "start": 2276.16, + "end": 2276.58 + }, + { + "word": "own", + "start": 2276.58, + "end": 2276.94 + }, + { + "word": "like", + "start": 2276.94, + "end": 2277.6 + }, + { + "word": "complications?", + "start": 2277.6, + "end": 2278.02 + } + ] + }, + { + "start": 2278.32, + "end": 2282.44, + "text": "Yeah, that's a really good question. I've been doing TypeScript for a long time. So TypeScript", + "words": [ + { + "word": "Yeah,", + "start": 2278.32, + "end": 2278.66 + }, + { + "word": "that's", + "start": 2278.66, + "end": 2278.84 + }, + { + "word": "a", + "start": 2278.84, + "end": 2278.94 + }, + { + "word": "really", + "start": 2278.94, + "end": 2279.04 + }, + { + "word": "good", + "start": 2279.04, + "end": 2279.16 + }, + { + "word": "question.", + "start": 2279.16, + "end": 2279.52 + }, + { + "word": "I've", + "start": 2279.64, + "end": 2279.86 + }, + { + "word": "been", + "start": 2279.86, + "end": 2279.98 + }, + { + "word": "doing", + "start": 2279.98, + "end": 2280.34 + }, + { + "word": "TypeScript", + "start": 2280.34, + "end": 2280.7 + }, + { + "word": "for", + "start": 2280.7, + "end": 2280.88 + }, + { + "word": "a", + "start": 2280.88, + "end": 2280.94 + }, + { + "word": "long", + "start": 2280.94, + "end": 2281.14 + }, + { + "word": "time.", + "start": 2281.14, + "end": 2281.58 + }, + { + "word": "So", + "start": 2281.78, + "end": 2282.12 + }, + { + "word": "TypeScript", + "start": 2282.12, + "end": 2282.44 + } + ] + }, + { + "start": 2282.44, + "end": 2287.94, + "text": "was pretty simple for me. I will say that there are like some things that I did with the generation", + "words": [ + { + "word": "was", + "start": 2282.44, + "end": 2282.6 + }, + { + "word": "pretty", + "start": 2282.6, + "end": 2282.9 + }, + { + "word": "simple", + "start": 2282.9, + "end": 2283.44 + }, + { + "word": "for", + "start": 2283.44, + "end": 2283.7 + }, + { + "word": "me.", + "start": 2283.7, + "end": 2284.18 + }, + { + "word": "I", + "start": 2284.96, + "end": 2285.26 + }, + { + "word": "will", + "start": 2285.26, + "end": 2285.52 + }, + { + "word": "say", + "start": 2285.52, + "end": 2285.76 + }, + { + "word": "that", + "start": 2285.76, + "end": 2285.88 + }, + { + "word": "there", + "start": 2285.88, + "end": 2286.18 + }, + { + "word": "are", + "start": 2286.18, + "end": 2286.38 + }, + { + "word": "like", + "start": 2286.38, + "end": 2286.54 + }, + { + "word": "some", + "start": 2286.54, + "end": 2286.74 + }, + { + "word": "things", + "start": 2286.74, + "end": 2286.92 + }, + { + "word": "that", + "start": 2286.92, + "end": 2287.08 + }, + { + "word": "I", + "start": 2287.08, + "end": 2287.18 + }, + { + "word": "did", + "start": 2287.18, + "end": 2287.28 + }, + { + "word": "with", + "start": 2287.28, + "end": 2287.42 + }, + { + "word": "the", + "start": 2287.42, + "end": 2287.56 + }, + { + "word": "generation", + "start": 2287.56, + "end": 2287.94 + } + ] + }, + { + "start": 2287.94, + "end": 2293.82, + "text": "that are a little special maybe. So the schemas.ts file here is the whole thing that's generated.", + "words": [ + { + "word": "that", + "start": 2287.94, + "end": 2288.14 + }, + { + "word": "are", + "start": 2288.14, + "end": 2288.28 + }, + { + "word": "a", + "start": 2288.28, + "end": 2288.52 + }, + { + "word": "little", + "start": 2288.52, + "end": 2288.98 + }, + { + "word": "special", + "start": 2288.98, + "end": 2290.7 + }, + { + "word": "maybe.", + "start": 2290.7, + "end": 2291.26 + }, + { + "word": "So", + "start": 2291.4, + "end": 2291.44 + }, + { + "word": "the", + "start": 2291.44, + "end": 2291.66 + }, + { + "word": "schemas", + "start": 2291.66, + "end": 2291.96 + }, + { + "word": ".ts", + "start": 2291.96, + "end": 2292.38 + }, + { + "word": "file", + "start": 2292.38, + "end": 2292.66 + }, + { + "word": "here", + "start": 2292.66, + "end": 2292.84 + }, + { + "word": "is", + "start": 2292.84, + "end": 2292.96 + }, + { + "word": "the", + "start": 2292.96, + "end": 2293.02 + }, + { + "word": "whole", + "start": 2293.02, + "end": 2293.22 + }, + { + "word": "thing", + "start": 2293.22, + "end": 2293.32 + }, + { + "word": "that's", + "start": 2293.32, + "end": 2293.54 + }, + { + "word": "generated.", + "start": 2293.54, + "end": 2293.82 + } + ] + }, + { + "start": 2294.9, + "end": 2299.64, + "text": "So on the top of the file, I have like all the TypeScript types that are generated. And then on", + "words": [ + { + "word": "So", + "start": 2294.9, + "end": 2295.26 + }, + { + "word": "on", + "start": 2295.26, + "end": 2295.5 + }, + { + "word": "the", + "start": 2295.5, + "end": 2295.62 + }, + { + "word": "top", + "start": 2295.62, + "end": 2295.74 + }, + { + "word": "of", + "start": 2295.74, + "end": 2295.86 + }, + { + "word": "the", + "start": 2295.86, + "end": 2296.0 + }, + { + "word": "file,", + "start": 2296.0, + "end": 2296.24 + }, + { + "word": "I", + "start": 2296.24, + "end": 2296.46 + }, + { + "word": "have", + "start": 2296.46, + "end": 2296.76 + }, + { + "word": "like", + "start": 2296.76, + "end": 2297.04 + }, + { + "word": "all", + "start": 2297.04, + "end": 2297.22 + }, + { + "word": "the", + "start": 2297.22, + "end": 2297.56 + }, + { + "word": "TypeScript", + "start": 2297.56, + "end": 2297.9 + }, + { + "word": "types", + "start": 2297.9, + "end": 2298.22 + }, + { + "word": "that", + "start": 2298.22, + "end": 2298.36 + }, + { + "word": "are", + "start": 2298.36, + "end": 2298.5 + }, + { + "word": "generated.", + "start": 2298.5, + "end": 2298.98 + }, + { + "word": "And", + "start": 2299.32, + "end": 2299.44 + }, + { + "word": "then", + "start": 2299.44, + "end": 2299.54 + }, + { + "word": "on", + "start": 2299.54, + "end": 2299.64 + } + ] + }, + { + "start": 2299.64, + "end": 2306.18, + "text": "the bottom, I have these like Zod like validators. You can invert types from Zod, but like doing that", + "words": [ + { + "word": "the", + "start": 2299.64, + "end": 2299.84 + }, + { + "word": "bottom,", + "start": 2299.84, + "end": 2300.1 + }, + { + "word": "I", + "start": 2300.24, + "end": 2300.46 + }, + { + "word": "have", + "start": 2300.46, + "end": 2300.92 + }, + { + "word": "these", + "start": 2300.92, + "end": 2301.52 + }, + { + "word": "like", + "start": 2301.52, + "end": 2301.66 + }, + { + "word": "Zod", + "start": 2301.66, + "end": 2301.94 + }, + { + "word": "like", + "start": 2301.94, + "end": 2302.5 + }, + { + "word": "validators.", + "start": 2302.5, + "end": 2303.06 + }, + { + "word": "You", + "start": 2303.7, + "end": 2303.86 + }, + { + "word": "can", + "start": 2303.86, + "end": 2304.04 + }, + { + "word": "invert", + "start": 2304.04, + "end": 2304.36 + }, + { + "word": "types", + "start": 2304.36, + "end": 2304.68 + }, + { + "word": "from", + "start": 2304.68, + "end": 2304.9 + }, + { + "word": "Zod,", + "start": 2304.9, + "end": 2305.24 + }, + { + "word": "but", + "start": 2305.38, + "end": 2305.48 + }, + { + "word": "like", + "start": 2305.48, + "end": 2305.88 + }, + { + "word": "doing", + "start": 2305.88, + "end": 2306.06 + }, + { + "word": "that", + "start": 2306.06, + "end": 2306.28 + } + ] + }, + { + "start": 2306.92, + "end": 2312.92, + "text": "before Zod before, which I haven't tested the performance of type inference goes way, way down.", + "words": [ + { + "word": "before", + "start": 2306.92, + "end": 2307.36 + }, + { + "word": "Zod", + "start": 2307.36, + "end": 2307.8 + }, + { + "word": "before,", + "start": 2307.8, + "end": 2308.14 + }, + { + "word": "which", + "start": 2308.22, + "end": 2308.34 + }, + { + "word": "I", + "start": 2308.34, + "end": 2308.48 + }, + { + "word": "haven't", + "start": 2308.48, + "end": 2308.6 + }, + { + "word": "tested", + "start": 2308.6, + "end": 2309.04 + }, + { + "word": "the", + "start": 2309.04, + "end": 2309.64 + }, + { + "word": "performance", + "start": 2309.64, + "end": 2310.32 + }, + { + "word": "of", + "start": 2310.32, + "end": 2311.14 + }, + { + "word": "type", + "start": 2311.14, + "end": 2311.34 + }, + { + "word": "inference", + "start": 2311.34, + "end": 2311.72 + }, + { + "word": "goes", + "start": 2311.72, + "end": 2312.06 + }, + { + "word": "way,", + "start": 2312.06, + "end": 2312.4 + }, + { + "word": "way", + "start": 2312.42, + "end": 2312.54 + }, + { + "word": "down.", + "start": 2312.54, + "end": 2312.92 + } + ] + }, + { + "start": 2312.98, + "end": 2316.32, + "text": "So that was like a thing that bit me is like, oh, I actually just need to generate the TypeScript", + "words": [ + { + "word": "So", + "start": 2312.98, + "end": 2313.12 + }, + { + "word": "that", + "start": 2313.12, + "end": 2313.24 + }, + { + "word": "was", + "start": 2313.24, + "end": 2313.36 + }, + { + "word": "like", + "start": 2313.36, + "end": 2313.52 + }, + { + "word": "a", + "start": 2313.52, + "end": 2313.64 + }, + { + "word": "thing", + "start": 2313.64, + "end": 2313.76 + }, + { + "word": "that", + "start": 2313.76, + "end": 2313.98 + }, + { + "word": "bit", + "start": 2313.98, + "end": 2314.06 + }, + { + "word": "me", + "start": 2314.06, + "end": 2314.28 + }, + { + "word": "is", + "start": 2314.28, + "end": 2314.38 + }, + { + "word": "like,", + "start": 2314.38, + "end": 2314.52 + }, + { + "word": "oh,", + "start": 2314.52, + "end": 2314.82 + }, + { + "word": "I", + "start": 2314.82, + "end": 2315.04 + }, + { + "word": "actually", + "start": 2315.04, + "end": 2315.18 + }, + { + "word": "just", + "start": 2315.18, + "end": 2315.4 + }, + { + "word": "need", + "start": 2315.4, + "end": 2315.48 + }, + { + "word": "to", + "start": 2315.48, + "end": 2315.66 + }, + { + "word": "generate", + "start": 2315.66, + "end": 2315.84 + }, + { + "word": "the", + "start": 2315.84, + "end": 2316.04 + }, + { + "word": "TypeScript", + "start": 2316.04, + "end": 2316.32 + } + ] + }, + { + "start": 2316.32, + "end": 2324.0, + "text": "separately. And for Python, it's the fact that it doesn't easily support intersections. Like,", + "words": [ + { + "word": "separately.", + "start": 2316.32, + "end": 2316.64 + }, + { + "word": "And", + "start": 2317.36, + "end": 2317.8 + }, + { + "word": "for", + "start": 2317.8, + "end": 2318.04 + }, + { + "word": "Python,", + "start": 2318.04, + "end": 2318.52 + }, + { + "word": "it's", + "start": 2318.92, + "end": 2319.14 + }, + { + "word": "the", + "start": 2319.14, + "end": 2319.32 + }, + { + "word": "fact", + "start": 2319.32, + "end": 2319.44 + }, + { + "word": "that", + "start": 2319.44, + "end": 2319.64 + }, + { + "word": "it", + "start": 2319.64, + "end": 2320.08 + }, + { + "word": "doesn't", + "start": 2320.08, + "end": 2320.76 + }, + { + "word": "easily", + "start": 2320.76, + "end": 2321.38 + }, + { + "word": "support", + "start": 2321.38, + "end": 2322.08 + }, + { + "word": "intersections.", + "start": 2322.08, + "end": 2322.9 + }, + { + "word": "Like,", + "start": 2323.76, + "end": 2324.0 + } + ] + }, + { + "start": 2324.64, + "end": 2329.3, + "text": "I don't know how best to say that. That was that's like a hard constraint. It took a lot", + "words": [ + { + "word": "I", + "start": 2324.64, + "end": 2325.08 + }, + { + "word": "don't", + "start": 2325.08, + "end": 2325.36 + }, + { + "word": "know", + "start": 2325.36, + "end": 2325.68 + }, + { + "word": "how", + "start": 2325.68, + "end": 2326.04 + }, + { + "word": "best", + "start": 2326.04, + "end": 2326.22 + }, + { + "word": "to", + "start": 2326.22, + "end": 2326.42 + }, + { + "word": "say", + "start": 2326.42, + "end": 2326.56 + }, + { + "word": "that.", + "start": 2326.56, + "end": 2326.86 + }, + { + "word": "That", + "start": 2326.86, + "end": 2327.04 + }, + { + "word": "was", + "start": 2327.04, + "end": 2327.44 + }, + { + "word": "that's", + "start": 2327.44, + "end": 2327.62 + }, + { + "word": "like", + "start": 2327.62, + "end": 2327.82 + }, + { + "word": "a", + "start": 2327.82, + "end": 2328.06 + }, + { + "word": "hard", + "start": 2328.06, + "end": 2328.3 + }, + { + "word": "constraint.", + "start": 2328.3, + "end": 2328.72 + }, + { + "word": "It", + "start": 2328.88, + "end": 2328.9 + }, + { + "word": "took", + "start": 2328.9, + "end": 2329.02 + }, + { + "word": "a", + "start": 2329.02, + "end": 2329.24 + }, + { + "word": "lot", + "start": 2329.24, + "end": 2329.3 + } + ] + }, + { + "start": 2329.3, + "end": 2333.44, + "text": "of like deep thinking. It's like, how do I do this where it's not terrible? But I mean,", + "words": [ + { + "word": "of", + "start": 2329.3, + "end": 2329.54 + }, + { + "word": "like", + "start": 2329.54, + "end": 2329.68 + }, + { + "word": "deep", + "start": 2329.68, + "end": 2329.84 + }, + { + "word": "thinking.", + "start": 2329.84, + "end": 2330.1 + }, + { + "word": "It's", + "start": 2330.1, + "end": 2330.32 + }, + { + "word": "like,", + "start": 2330.32, + "end": 2330.48 + }, + { + "word": "how", + "start": 2330.76, + "end": 2330.88 + }, + { + "word": "do", + "start": 2330.88, + "end": 2331.0 + }, + { + "word": "I", + "start": 2331.0, + "end": 2331.08 + }, + { + "word": "do", + "start": 2331.08, + "end": 2331.2 + }, + { + "word": "this", + "start": 2331.2, + "end": 2331.44 + }, + { + "word": "where", + "start": 2331.44, + "end": 2331.58 + }, + { + "word": "it's", + "start": 2331.58, + "end": 2331.76 + }, + { + "word": "not", + "start": 2331.76, + "end": 2331.92 + }, + { + "word": "terrible?", + "start": 2331.92, + "end": 2332.4 + }, + { + "word": "But", + "start": 2332.94, + "end": 2333.1 + }, + { + "word": "I", + "start": 2333.1, + "end": 2333.16 + }, + { + "word": "mean,", + "start": 2333.16, + "end": 2333.44 + } + ] + }, + { + "start": 2333.68, + "end": 2340.48, + "text": "I think overall, like if I just jump into the package here, it like came out relatively simple.", + "words": [ + { + "word": "I", + "start": 2333.68, + "end": 2333.9 + }, + { + "word": "think", + "start": 2333.9, + "end": 2334.12 + }, + { + "word": "overall,", + "start": 2334.12, + "end": 2334.56 + }, + { + "word": "like", + "start": 2334.7, + "end": 2335.0 + }, + { + "word": "if", + "start": 2335.0, + "end": 2335.2 + }, + { + "word": "I", + "start": 2335.2, + "end": 2335.28 + }, + { + "word": "just", + "start": 2335.28, + "end": 2335.66 + }, + { + "word": "jump", + "start": 2335.66, + "end": 2335.8 + }, + { + "word": "into", + "start": 2335.8, + "end": 2335.96 + }, + { + "word": "the", + "start": 2335.96, + "end": 2336.14 + }, + { + "word": "package", + "start": 2336.14, + "end": 2336.38 + }, + { + "word": "here,", + "start": 2336.38, + "end": 2336.66 + }, + { + "word": "it", + "start": 2336.66, + "end": 2336.84 + }, + { + "word": "like", + "start": 2336.84, + "end": 2337.78 + }, + { + "word": "came", + "start": 2337.78, + "end": 2338.2 + }, + { + "word": "out", + "start": 2338.2, + "end": 2338.74 + }, + { + "word": "relatively", + "start": 2338.74, + "end": 2339.74 + }, + { + "word": "simple.", + "start": 2339.74, + "end": 2340.48 + } + ] + }, + { + "start": 2340.48, + "end": 2344.84, + "text": "I mean, you'll see the same sort of shapes repeated over and over again. There's just like a lot of", + "words": [ + { + "word": "I", + "start": 2340.48, + "end": 2340.68 + }, + { + "word": "mean,", + "start": 2340.68, + "end": 2340.96 + }, + { + "word": "you'll", + "start": 2340.96, + "end": 2341.32 + }, + { + "word": "see", + "start": 2341.32, + "end": 2341.44 + }, + { + "word": "the", + "start": 2341.44, + "end": 2341.7 + }, + { + "word": "same", + "start": 2341.7, + "end": 2341.92 + }, + { + "word": "sort", + "start": 2341.92, + "end": 2342.16 + }, + { + "word": "of", + "start": 2342.16, + "end": 2342.42 + }, + { + "word": "shapes", + "start": 2342.42, + "end": 2342.68 + }, + { + "word": "repeated", + "start": 2342.68, + "end": 2343.1 + }, + { + "word": "over", + "start": 2343.1, + "end": 2343.5 + }, + { + "word": "and", + "start": 2343.5, + "end": 2343.58 + }, + { + "word": "over", + "start": 2343.58, + "end": 2343.72 + }, + { + "word": "again.", + "start": 2343.72, + "end": 2343.88 + }, + { + "word": "There's", + "start": 2343.9, + "end": 2344.08 + }, + { + "word": "just", + "start": 2344.08, + "end": 2344.18 + }, + { + "word": "like", + "start": 2344.18, + "end": 2344.34 + }, + { + "word": "a", + "start": 2344.34, + "end": 2344.46 + }, + { + "word": "lot", + "start": 2344.46, + "end": 2344.64 + }, + { + "word": "of", + "start": 2344.64, + "end": 2344.84 + } + ] + }, + { + "start": 2344.84, + "end": 2353.78, + "text": "simple classes and unions. And I'm happy to have had the Python client because it actually made", + "words": [ + { + "word": "simple", + "start": 2344.84, + "end": 2345.32 + }, + { + "word": "classes", + "start": 2345.32, + "end": 2345.92 + }, + { + "word": "and", + "start": 2345.92, + "end": 2346.38 + }, + { + "word": "unions.", + "start": 2346.38, + "end": 2346.78 + }, + { + "word": "And", + "start": 2347.78, + "end": 2347.96 + }, + { + "word": "I'm", + "start": 2347.96, + "end": 2348.78 + }, + { + "word": "happy", + "start": 2348.78, + "end": 2349.2 + }, + { + "word": "to", + "start": 2349.2, + "end": 2349.54 + }, + { + "word": "have", + "start": 2349.54, + "end": 2349.76 + }, + { + "word": "had", + "start": 2349.76, + "end": 2350.58 + }, + { + "word": "the", + "start": 2350.58, + "end": 2351.9 + }, + { + "word": "Python", + "start": 2351.9, + "end": 2352.44 + }, + { + "word": "client", + "start": 2352.44, + "end": 2352.76 + }, + { + "word": "because", + "start": 2352.76, + "end": 2352.98 + }, + { + "word": "it", + "start": 2352.98, + "end": 2353.2 + }, + { + "word": "actually", + "start": 2353.2, + "end": 2353.54 + }, + { + "word": "made", + "start": 2353.54, + "end": 2353.78 + } + ] + }, + { + "start": 2353.78, + "end": 2358.58, + "text": "the implementation upstream significantly simpler. Whereas like TypeScript is just very expressive", + "words": [ + { + "word": "the", + "start": 2353.78, + "end": 2353.98 + }, + { + "word": "implementation", + "start": 2353.98, + "end": 2354.44 + }, + { + "word": "upstream", + "start": 2354.44, + "end": 2354.84 + }, + { + "word": "significantly", + "start": 2354.84, + "end": 2355.38 + }, + { + "word": "simpler.", + "start": 2355.38, + "end": 2355.98 + }, + { + "word": "Whereas", + "start": 2357.02, + "end": 2357.04 + }, + { + "word": "like", + "start": 2357.04, + "end": 2357.44 + }, + { + "word": "TypeScript", + "start": 2357.44, + "end": 2357.7 + }, + { + "word": "is", + "start": 2357.7, + "end": 2357.86 + }, + { + "word": "just", + "start": 2357.86, + "end": 2358.06 + }, + { + "word": "very", + "start": 2358.06, + "end": 2358.22 + }, + { + "word": "expressive", + "start": 2358.22, + "end": 2358.58 + } + ] + }, + { + "start": 2358.58, + "end": 2361.74, + "text": "and I could do whatever I want. I could do really complicated things and it's just like, yeah, cool,", + "words": [ + { + "word": "and", + "start": 2358.58, + "end": 2358.72 + }, + { + "word": "I", + "start": 2358.72, + "end": 2358.76 + }, + { + "word": "could", + "start": 2358.76, + "end": 2358.9 + }, + { + "word": "do", + "start": 2358.9, + "end": 2359.0 + }, + { + "word": "whatever", + "start": 2359.0, + "end": 2359.26 + }, + { + "word": "I", + "start": 2359.26, + "end": 2359.46 + }, + { + "word": "want.", + "start": 2359.46, + "end": 2359.54 + }, + { + "word": "I", + "start": 2359.62, + "end": 2359.62 + }, + { + "word": "could", + "start": 2359.62, + "end": 2359.76 + }, + { + "word": "do", + "start": 2359.76, + "end": 2359.92 + }, + { + "word": "really", + "start": 2359.92, + "end": 2360.18 + }, + { + "word": "complicated", + "start": 2360.18, + "end": 2360.62 + }, + { + "word": "things", + "start": 2360.62, + "end": 2360.88 + }, + { + "word": "and", + "start": 2360.88, + "end": 2361.0 + }, + { + "word": "it's", + "start": 2361.0, + "end": 2361.16 + }, + { + "word": "just", + "start": 2361.16, + "end": 2361.24 + }, + { + "word": "like,", + "start": 2361.24, + "end": 2361.36 + }, + { + "word": "yeah,", + "start": 2361.36, + "end": 2361.52 + }, + { + "word": "cool,", + "start": 2361.52, + "end": 2361.74 + } + ] + }, + { + "start": 2361.74, + "end": 2367.12, + "text": "fine. And it turns out like constraints can be good sometimes. So.", + "words": [ + { + "word": "fine.", + "start": 2361.74, + "end": 2362.08 + }, + { + "word": "And", + "start": 2363.26, + "end": 2363.42 + }, + { + "word": "it", + "start": 2363.42, + "end": 2363.48 + }, + { + "word": "turns", + "start": 2363.48, + "end": 2363.68 + }, + { + "word": "out", + "start": 2363.68, + "end": 2364.02 + }, + { + "word": "like", + "start": 2364.02, + "end": 2364.8 + }, + { + "word": "constraints", + "start": 2364.8, + "end": 2365.14 + }, + { + "word": "can", + "start": 2365.14, + "end": 2365.32 + }, + { + "word": "be", + "start": 2365.32, + "end": 2365.44 + }, + { + "word": "good", + "start": 2365.44, + "end": 2365.56 + }, + { + "word": "sometimes.", + "start": 2365.56, + "end": 2366.04 + }, + { + "word": "So.", + "start": 2366.86, + "end": 2367.12 + } + ] + }, + { + "start": 2370.46, + "end": 2376.78, + "text": "All right. We're good. No more questions. Anybody? Oh, we got one more. In 2025,", + "words": [ + { + "word": "All", + "start": 2370.46, + "end": 2370.96 + }, + { + "word": "right.", + "start": 2370.96, + "end": 2371.42 + }, + { + "word": "We're", + "start": 2371.86, + "end": 2372.1 + }, + { + "word": "good.", + "start": 2372.1, + "end": 2372.28 + }, + { + "word": "No", + "start": 2372.5, + "end": 2372.68 + }, + { + "word": "more", + "start": 2372.68, + "end": 2372.86 + }, + { + "word": "questions.", + "start": 2372.86, + "end": 2373.26 + }, + { + "word": "Anybody?", + "start": 2373.38, + "end": 2373.72 + }, + { + "word": "Oh,", + "start": 2374.12, + "end": 2374.44 + }, + { + "word": "we", + "start": 2374.84, + "end": 2375.0 + }, + { + "word": "got", + "start": 2375.0, + "end": 2375.08 + }, + { + "word": "one", + "start": 2375.08, + "end": 2375.26 + }, + { + "word": "more.", + "start": 2375.26, + "end": 2375.52 + }, + { + "word": "In", + "start": 2376.08, + "end": 2376.26 + }, + { + "word": "2025,", + "start": 2376.26, + "end": 2376.78 + } + ] + }, + { + "start": 2377.4, + "end": 2381.96, + "text": "what's the interface of choice for building code, doing code gen as an open API, GraphQL,", + "words": [ + { + "word": "what's", + "start": 2377.4, + "end": 2377.6 + }, + { + "word": "the", + "start": 2377.6, + "end": 2377.76 + }, + { + "word": "interface", + "start": 2377.76, + "end": 2378.08 + }, + { + "word": "of", + "start": 2378.08, + "end": 2378.38 + }, + { + "word": "choice", + "start": 2378.38, + "end": 2378.7 + }, + { + "word": "for", + "start": 2378.7, + "end": 2378.92 + }, + { + "word": "building", + "start": 2378.92, + "end": 2379.16 + }, + { + "word": "code,", + "start": 2379.16, + "end": 2379.42 + }, + { + "word": "doing", + "start": 2379.42, + "end": 2379.66 + }, + { + "word": "code", + "start": 2379.66, + "end": 2379.92 + }, + { + "word": "gen", + "start": 2379.92, + "end": 2380.06 + }, + { + "word": "as", + "start": 2380.06, + "end": 2380.28 + }, + { + "word": "an", + "start": 2380.28, + "end": 2380.44 + }, + { + "word": "open", + "start": 2380.44, + "end": 2380.58 + }, + { + "word": "API,", + "start": 2380.58, + "end": 2381.12 + }, + { + "word": "GraphQL,", + "start": 2381.44, + "end": 2381.96 + } + ] + }, + { + "start": 2382.9, + "end": 2389.86, + "text": "or protocols maybe or something I missed? That's a good question. I prefer generating code from code.", + "words": [ + { + "word": "or", + "start": 2382.9, + "end": 2383.1 + }, + { + "word": "protocols", + "start": 2383.1, + "end": 2383.46 + }, + { + "word": "maybe", + "start": 2383.46, + "end": 2383.9 + }, + { + "word": "or", + "start": 2383.9, + "end": 2384.14 + }, + { + "word": "something", + "start": 2384.14, + "end": 2384.36 + }, + { + "word": "I", + "start": 2384.36, + "end": 2384.56 + }, + { + "word": "missed?", + "start": 2384.56, + "end": 2384.78 + }, + { + "word": "That's", + "start": 2386.3, + "end": 2386.78 + }, + { + "word": "a", + "start": 2386.78, + "end": 2386.92 + }, + { + "word": "good", + "start": 2386.92, + "end": 2387.08 + }, + { + "word": "question.", + "start": 2387.08, + "end": 2387.72 + }, + { + "word": "I", + "start": 2387.92, + "end": 2388.42 + }, + { + "word": "prefer", + "start": 2388.42, + "end": 2388.8 + }, + { + "word": "generating", + "start": 2388.8, + "end": 2389.18 + }, + { + "word": "code", + "start": 2389.18, + "end": 2389.38 + }, + { + "word": "from", + "start": 2389.38, + "end": 2389.58 + }, + { + "word": "code.", + "start": 2389.58, + "end": 2389.86 + } + ] + }, + { + "start": 2391.06, + "end": 2395.8, + "text": "My like ideal interface is just like, give me some TypeScript types and let me generate stuff", + "words": [ + { + "word": "My", + "start": 2391.06, + "end": 2391.56 + }, + { + "word": "like", + "start": 2391.56, + "end": 2391.8 + }, + { + "word": "ideal", + "start": 2391.8, + "end": 2392.16 + }, + { + "word": "interface", + "start": 2392.16, + "end": 2392.68 + }, + { + "word": "is", + "start": 2392.68, + "end": 2392.88 + }, + { + "word": "just", + "start": 2392.88, + "end": 2393.02 + }, + { + "word": "like,", + "start": 2393.02, + "end": 2393.46 + }, + { + "word": "give", + "start": 2393.58, + "end": 2393.6 + }, + { + "word": "me", + "start": 2393.6, + "end": 2394.08 + }, + { + "word": "some", + "start": 2394.08, + "end": 2394.34 + }, + { + "word": "TypeScript", + "start": 2394.34, + "end": 2394.66 + }, + { + "word": "types", + "start": 2394.66, + "end": 2394.98 + }, + { + "word": "and", + "start": 2394.98, + "end": 2395.14 + }, + { + "word": "let", + "start": 2395.14, + "end": 2395.24 + }, + { + "word": "me", + "start": 2395.24, + "end": 2395.36 + }, + { + "word": "generate", + "start": 2395.36, + "end": 2395.6 + }, + { + "word": "stuff", + "start": 2395.6, + "end": 2395.8 + } + ] + }, + { + "start": 2395.8, + "end": 2402.16, + "text": "from those. So Microsoft has a project called like TypeSpec or something that's like pretty", + "words": [ + { + "word": "from", + "start": 2395.8, + "end": 2395.92 + }, + { + "word": "those.", + "start": 2395.92, + "end": 2396.38 + }, + { + "word": "So", + "start": 2398.18, + "end": 2398.38 + }, + { + "word": "Microsoft", + "start": 2398.38, + "end": 2398.74 + }, + { + "word": "has", + "start": 2398.74, + "end": 2399.04 + }, + { + "word": "a", + "start": 2399.04, + "end": 2399.26 + }, + { + "word": "project", + "start": 2399.26, + "end": 2399.72 + }, + { + "word": "called", + "start": 2399.72, + "end": 2400.16 + }, + { + "word": "like", + "start": 2400.16, + "end": 2400.44 + }, + { + "word": "TypeSpec", + "start": 2400.44, + "end": 2401.02 + }, + { + "word": "or", + "start": 2401.02, + "end": 2401.2 + }, + { + "word": "something", + "start": 2401.2, + "end": 2401.5 + }, + { + "word": "that's", + "start": 2401.5, + "end": 2401.82 + }, + { + "word": "like", + "start": 2401.82, + "end": 2402.0 + }, + { + "word": "pretty", + "start": 2402.0, + "end": 2402.16 + } + ] + }, + { + "start": 2402.16, + "end": 2410.2, + "text": "interesting. And it's like, if you squint at it, it looks like TypeScript types. Open API is not", + "words": [ + { + "word": "interesting.", + "start": 2402.16, + "end": 2402.7 + }, + { + "word": "And", + "start": 2402.74, + "end": 2402.84 + }, + { + "word": "it's", + "start": 2402.84, + "end": 2403.0 + }, + { + "word": "like,", + "start": 2403.0, + "end": 2404.1 + }, + { + "word": "if", + "start": 2404.1, + "end": 2404.66 + }, + { + "word": "you", + "start": 2404.66, + "end": 2404.82 + }, + { + "word": "squint", + "start": 2404.82, + "end": 2405.04 + }, + { + "word": "at", + "start": 2405.04, + "end": 2405.12 + }, + { + "word": "it,", + "start": 2405.12, + "end": 2405.24 + }, + { + "word": "it", + "start": 2405.24, + "end": 2405.32 + }, + { + "word": "looks", + "start": 2405.32, + "end": 2405.48 + }, + { + "word": "like", + "start": 2405.48, + "end": 2405.74 + }, + { + "word": "TypeScript", + "start": 2405.74, + "end": 2406.04 + }, + { + "word": "types.", + "start": 2406.04, + "end": 2406.98 + }, + { + "word": "Open", + "start": 2408.26, + "end": 2408.42 + }, + { + "word": "API", + "start": 2408.42, + "end": 2408.76 + }, + { + "word": "is", + "start": 2408.76, + "end": 2409.42 + }, + { + "word": "not", + "start": 2409.42, + "end": 2410.2 + } + ] + }, + { + "start": 2410.2, + "end": 2415.02, + "text": "my friend. JSON schema is also not my friend. Like one of the big things that I hate about", + "words": [ + { + "word": "my", + "start": 2410.2, + "end": 2410.78 + }, + { + "word": "friend.", + "start": 2410.78, + "end": 2411.16 + }, + { + "word": "JSON", + "start": 2411.54, + "end": 2411.78 + }, + { + "word": "schema", + "start": 2411.78, + "end": 2412.12 + }, + { + "word": "is", + "start": 2412.12, + "end": 2412.68 + }, + { + "word": "also", + "start": 2412.68, + "end": 2413.08 + }, + { + "word": "not", + "start": 2413.08, + "end": 2413.26 + }, + { + "word": "my", + "start": 2413.26, + "end": 2413.46 + }, + { + "word": "friend.", + "start": 2413.46, + "end": 2413.7 + }, + { + "word": "Like", + "start": 2413.84, + "end": 2414.02 + }, + { + "word": "one", + "start": 2414.02, + "end": 2414.14 + }, + { + "word": "of", + "start": 2414.14, + "end": 2414.24 + }, + { + "word": "the", + "start": 2414.24, + "end": 2414.32 + }, + { + "word": "big", + "start": 2414.32, + "end": 2414.44 + }, + { + "word": "things", + "start": 2414.44, + "end": 2414.6 + }, + { + "word": "that", + "start": 2414.6, + "end": 2414.72 + }, + { + "word": "I", + "start": 2414.72, + "end": 2414.78 + }, + { + "word": "hate", + "start": 2414.78, + "end": 2414.86 + }, + { + "word": "about", + "start": 2414.86, + "end": 2415.02 + } + ] + }, + { + "start": 2415.02, + "end": 2421.78, + "text": "JSON schema is like a lot of the like validators and tooling for it are stuck on like old versions.", + "words": [ + { + "word": "JSON", + "start": 2415.02, + "end": 2415.32 + }, + { + "word": "schema", + "start": 2415.32, + "end": 2415.62 + }, + { + "word": "is", + "start": 2415.62, + "end": 2415.9 + }, + { + "word": "like", + "start": 2415.9, + "end": 2416.66 + }, + { + "word": "a", + "start": 2416.66, + "end": 2416.74 + }, + { + "word": "lot", + "start": 2416.74, + "end": 2417.02 + }, + { + "word": "of", + "start": 2417.02, + "end": 2417.32 + }, + { + "word": "the", + "start": 2417.32, + "end": 2418.44 + }, + { + "word": "like", + "start": 2418.44, + "end": 2418.86 + }, + { + "word": "validators", + "start": 2418.86, + "end": 2419.36 + }, + { + "word": "and", + "start": 2419.36, + "end": 2419.6 + }, + { + "word": "tooling", + "start": 2419.6, + "end": 2419.84 + }, + { + "word": "for", + "start": 2419.84, + "end": 2420.18 + }, + { + "word": "it", + "start": 2420.18, + "end": 2420.3 + }, + { + "word": "are", + "start": 2420.3, + "end": 2420.52 + }, + { + "word": "stuck", + "start": 2420.52, + "end": 2420.68 + }, + { + "word": "on", + "start": 2420.68, + "end": 2420.86 + }, + { + "word": "like", + "start": 2420.86, + "end": 2421.04 + }, + { + "word": "old", + "start": 2421.04, + "end": 2421.26 + }, + { + "word": "versions.", + "start": 2421.26, + "end": 2421.78 + } + ] + }, + { + "start": 2421.86, + "end": 2425.32, + "text": "So there are things that you want to express that you can't express because none of the tools", + "words": [ + { + "word": "So", + "start": 2421.86, + "end": 2422.02 + }, + { + "word": "there", + "start": 2422.02, + "end": 2422.18 + }, + { + "word": "are", + "start": 2422.18, + "end": 2422.3 + }, + { + "word": "things", + "start": 2422.3, + "end": 2422.52 + }, + { + "word": "that", + "start": 2422.52, + "end": 2422.66 + }, + { + "word": "you", + "start": 2422.66, + "end": 2422.8 + }, + { + "word": "want", + "start": 2422.8, + "end": 2422.9 + }, + { + "word": "to", + "start": 2422.9, + "end": 2423.14 + }, + { + "word": "express", + "start": 2423.14, + "end": 2423.48 + }, + { + "word": "that", + "start": 2423.48, + "end": 2423.66 + }, + { + "word": "you", + "start": 2423.66, + "end": 2423.84 + }, + { + "word": "can't", + "start": 2423.84, + "end": 2424.14 + }, + { + "word": "express", + "start": 2424.14, + "end": 2424.44 + }, + { + "word": "because", + "start": 2424.44, + "end": 2424.74 + }, + { + "word": "none", + "start": 2424.74, + "end": 2424.92 + }, + { + "word": "of", + "start": 2424.92, + "end": 2425.04 + }, + { + "word": "the", + "start": 2425.04, + "end": 2425.18 + }, + { + "word": "tools", + "start": 2425.18, + "end": 2425.32 + } + ] + }, + { + "start": 2425.32, + "end": 2430.96, + "text": "support them, even though it's in the new specs. Imperating. There are trade offs with all these", + "words": [ + { + "word": "support", + "start": 2425.32, + "end": 2425.62 + }, + { + "word": "them,", + "start": 2425.62, + "end": 2425.84 + }, + { + "word": "even", + "start": 2425.9, + "end": 2426.02 + }, + { + "word": "though", + "start": 2426.02, + "end": 2426.18 + }, + { + "word": "it's", + "start": 2426.18, + "end": 2426.3 + }, + { + "word": "in", + "start": 2426.3, + "end": 2426.42 + }, + { + "word": "the", + "start": 2426.42, + "end": 2426.52 + }, + { + "word": "new", + "start": 2426.52, + "end": 2426.68 + }, + { + "word": "specs.", + "start": 2426.68, + "end": 2427.24 + }, + { + "word": "Imperating.", + "start": 2428.18, + "end": 2428.58 + }, + { + "word": "There", + "start": 2430.04, + "end": 2430.16 + }, + { + "word": "are", + "start": 2430.16, + "end": 2430.28 + }, + { + "word": "trade", + "start": 2430.28, + "end": 2430.4 + }, + { + "word": "offs", + "start": 2430.4, + "end": 2430.54 + }, + { + "word": "with", + "start": 2430.54, + "end": 2430.68 + }, + { + "word": "all", + "start": 2430.68, + "end": 2430.78 + }, + { + "word": "these", + "start": 2430.78, + "end": 2430.96 + } + ] + }, + { + "start": 2430.96, + "end": 2436.76, + "text": "things. It's never going to be perfect. Just bite the bullet and figure out like what your use case", + "words": [ + { + "word": "things.", + "start": 2430.96, + "end": 2431.22 + }, + { + "word": "It's", + "start": 2431.78, + "end": 2432.18 + }, + { + "word": "never", + "start": 2432.18, + "end": 2432.36 + }, + { + "word": "going", + "start": 2432.36, + "end": 2432.48 + }, + { + "word": "to", + "start": 2432.48, + "end": 2432.52 + }, + { + "word": "be", + "start": 2432.52, + "end": 2432.68 + }, + { + "word": "perfect.", + "start": 2432.68, + "end": 2433.04 + }, + { + "word": "Just", + "start": 2433.6, + "end": 2434.0 + }, + { + "word": "bite", + "start": 2434.0, + "end": 2434.16 + }, + { + "word": "the", + "start": 2434.16, + "end": 2434.32 + }, + { + "word": "bullet", + "start": 2434.32, + "end": 2434.64 + }, + { + "word": "and", + "start": 2434.64, + "end": 2435.34 + }, + { + "word": "figure", + "start": 2435.34, + "end": 2435.56 + }, + { + "word": "out", + "start": 2435.56, + "end": 2435.76 + }, + { + "word": "like", + "start": 2435.76, + "end": 2435.96 + }, + { + "word": "what", + "start": 2435.96, + "end": 2436.16 + }, + { + "word": "your", + "start": 2436.16, + "end": 2436.36 + }, + { + "word": "use", + "start": 2436.36, + "end": 2436.56 + }, + { + "word": "case", + "start": 2436.56, + "end": 2436.76 + } + ] + }, + { + "start": 2436.76, + "end": 2441.8, + "text": "is. Like if you want to support anything like that other people use, you probably should go with", + "words": [ + { + "word": "is.", + "start": 2436.76, + "end": 2437.08 + }, + { + "word": "Like", + "start": 2437.14, + "end": 2437.34 + }, + { + "word": "if", + "start": 2437.34, + "end": 2437.42 + }, + { + "word": "you", + "start": 2437.42, + "end": 2437.62 + }, + { + "word": "want", + "start": 2437.62, + "end": 2437.72 + }, + { + "word": "to", + "start": 2437.72, + "end": 2437.94 + }, + { + "word": "support", + "start": 2437.94, + "end": 2438.18 + }, + { + "word": "anything", + "start": 2438.18, + "end": 2438.58 + }, + { + "word": "like", + "start": 2438.58, + "end": 2439.66 + }, + { + "word": "that", + "start": 2439.66, + "end": 2440.32 + }, + { + "word": "other", + "start": 2440.32, + "end": 2440.52 + }, + { + "word": "people", + "start": 2440.52, + "end": 2440.8 + }, + { + "word": "use,", + "start": 2440.8, + "end": 2441.04 + }, + { + "word": "you", + "start": 2441.06, + "end": 2441.18 + }, + { + "word": "probably", + "start": 2441.18, + "end": 2441.44 + }, + { + "word": "should", + "start": 2441.44, + "end": 2441.56 + }, + { + "word": "go", + "start": 2441.56, + "end": 2441.7 + }, + { + "word": "with", + "start": 2441.7, + "end": 2441.8 + } + ] + }, + { + "start": 2441.8, + "end": 2452.84, + "text": "something standard probably. But the world's your oyster. Do what you want. Cool. So I had my stuff", + "words": [ + { + "word": "something", + "start": 2441.8, + "end": 2442.06 + }, + { + "word": "standard", + "start": 2442.06, + "end": 2442.58 + }, + { + "word": "probably.", + "start": 2442.58, + "end": 2443.26 + }, + { + "word": "But", + "start": 2443.92, + "end": 2444.32 + }, + { + "word": "the", + "start": 2444.32, + "end": 2444.66 + }, + { + "word": "world's", + "start": 2444.66, + "end": 2444.86 + }, + { + "word": "your", + "start": 2444.86, + "end": 2444.94 + }, + { + "word": "oyster.", + "start": 2444.94, + "end": 2445.08 + }, + { + "word": "Do", + "start": 2445.14, + "end": 2445.24 + }, + { + "word": "what", + "start": 2445.24, + "end": 2445.34 + }, + { + "word": "you", + "start": 2445.34, + "end": 2446.56 + }, + { + "word": "want.", + "start": 2446.56, + "end": 2446.56 + }, + { + "word": "Cool.", + "start": 2449.9, + "end": 2450.2 + }, + { + "word": "So", + "start": 2450.92, + "end": 2451.32 + }, + { + "word": "I", + "start": 2451.32, + "end": 2451.7 + }, + { + "word": "had", + "start": 2451.7, + "end": 2451.86 + }, + { + "word": "my", + "start": 2451.86, + "end": 2452.66 + }, + { + "word": "stuff", + "start": 2452.66, + "end": 2452.84 + } + ] + }, + { + "start": 2452.84, + "end": 2456.94, + "text": "there. You can go to my site. Feel free to email me. I like meeting people. So if you ever want", + "words": [ + { + "word": "there.", + "start": 2452.84, + "end": 2453.12 + }, + { + "word": "You", + "start": 2453.26, + "end": 2453.26 + }, + { + "word": "can", + "start": 2453.26, + "end": 2453.38 + }, + { + "word": "go", + "start": 2453.38, + "end": 2453.48 + }, + { + "word": "to", + "start": 2453.48, + "end": 2453.58 + }, + { + "word": "my", + "start": 2453.58, + "end": 2453.74 + }, + { + "word": "site.", + "start": 2453.74, + "end": 2454.1 + }, + { + "word": "Feel", + "start": 2454.96, + "end": 2455.04 + }, + { + "word": "free", + "start": 2455.04, + "end": 2455.2 + }, + { + "word": "to", + "start": 2455.2, + "end": 2455.32 + }, + { + "word": "email", + "start": 2455.32, + "end": 2455.42 + }, + { + "word": "me.", + "start": 2455.42, + "end": 2455.62 + }, + { + "word": "I", + "start": 2455.74, + "end": 2455.74 + }, + { + "word": "like", + "start": 2455.74, + "end": 2455.9 + }, + { + "word": "meeting", + "start": 2455.9, + "end": 2456.1 + }, + { + "word": "people.", + "start": 2456.1, + "end": 2456.46 + }, + { + "word": "So", + "start": 2456.56, + "end": 2456.62 + }, + { + "word": "if", + "start": 2456.62, + "end": 2456.68 + }, + { + "word": "you", + "start": 2456.68, + "end": 2456.76 + }, + { + "word": "ever", + "start": 2456.76, + "end": 2456.86 + }, + { + "word": "want", + "start": 2456.86, + "end": 2456.94 + } + ] + }, + { + "start": 2456.94, + "end": 2462.16, + "text": "to grab a coffee or whatever, I'm in Brooklyn. So come say hi. And yeah, thanks for your time.", + "words": [ + { + "word": "to", + "start": 2456.94, + "end": 2457.02 + }, + { + "word": "grab", + "start": 2457.02, + "end": 2457.12 + }, + { + "word": "a", + "start": 2457.12, + "end": 2457.24 + }, + { + "word": "coffee", + "start": 2457.24, + "end": 2457.5 + }, + { + "word": "or", + "start": 2457.5, + "end": 2457.68 + }, + { + "word": "whatever,", + "start": 2457.68, + "end": 2457.92 + }, + { + "word": "I'm", + "start": 2458.12, + "end": 2458.16 + }, + { + "word": "in", + "start": 2458.16, + "end": 2458.28 + }, + { + "word": "Brooklyn.", + "start": 2458.28, + "end": 2458.54 + }, + { + "word": "So", + "start": 2459.2, + "end": 2459.24 + }, + { + "word": "come", + "start": 2459.24, + "end": 2459.44 + }, + { + "word": "say", + "start": 2459.44, + "end": 2459.6 + }, + { + "word": "hi.", + "start": 2459.6, + "end": 2460.2 + }, + { + "word": "And", + "start": 2460.76, + "end": 2460.9 + }, + { + "word": "yeah,", + "start": 2460.9, + "end": 2461.14 + }, + { + "word": "thanks", + "start": 2461.32, + "end": 2461.4 + }, + { + "word": "for", + "start": 2461.4, + "end": 2461.52 + }, + { + "word": "your", + "start": 2461.52, + "end": 2461.62 + }, + { + "word": "time.", + "start": 2461.62, + "end": 2462.16 + } + ] + } + ] +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..73bca28 --- /dev/null +++ b/requirements.txt @@ -0,0 +1 @@ +openai-whisper diff --git a/scripts/transcribe.py b/scripts/transcribe.py new file mode 100644 index 0000000..cd40fdb --- /dev/null +++ b/scripts/transcribe.py @@ -0,0 +1,104 @@ +#!/usr/bin/env python3 +""" +Generate word-level transcript from audio/video using OpenAI Whisper. + +Usage: + python scripts/transcribe.py [model-size] + +Example: + python scripts/transcribe.py \ + public/assets/talks/codegen-in-rust/audio.m4a \ + public/transcripts/t2468.json \ + medium +""" + +import sys +import json +from pathlib import Path + +def transcribe_file(input_path: str, output_path: str, model_size: str = "base"): + """ + Transcribe audio/video file with word-level timestamps. + + Args: + input_path: Path to audio/video file + output_path: Path to output JSON file + model_size: Whisper model size (tiny, base, small, medium, large) + """ + try: + import whisper + except ImportError: + print("Error: openai-whisper is not installed.") + print("Install it with: pip install openai-whisper") + sys.exit(1) + + print(f"Loading Whisper model: {model_size}") + model = whisper.load_model(model_size) + + print(f"Transcribing: {input_path}") + print("This may take a while depending on file length and model size...") + + result = model.transcribe( + input_path, + word_timestamps=True, # Critical for word-level highlighting + language="en" # Can be removed for auto-detection + ) + + # Build transcript structure + transcript = { + "language": result.get("language", "en"), + "duration": 0, + "segments": [] + } + + total_words = 0 + + for segment in result.get("segments", []): + seg_data = { + "start": round(segment["start"], 3), + "end": round(segment["end"], 3), + "text": segment["text"].strip(), + "words": [] + } + + # Extract word-level timestamps if available + if "words" in segment: + for word in segment["words"]: + seg_data["words"].append({ + "word": word["word"].strip(), + "start": round(word["start"], 3), + "end": round(word["end"], 3) + }) + total_words += 1 + + transcript["segments"].append(seg_data) + transcript["duration"] = max(transcript["duration"], seg_data["end"]) + + # Ensure output directory exists + output_file = Path(output_path) + output_file.parent.mkdir(parents=True, exist_ok=True) + + # Write JSON + with open(output_file, 'w', encoding='utf-8') as f: + json.dump(transcript, f, indent=2, ensure_ascii=False) + + print(f"\n✓ Transcript saved to: {output_path}") + print(f" Language: {transcript['language']}") + print(f" Duration: {transcript['duration']:.1f}s ({transcript['duration'] / 60:.1f}min)") + print(f" Segments: {len(transcript['segments'])}") + print(f" Words: {total_words}") + +if __name__ == "__main__": + if len(sys.argv) < 3: + print(__doc__) + sys.exit(1) + + input_file = sys.argv[1] + output_file = sys.argv[2] + model = sys.argv[3] if len(sys.argv) > 3 else "base" + + if not Path(input_file).exists(): + print(f"Error: Input file not found: {input_file}") + sys.exit(1) + + transcribe_file(input_file, output_file, model) diff --git a/src/components/AudioTranscript.astro b/src/components/AudioTranscript.astro new file mode 100644 index 0000000..3f0295c --- /dev/null +++ b/src/components/AudioTranscript.astro @@ -0,0 +1,231 @@ +--- +import TUIAudioPlayer from "./TUIAudioPlayer.astro"; + +interface Word { + word: string; + start: number; + end: number; +} + +interface Segment { + start: number; + end: number; + text: string; + words: Word[]; +} + +interface Transcript { + language: string; + duration: number; + segments: Segment[]; +} + +interface Props { + audioPath: string; + transcriptPath: string; + talkId: string; + class?: string; +} + +const { audioPath, transcriptPath, talkId, class: className } = Astro.props; +const containerId = `audio-transcript-${talkId}`; +const playerId = `audio-player-${talkId}`; +--- + +
+ +
+ +
+ + +
+
+
+ Loading transcript... +
+ +
+
+
+ + + + + + diff --git a/src/components/TUIAudioPlayer.astro b/src/components/TUIAudioPlayer.astro new file mode 100644 index 0000000..4f324cf --- /dev/null +++ b/src/components/TUIAudioPlayer.astro @@ -0,0 +1,145 @@ +--- +interface Props { + audioPath: string; + playerId: string; +} + +const { audioPath, playerId } = Astro.props; +--- + +
+ + +
+ + + + 00:00 + / + 00:00 + + +
+ +
+
+
+ + + + diff --git a/src/components/TalkSlides.astro b/src/components/TalkSlides.astro index c3e844a..fe333e7 100644 --- a/src/components/TalkSlides.astro +++ b/src/components/TalkSlides.astro @@ -20,9 +20,17 @@ interface Props { * ID for the talk (used for namespacing) */ talkId: string; + /** + * Whether to sync slides with audio playback (requires audioPlayerId) + */ + syncWithAudio?: boolean; + /** + * ID of the audio player to sync with (e.g., "audio-player-codegen-rust") + */ + audioPlayerId?: string; } -const { slides, basePath, talkId } = Astro.props; +const { slides, basePath, talkId, syncWithAudio = false, audioPlayerId } = Astro.props; // Normalize slides to array format const slideList: Slide[] = typeof slides === "number" @@ -49,75 +57,96 @@ const totalSlides = resolvedSlides.length; const containerId = `talk-slides-${talkId}`; --- -
-
+
+
Slide 1 -
- -
- - -
- 1 / {totalSlides} +
+
+
+
+
- - -
- -
- ← - → - Space - to navigate • - Home - End - to jump
- - diff --git a/src/content.config.ts b/src/content.config.ts index 5d86405..83fcf18 100644 --- a/src/content.config.ts +++ b/src/content.config.ts @@ -46,6 +46,16 @@ const talks = defineCollection({ description: z.string().optional(), date: z.coerce.date(), event: z.string(), + location: z.string().optional(), + slides: z.union([ + z.number(), + z.array(z.object({ + image: z.string(), + timestamp: z.number().optional(), + })) + ]).optional(), + audioPath: z.string().optional(), + transcriptPath: z.string().optional(), }), }); diff --git a/src/content/talks/t2468--codegen-in-rust.mdx b/src/content/talks/t2468--codegen-in-rust.mdx index 37197c2..c3d47bd 100644 --- a/src/content/talks/t2468--codegen-in-rust.mdx +++ b/src/content/talks/t2468--codegen-in-rust.mdx @@ -2,12 +2,63 @@ title: Codegen in Rust date: 2025-07-08 event: RustNYC +location: New York, NY +slides: + - image: codegen-1.png + timestamp: 0 + - image: codegen-2.png + timestamp: 16 + - image: codegen-3.png + - image: codegen-4.png + - image: codegen-5.png + - image: codegen-6.png + - image: codegen-7.png + - image: codegen-8.png + - image: codegen-9.png + - image: codegen-10.png + - image: codegen-11.png + - image: codegen-12.png + - image: codegen-13.png + - image: codegen-14.png + - image: codegen-15.png + - image: codegen-16.png + - image: codegen-17.png + - image: codegen-18.png + - image: codegen-19.png + - image: codegen-20.png + - image: codegen-21.png + - image: codegen-22.png + - image: codegen-23.png + - image: codegen-24.png + - image: codegen-25.png + - image: codegen-26.png + - image: codegen-27.png + - image: codegen-28.png + - image: codegen-29.png + - image: codegen-30.png + - image: codegen-31.png + - image: codegen-32.png + - image: codegen-33.png + - image: codegen-34.png + - image: codegen-35.png + - image: codegen-36.png + - image: codegen-37.png + - image: codegen-38.png + - image: codegen-39.png + - image: codegen-40.png + - image: codegen-41.png + - image: codegen-42.png + - image: codegen-43.png + - image: codegen-44.png + - image: codegen-45.png + - image: codegen-46.png + - image: codegen-47.png + - image: codegen-48.png + - image: codegen-49.png + - image: codegen-50.png + - image: codegen-51.png + - image: codegen-52.png + - image: codegen-53.png +audioPath: /assets/talks/codegen-in-rust/audio.m4a +transcriptPath: /transcripts/t2468.json --- - -import TalkSlides from "@/components/TalkSlides.astro"; - - diff --git a/src/pages/talks/[code]/[slug].astro b/src/pages/talks/[code]/[slug].astro index 81efe1f..1b55019 100644 --- a/src/pages/talks/[code]/[slug].astro +++ b/src/pages/talks/[code]/[slug].astro @@ -3,6 +3,8 @@ import { getCollection, render } from "astro:content"; import FormattedDate from "@/components/FormattedDate.astro"; import Link from "@/components/Link.astro"; import MDContent from "@/components/MDContent.astro"; +import TalkSlides from "@/components/TalkSlides.astro"; +import AudioTranscript from "@/components/AudioTranscript.astro"; import Layout from "@/layouts/Layout.astro"; import { Code } from "@/utils/code"; @@ -16,13 +18,20 @@ type Props = Awaited>[number]["props"]; const talk = Astro.props; const { Content } = await render(talk); -// Extract code from filename +// Extract code and slug from filename const code = Code.fromId(talk.id); +const { slug } = Code.parseId(talk.id); + +// Check if this talk has slides/audio/transcript +const hasSlides = talk.data.slides !== undefined; +const hasAudio = talk.data.audioPath !== undefined; +const hasTranscript = talk.data.transcriptPath !== undefined; +const hasInteractiveLayout = hasSlides && hasAudio && hasTranscript; --- -
-
+
+

{talk.data.title}

@@ -38,26 +47,41 @@ const code = Code.fromId(talk.id);
-
- -
+ {hasInteractiveLayout ? ( +
+
+ +
-
- - ← Back to talks - -
+
+ +
+
+ ) : ( + + )}
- +`}