vizmatic 0.3.2 → 0.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/PROMPT.md +75 -525
- package/README.md +87 -578
- package/ROADMAP.md +49 -67
- package/SCIENCE.md +250 -0
- package/assets/THIRD_PARTY_LICENSES.md +40 -1
- package/assets/fonts/InstrumentSerif-Italic.ttf +0 -0
- package/assets/fonts/InstrumentSerif-Regular.ttf +0 -0
- package/assets/licenses/raster-codecs-MIT.txt +74 -0
- package/dist/chunk-3F2VQ7NW.js +1 -0
- package/dist/chunk-4XE64I2U.js +755 -0
- package/dist/chunk-JHHPLALU.js +79 -0
- package/dist/chunk-LTX44BAE.js +112 -0
- package/dist/chunk-MLKGABMK.js +9 -0
- package/dist/chunk-PSBF4TEK.js +1 -0
- package/dist/chunk-RPAHMKAR.js +605 -0
- package/dist/chunk-RWF4VBUL.js +3617 -0
- package/dist/chunk-WHT6HRMX.js +4201 -0
- package/dist/cli.js +371 -10
- package/dist/index.cjs +11129 -2922
- package/dist/index.d.cts +1225 -369
- package/dist/index.d.ts +1225 -369
- package/dist/index.js +6220 -3015
- package/dist/math-LXB4FH4E.js +7 -0
- package/dist/math-QVCETQDQ.js +1 -0
- package/dist/scene-browser-assets.d.ts +38 -0
- package/dist/scene-browser-assets.js +53 -0
- package/dist/scene-browser-chunks/chunk-5MVLYGXM.js +70 -0
- package/dist/scene-browser-chunks/chunk-ASXKN3NU.js +1 -0
- package/dist/scene-browser-chunks/chunk-CM5Y5LZP.js +1 -0
- package/dist/scene-browser-chunks/chunk-DP7NB4EW.js +6 -0
- package/dist/scene-browser-chunks/emscripten-module.browser-M5AEKJGE.js +1 -0
- package/dist/scene-browser-chunks/ffi-FL6ORJU3.js +1 -0
- package/dist/scene-browser-chunks/module-ES6BEMUI-JD5S5VKR.js +1 -0
- package/dist/scene-browser-chunks/module-asyncify-2EFITU5U-HWPFJFJC.js +1 -0
- package/dist/scene-browser-chunks/scene-browser-layout-M3XSXMV4.js +27 -0
- package/dist/scene-browser.d.ts +117 -0
- package/dist/scene-browser.js +220 -0
- package/dist/scene-cli.d.ts +1 -0
- package/dist/scene-cli.js +4 -0
- package/dist/scene-runtime.cjs +995 -0
- package/dist/scene-runtime.d.cts +81 -0
- package/dist/scene-runtime.d.ts +81 -0
- package/dist/scene-runtime.js +22 -0
- package/dist/server-2FYHZ4UO.js +331 -0
- package/dist/stage-browser/browser.d.ts +2482 -0
- package/dist/stage-browser/chunk-SQE76S5B.js +1 -0
- package/dist/stage-browser/chunk-VZNL6JY2.js +59 -0
- package/dist/stage-browser/dagre.esm-N2NIVIAZ.js +6 -0
- package/dist/stage-browser/math-4WFNHVV2.js +18 -0
- package/dist/stage-browser/stage.js +19 -0
- package/dist/stage-export.cjs +4950 -0
- package/dist/stage-export.d.cts +112 -0
- package/dist/stage-export.d.ts +112 -0
- package/dist/stage-export.js +544 -0
- package/dist/stage.cjs +9745 -0
- package/dist/stage.d.cts +1678 -0
- package/dist/stage.d.ts +1678 -0
- package/dist/stage.js +5404 -0
- package/dist/svg-import-Djj2q7Pc.d.cts +742 -0
- package/dist/svg-import-Djj2q7Pc.d.ts +742 -0
- package/dist/video-CcHW1qhV.d.cts +532 -0
- package/dist/video-CcHW1qhV.d.ts +532 -0
- package/examples/README.md +18 -0
- package/examples/agent-pipeline.tsx +4 -4
- package/examples/animated-pipeline.tsx +1 -5
- package/examples/attention-head.tsx +12 -12
- package/examples/aurora-incident.tsx +4 -3
- package/examples/building-blocks.tsx +8 -9
- package/examples/catalog-charts.tsx +4 -4
- package/examples/catalog-content.tsx +7 -9
- package/examples/catalog-convolution-kernel.tsx +116 -0
- package/examples/catalog-data.tsx +2 -8
- package/examples/catalog-dataflow.tsx +5 -9
- package/examples/catalog-dense.tsx +80 -0
- package/examples/catalog-deployment.tsx +5 -11
- package/examples/catalog-diagrams.tsx +13 -16
- package/examples/catalog-drawing.tsx +7 -7
- package/examples/catalog-flows.tsx +4 -4
- package/examples/catalog-foundations.tsx +11 -11
- package/examples/catalog-gaussian-blur.tsx +146 -0
- package/examples/catalog-image-tensors.tsx +115 -0
- package/examples/catalog-ml.tsx +36 -31
- package/examples/catalog-numeric-matrices.tsx +93 -0
- package/examples/catalog-photo-blur.tsx +209 -0
- package/examples/catalog-science-ai.tsx +130 -0
- package/examples/catalog-science-chemistry.tsx +103 -0
- package/examples/catalog-science-math.tsx +93 -0
- package/examples/catalog-science-physics.tsx +84 -0
- package/examples/catalog-sequence.tsx +59 -38
- package/examples/data-pipeline-lineage-presentation.tsx +5 -0
- package/examples/data-pipeline-lineage.tsx +85 -0
- package/examples/daybreak-launch.tsx +1 -0
- package/examples/desired-quadrant.tsx +7 -8
- package/examples/engineering-dashboard-presentation.tsx +13 -0
- package/examples/engineering-dashboard.tsx +160 -0
- package/examples/engineering-flow.tsx +2 -4
- package/examples/eval-dashboard.tsx +6 -6
- package/examples/films/attention.ts +278 -0
- package/examples/films/cache-miss.ts +431 -0
- package/examples/films/catalog.json +132 -0
- package/examples/films/central-limit.ts +269 -0
- package/examples/films/complex-maps.ts +273 -0
- package/examples/films/deck-example.ts +224 -0
- package/examples/films/euler-circle.ts +179 -0
- package/examples/films/fourier-epicycles.ts +265 -0
- package/examples/films/gradient-descent.ts +345 -0
- package/examples/films/linear-maps.ts +175 -0
- package/examples/films/lorenz.ts +207 -0
- package/examples/films/pythagoras.ts +185 -0
- package/examples/films/taylor-series.ts +159 -0
- package/examples/films/vizmatic-title.ts +117 -0
- package/examples/llm-serving-stack-presentation.tsx +5 -0
- package/examples/llm-serving-stack.tsx +94 -0
- package/examples/model-garden.tsx +1 -0
- package/examples/model-router.tsx +6 -6
- package/examples/nccl-all-gather.tsx +3 -3
- package/examples/nccl-all-reduce.tsx +3 -3
- package/examples/nccl-all-to-all.tsx +1 -1
- package/examples/nccl-broadcast.tsx +1 -1
- package/examples/nccl-reduce-scatter.tsx +5 -5
- package/examples/orthogonal-routing.tsx +4 -4
- package/examples/pareto-frontier.tsx +9 -10
- package/examples/presentation-frame.tsx +6 -6
- package/examples/pressure-mechanism.scene.json +14 -0
- package/examples/production-system-map-presentation.tsx +5 -0
- package/examples/production-system-map.tsx +130 -0
- package/examples/rag-graph.tsx +7 -7
- package/examples/release-card.tsx +5 -5
- package/examples/spec-anatomy.tsx +5 -5
- package/examples/system-architecture.tsx +19 -32
- package/examples/theme-system.tsx +1 -1
- package/examples/token-matrix.tsx +4 -2
- package/examples/transparent-badge.tsx +1 -2
- package/examples/videos/README.md +62 -0
- package/examples/videos/calculus-tangent.tsx +101 -0
- package/examples/videos/catalyst-pathway.tsx +56 -0
- package/examples/videos/causal-attention.tsx +91 -0
- package/examples/videos/convolution-kernel.tsx +34 -0
- package/examples/videos/gaussian-blur.tsx +32 -0
- package/examples/videos/image-to-matrix.tsx +22 -0
- package/examples/videos/matrix-multiplication.tsx +128 -0
- package/examples/videos/photo-gaussian-blur.tsx +39 -0
- package/examples/videos/request-lifecycle.tsx +99 -0
- package/examples/videos/signal-to-story.tsx +126 -0
- package/examples/videos/wave-interference.tsx +80 -0
- package/examples/vizmatic-bare.d.ts +1 -0
- package/examples/vizmatic-hero.tsx +9 -18
- package/examples/website-workflow.tsx +7 -7
- package/examples/weekend-field-notes.tsx +3 -2
- package/package.json +77 -12
|
@@ -0,0 +1,431 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* A cache stampede, simulated. One hot key expires at 12,000 requests per second.
|
|
3
|
+
* Every request runs through a small queueing model in this file, so the pool
|
|
4
|
+
* depth, queue, and p99 lines on screen are computed, not drawn by hand. The hop
|
|
5
|
+
* times are illustrative figures for a service in one availability zone.
|
|
6
|
+
*/
|
|
7
|
+
import {
|
|
8
|
+
Node, draw, dynamic, fade, fadeIn, film, line, linear, parseSvgPath, pointAt, polyPath, rect, smoother, text, write, dot,
|
|
9
|
+
type ColorInput, type Path, type Vec,
|
|
10
|
+
} from 'vizmatic/stage'
|
|
11
|
+
|
|
12
|
+
// ── The model ───────────────────────────────────────────────────────────────
|
|
13
|
+
|
|
14
|
+
const RATE = 12 // requests per millisecond
|
|
15
|
+
const POOL = 40
|
|
16
|
+
const QUERY_MS = 40
|
|
17
|
+
const SPANS = [
|
|
18
|
+
{ name: 'accept', ms: 0.2, miss: true, hit: true },
|
|
19
|
+
{ name: 'route to service', ms: 0.15, miss: true, hit: true },
|
|
20
|
+
{ name: 'handler', ms: 0.4, miss: true, hit: true },
|
|
21
|
+
{ name: 'redis GET', ms: 0.35, miss: true, hit: true },
|
|
22
|
+
{ name: 'postgres query', ms: QUERY_MS, miss: true, hit: false },
|
|
23
|
+
{ name: 'redis SET', ms: 0.3, miss: true, hit: false },
|
|
24
|
+
{ name: 'serialize', ms: 0.9, miss: true, hit: true },
|
|
25
|
+
{ name: 'respond', ms: 0.1, miss: true, hit: true },
|
|
26
|
+
] as const
|
|
27
|
+
const HIT_MS = SPANS.filter((span) => span.hit).reduce((sum, span) => sum + span.ms, 0)
|
|
28
|
+
const MISS_MS = SPANS.reduce((sum, span) => sum + span.ms, 0)
|
|
29
|
+
const SIM_START = -40, SIM_END = 640, SIM_LEN = SIM_END - SIM_START
|
|
30
|
+
|
|
31
|
+
interface Run {
|
|
32
|
+
inUse: Float32Array
|
|
33
|
+
queue: Float32Array
|
|
34
|
+
p99: Float32Array
|
|
35
|
+
hitRate: Float32Array
|
|
36
|
+
queries: number
|
|
37
|
+
peak: number
|
|
38
|
+
}
|
|
39
|
+
|
|
40
|
+
function simulate(coalesce: boolean): Run {
|
|
41
|
+
const inUseDelta = new Float32Array(SIM_LEN + 1)
|
|
42
|
+
const queueDelta = new Float32Array(SIM_LEN + 1)
|
|
43
|
+
const finished: { at: number; latency: number; miss: boolean }[] = []
|
|
44
|
+
const free = new Array<number>(POOL).fill(SIM_START)
|
|
45
|
+
let filled = Infinity
|
|
46
|
+
let queries = 0
|
|
47
|
+
const index = (t: number) => Math.max(0, Math.min(SIM_LEN, Math.floor(t - SIM_START)))
|
|
48
|
+
for (let n = 0; n < SIM_LEN * RATE; n++) {
|
|
49
|
+
const arrive = SIM_START + n / RATE
|
|
50
|
+
if (arrive < 0 || arrive >= filled) {
|
|
51
|
+
finished.push({ at: arrive + HIT_MS, latency: HIT_MS, miss: false })
|
|
52
|
+
continue
|
|
53
|
+
}
|
|
54
|
+
if (coalesce && queries > 0) {
|
|
55
|
+
// A follower waits for the one query already running, then reads the fresh value.
|
|
56
|
+
finished.push({ at: filled + HIT_MS, latency: filled + HIT_MS - arrive, miss: true })
|
|
57
|
+
continue
|
|
58
|
+
}
|
|
59
|
+
let slot = 0
|
|
60
|
+
for (let i = 1; i < POOL; i++) if (free[i]! < free[slot]!) slot = i
|
|
61
|
+
const start = Math.max(arrive, free[slot]!)
|
|
62
|
+
const end = start + QUERY_MS
|
|
63
|
+
free[slot] = end
|
|
64
|
+
queries++
|
|
65
|
+
if (start > arrive) {
|
|
66
|
+
queueDelta[index(arrive)]! += 1
|
|
67
|
+
queueDelta[index(start)]! -= 1
|
|
68
|
+
}
|
|
69
|
+
inUseDelta[index(start)]! += 1
|
|
70
|
+
inUseDelta[index(end)]! -= 1
|
|
71
|
+
if (end + 0.3 < filled) filled = end + 0.3
|
|
72
|
+
finished.push({ at: end + MISS_MS - QUERY_MS, latency: end + MISS_MS - QUERY_MS - arrive, miss: true })
|
|
73
|
+
}
|
|
74
|
+
const inUse = new Float32Array(SIM_LEN), queue = new Float32Array(SIM_LEN)
|
|
75
|
+
let use = 0, waiting = 0
|
|
76
|
+
for (let i = 0; i < SIM_LEN; i++) {
|
|
77
|
+
use += inUseDelta[i]!
|
|
78
|
+
waiting += queueDelta[i]!
|
|
79
|
+
inUse[i] = use
|
|
80
|
+
queue[i] = waiting
|
|
81
|
+
}
|
|
82
|
+
finished.sort((a, b) => a.at - b.at)
|
|
83
|
+
const p99 = new Float32Array(SIM_LEN), hitRate = new Float32Array(SIM_LEN)
|
|
84
|
+
const windowMs = 50
|
|
85
|
+
let peak = 0
|
|
86
|
+
for (let i = 0; i < SIM_LEN; i++) {
|
|
87
|
+
const t = SIM_START + i
|
|
88
|
+
const recent: number[] = []
|
|
89
|
+
for (let lo = lowerBound(finished, t - windowMs); lo < finished.length && finished[lo]!.at <= t; lo++) recent.push(finished[lo]!.latency)
|
|
90
|
+
recent.sort((a, b) => a - b)
|
|
91
|
+
const value = recent.length ? recent[Math.min(recent.length - 1, Math.floor(recent.length * 0.99))]! : HIT_MS
|
|
92
|
+
p99[i] = value
|
|
93
|
+
// Hit rate is per arrival: only requests that arrive before the refill can miss.
|
|
94
|
+
hitRate[i] = t >= 0 && t < filled ? 0 : 1
|
|
95
|
+
peak = Math.max(peak, value)
|
|
96
|
+
}
|
|
97
|
+
return { inUse, queue, p99, hitRate, queries, peak }
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
function lowerBound(items: { at: number }[], t: number): number {
|
|
101
|
+
let lo = 0, hi = items.length
|
|
102
|
+
while (lo < hi) {
|
|
103
|
+
const mid = (lo + hi) >> 1
|
|
104
|
+
if (items[mid]!.at < t) lo = mid + 1
|
|
105
|
+
else hi = mid
|
|
106
|
+
}
|
|
107
|
+
return lo
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
// ── Drawing helpers ─────────────────────────────────────────────────────────
|
|
111
|
+
|
|
112
|
+
type Align = 'left' | 'right' | 'center'
|
|
113
|
+
interface LabelStyle { size?: number; font?: 'sans' | 'mono' | 'serif'; color?: ColorInput; weight?: 400 | 600 | 700; align?: Align; caps?: boolean }
|
|
114
|
+
|
|
115
|
+
function label(content: string, x: number, y: number, style: LabelStyle = {}): Node {
|
|
116
|
+
const node = text(content, {
|
|
117
|
+
size: style.size ?? 18, font: style.font ?? 'sans', color: style.color ?? 'ink', weight: style.weight ?? 400,
|
|
118
|
+
uppercase: style.caps, tracking: style.caps ? 0.08 : 0,
|
|
119
|
+
})
|
|
120
|
+
const width = node.bounds().width
|
|
121
|
+
const align = style.align ?? 'left'
|
|
122
|
+
return node.at(align === 'left' ? x + width / 2 : align === 'right' ? x - width / 2 : x, y)
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
interface BoxSpec { x: number; y: number; w: number; h: number; title: string; kind: string }
|
|
126
|
+
|
|
127
|
+
const LB: BoxSpec = { x: -880, y: -398, w: 300, h: 214, title: 'Load balancer', kind: 'L7, 4 nodes' }
|
|
128
|
+
const SERVICE: BoxSpec = { x: -440, y: -398, w: 320, h: 214, title: 'Catalog service', kind: '24 pods, one pool per fleet' }
|
|
129
|
+
const REDIS: BoxSpec = { x: 60, y: -484, w: 300, h: 158, title: 'Redis', kind: 'primary, in-memory' }
|
|
130
|
+
const POSTGRES: BoxSpec = { x: 60, y: -296, w: 300, h: 214, title: 'Postgres', kind: 'primary, 40 connections' }
|
|
131
|
+
const KEY: BoxSpec = { x: 500, y: -398, w: 380, h: 214, title: 'Hot key', kind: 'product:4821, read by every page' }
|
|
132
|
+
|
|
133
|
+
function box(spec: BoxSpec, accent: ColorInput = 'faint'): Node {
|
|
134
|
+
const group = new Node()
|
|
135
|
+
group.add(rect(spec.w, spec.h, { fill: 'surface', stroke: accent, width: 1.4, radius: 8 }).at(spec.x + spec.w / 2, spec.y + spec.h / 2))
|
|
136
|
+
group.add(label(spec.title, spec.x + 18, spec.y + 28, { size: 25, weight: 600 }))
|
|
137
|
+
group.add(label(spec.kind, spec.x + 18, spec.y + 56, { size: 16, color: 'dim', font: 'mono' }))
|
|
138
|
+
return group
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
function rowsFor(spec: BoxSpec, rows: readonly (readonly [string, string, ColorInput?])[]): Node[] {
|
|
142
|
+
return rows.flatMap(([name, value, color], i) => {
|
|
143
|
+
const y = spec.y + 92 + i * 30
|
|
144
|
+
return [
|
|
145
|
+
label(name, spec.x + 18, y, { size: 18, color: 'dim' }),
|
|
146
|
+
label(value, spec.x + spec.w - 18, y, { size: 20, font: 'mono', color: color ?? 'ink', align: 'right' }),
|
|
147
|
+
]
|
|
148
|
+
})
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
const elbow = (a: Vec, b: Vec, r = 14): Path => {
|
|
152
|
+
const mid = (a[0] + b[0]) / 2
|
|
153
|
+
const dy = Math.sign(b[1] - a[1])
|
|
154
|
+
if (dy === 0) return parseSvgPath(`M${a[0]} ${a[1]}L${b[0]} ${b[1]}`)
|
|
155
|
+
return parseSvgPath(`M${a[0]} ${a[1]}L${mid - r} ${a[1]}Q${mid} ${a[1]} ${mid} ${a[1] + dy * r}L${mid} ${b[1] - dy * r}Q${mid} ${b[1]} ${mid + r} ${b[1]}L${b[0]} ${b[1]}`)
|
|
156
|
+
}
|
|
157
|
+
|
|
158
|
+
export default film({
|
|
159
|
+
title: 'One key expires',
|
|
160
|
+
description: 'A live service diagram: a hot cache key expires at 12,000 requests per second and a stampede hits the database.',
|
|
161
|
+
fps: 60,
|
|
162
|
+
bleed: true,
|
|
163
|
+
bloom: 0.08,
|
|
164
|
+
}, (s) => {
|
|
165
|
+
const stampede = simulate(false)
|
|
166
|
+
const coalesced = simulate(true)
|
|
167
|
+
const missCount = stampede.queries
|
|
168
|
+
|
|
169
|
+
const simClock = s.value(SIM_START)
|
|
170
|
+
const useSecond = s.value(0)
|
|
171
|
+
const packet = s.value(0)
|
|
172
|
+
const packetAlpha = s.value(0)
|
|
173
|
+
const isMiss = s.value(0)
|
|
174
|
+
const axisMax = s.value(2.5)
|
|
175
|
+
|
|
176
|
+
const at = (values: Float32Array) => values[Math.max(0, Math.min(SIM_LEN - 1, Math.floor(simClock.value - SIM_START)))]!
|
|
177
|
+
const current = () => (useSecond.value >= 0.5 ? coalesced : stampede)
|
|
178
|
+
|
|
179
|
+
// ── The wires ───────────────────────────────────────────────────────────
|
|
180
|
+
|
|
181
|
+
const midRight = (spec: BoxSpec): Vec => [spec.x + spec.w, spec.y + spec.h / 2]
|
|
182
|
+
const midLeft = (spec: BoxSpec): Vec => [spec.x, spec.y + spec.h / 2]
|
|
183
|
+
const wireIn: Path = parseSvgPath(`M-960 ${LB.y + LB.h / 2}L${LB.x} ${LB.y + LB.h / 2}`)
|
|
184
|
+
const wireLb = elbow(midRight(LB), midLeft(SERVICE))
|
|
185
|
+
const wireRedis = elbow([SERVICE.x + SERVICE.w, SERVICE.y + 76], midLeft(REDIS))
|
|
186
|
+
const wirePg = elbow([SERVICE.x + SERVICE.w, SERVICE.y + 138], midLeft(POSTGRES))
|
|
187
|
+
|
|
188
|
+
const flows = dynamic((t) => {
|
|
189
|
+
const run = current()
|
|
190
|
+
const hits = at(run.hitRate)
|
|
191
|
+
const use = at(run.inUse) / POOL
|
|
192
|
+
const waiting = at(run.queue)
|
|
193
|
+
const drawn = (path: Path, rate: number, color: ColorInput, width: number): Node[] => [
|
|
194
|
+
new Node(path).stroke('faint', 1.4),
|
|
195
|
+
new Node(path).stroke(color, 1.6 + width * rate, rate > 0.01 ? 0.92 : 0).dash([9, 15], -t * 96).glow(rate > 0.2 ? 4 : 0, color as string),
|
|
196
|
+
]
|
|
197
|
+
const heat = waiting > 0 ? 'red' : 'orange'
|
|
198
|
+
return [
|
|
199
|
+
...drawn(wireIn, 1, 'teal', 2.4),
|
|
200
|
+
...drawn(wireLb, 1, 'teal', 2.4),
|
|
201
|
+
...drawn(wireRedis, Math.max(0.08, hits), 'teal', 2.4),
|
|
202
|
+
...drawn(wirePg, use, heat, 5),
|
|
203
|
+
]
|
|
204
|
+
})
|
|
205
|
+
|
|
206
|
+
const wireKey = line([REDIS.x + REDIS.w, midLeft(REDIS)[1]], [KEY.x + 60, KEY.y], { stroke: 'faint', width: 1.3, dash: [3, 7] })
|
|
207
|
+
const wireLabels = new Node().add(
|
|
208
|
+
label('0.15 ms', (midRight(LB)[0] + midLeft(SERVICE)[0]) / 2, midLeft(SERVICE)[1] - 16, { size: 16, font: 'mono', color: 'dim', align: 'center' }),
|
|
209
|
+
label('12,000 req/s', -874, LB.y - 22, { size: 18, font: 'mono', color: 'dim' }),
|
|
210
|
+
)
|
|
211
|
+
|
|
212
|
+
// ── The boxes, with live metrics ────────────────────────────────────────
|
|
213
|
+
|
|
214
|
+
const lbBox = box(LB), serviceBox = box(SERVICE), redisBox = box(REDIS), keyBox = box(KEY)
|
|
215
|
+
const pgFrame = dynamic(() => {
|
|
216
|
+
const waiting = at(current().queue)
|
|
217
|
+
return box(POSTGRES, waiting > 0 ? 'red' : 'faint')
|
|
218
|
+
})
|
|
219
|
+
const metrics = dynamic(() => {
|
|
220
|
+
const run = current()
|
|
221
|
+
const p99 = at(run.p99)
|
|
222
|
+
const hits = at(run.hitRate)
|
|
223
|
+
const use = at(run.inUse)
|
|
224
|
+
const waiting = at(run.queue)
|
|
225
|
+
const now = simClock.value
|
|
226
|
+
const missing = hits < 0.999
|
|
227
|
+
const items: Node[] = [
|
|
228
|
+
...rowsFor(LB, [['requests', '12,000/s'], ['p99, last 50 ms', `${p99.toFixed(1).padStart(6, ' ')} ms`, p99 > 100 ? 'red' : p99 > 20 ? 'orange' : 'ink'], ['in flight', String(Math.round(RATE * HIT_MS + use + waiting)).padStart(4, ' ')], ['errors', '0.00%']]),
|
|
229
|
+
...rowsFor(SERVICE, [['workers busy', `${Math.min(960, Math.round(26 + (use + waiting) * 2))} of 960`], ['cache hit rate', `${(hits * 100).toFixed(1).padStart(5, ' ')}%`, hits < 0.99 ? 'orange' : 'teal'], ['waiting on cache', String(Math.round(useSecond.value >= 0.5 && missing ? RATE * now : 0))], ['handler, p50', '0.40 ms']]),
|
|
230
|
+
...rowsFor(REDIS, [['GET, p50', '0.35 ms'], ['hit rate', `${(hits * 100).toFixed(1).padStart(5, ' ')}%`, hits < 0.99 ? 'orange' : 'teal']]),
|
|
231
|
+
...rowsFor(POSTGRES, [['connections', `${String(Math.round(use)).padStart(2, ' ')} of ${POOL}`, use >= POOL ? 'red' : 'ink'], ['queued', String(Math.round(waiting)).padStart(3, ' '), waiting > 0 ? 'red' : 'ink'], ['query time', `${QUERY_MS}.0 ms`]]),
|
|
232
|
+
]
|
|
233
|
+
// Pool meter along the bottom edge of the database box.
|
|
234
|
+
const meterY = POSTGRES.y + POSTGRES.h - 18
|
|
235
|
+
const meterW = POSTGRES.w - 36
|
|
236
|
+
items.push(
|
|
237
|
+
rect(meterW, 8, { fill: 'grid', stroke: null, radius: 2 }).at(POSTGRES.x + 18 + meterW / 2, meterY),
|
|
238
|
+
)
|
|
239
|
+
const share = Math.min(1, use / POOL)
|
|
240
|
+
if (share > 0) items.push(rect(meterW * share, 8, { fill: waiting > 0 ? 'red' : 'orange', stroke: null, radius: 2 }).at(POSTGRES.x + 18 + (meterW * share) / 2, meterY))
|
|
241
|
+
// The key's own state.
|
|
242
|
+
const ttl = now < 0 ? -now : 0
|
|
243
|
+
const state = now < 0 ? 'CACHED' : missing ? 'EXPIRED' : 'REFILLED'
|
|
244
|
+
const stateColor = missing ? 'red' : 'teal'
|
|
245
|
+
items.push(
|
|
246
|
+
...rowsFor(KEY, [
|
|
247
|
+
['state', state, stateColor],
|
|
248
|
+
['TTL left', now < 0 ? `${ttl.toFixed(0).padStart(3, ' ')} ms` : ' 0 ms'],
|
|
249
|
+
['single flight', useSecond.value >= 0.5 ? 'ON' : 'OFF', useSecond.value >= 0.5 ? 'teal' : 'dim'],
|
|
250
|
+
['queries for this key', String(queriesSoFar()).padStart(4, ' '), useSecond.value >= 0.5 ? 'teal' : queriesSoFar() > 1 ? 'red' : 'ink'],
|
|
251
|
+
]),
|
|
252
|
+
)
|
|
253
|
+
return items
|
|
254
|
+
})
|
|
255
|
+
const queriesSoFar = () => {
|
|
256
|
+
const run = current()
|
|
257
|
+
if (simClock.value < 0) return 0
|
|
258
|
+
if (run === coalesced) return 1
|
|
259
|
+
return Math.min(run.queries, Math.round(simClock.value * RATE) + 1)
|
|
260
|
+
}
|
|
261
|
+
|
|
262
|
+
// ── A single request, traced ────────────────────────────────────────────
|
|
263
|
+
|
|
264
|
+
const spots: Vec[] = [
|
|
265
|
+
[LB.x + LB.w * 0.5, midLeft(LB)[1]],
|
|
266
|
+
midRight(LB), midLeft(SERVICE),
|
|
267
|
+
[SERVICE.x + SERVICE.w / 2, midLeft(SERVICE)[1]],
|
|
268
|
+
]
|
|
269
|
+
const pgPoint: Vec = midLeft(POSTGRES)
|
|
270
|
+
|
|
271
|
+
/** Where the traced request is at a request-local time, for hit or miss. */
|
|
272
|
+
const tracePosition = (m: number, miss: boolean): Vec => {
|
|
273
|
+
const steps: { end: number; along?: Path; reverse?: boolean; holdAt?: Vec }[] = []
|
|
274
|
+
let clock = 0
|
|
275
|
+
const push = (ms: number, step: { along?: Path; reverse?: boolean; holdAt?: Vec }) => {
|
|
276
|
+
clock += ms
|
|
277
|
+
steps.push({ end: clock, ...step })
|
|
278
|
+
}
|
|
279
|
+
push(0.2, { holdAt: spots[0] })
|
|
280
|
+
push(0.15, { along: wireLb })
|
|
281
|
+
push(0.4, { holdAt: spots[3] })
|
|
282
|
+
push(0.175, { along: wireRedis })
|
|
283
|
+
push(0.175, { along: wireRedis, reverse: true })
|
|
284
|
+
if (miss) {
|
|
285
|
+
push(QUERY_MS * 0.02, { along: wirePg })
|
|
286
|
+
push(QUERY_MS * 0.96, { holdAt: pgPoint })
|
|
287
|
+
push(QUERY_MS * 0.02, { along: wirePg, reverse: true })
|
|
288
|
+
push(0.15, { along: wireRedis })
|
|
289
|
+
push(0.15, { along: wireRedis, reverse: true })
|
|
290
|
+
}
|
|
291
|
+
push(0.9, { holdAt: spots[3] })
|
|
292
|
+
push(0.1, { along: wireLb, reverse: true })
|
|
293
|
+
let start = 0
|
|
294
|
+
for (const step of steps) {
|
|
295
|
+
if (m <= step.end) {
|
|
296
|
+
const f = step.end > start ? (m - start) / (step.end - start) : 1
|
|
297
|
+
if (step.holdAt) return step.holdAt
|
|
298
|
+
const u = step.reverse ? 1 - f : f
|
|
299
|
+
return pointAt(step.along!, u)
|
|
300
|
+
}
|
|
301
|
+
start = step.end
|
|
302
|
+
}
|
|
303
|
+
return midRight(LB)
|
|
304
|
+
}
|
|
305
|
+
const tracer = dynamic(() => {
|
|
306
|
+
const a = packetAlpha.value
|
|
307
|
+
if (a <= 0) return null
|
|
308
|
+
const miss = isMiss.value >= 0.5
|
|
309
|
+
const m = packet.value
|
|
310
|
+
return dot(9, miss ? 'orange' : 'yellow').at(tracePosition(m, miss)).glow(12).opacity(a)
|
|
311
|
+
})
|
|
312
|
+
|
|
313
|
+
// ── The waterfall ───────────────────────────────────────────────────────
|
|
314
|
+
|
|
315
|
+
const WF = { x: -880, y: 42, w: 780, rowH: 40, labelW: 190 }
|
|
316
|
+
const waterfall = dynamic(() => {
|
|
317
|
+
const items: Node[] = []
|
|
318
|
+
const miss = isMiss.value >= 0.5
|
|
319
|
+
const m = packet.value
|
|
320
|
+
const scale = (WF.w - WF.labelW - 76) / axisMax.value
|
|
321
|
+
const x0 = WF.x + WF.labelW
|
|
322
|
+
let clock = 0
|
|
323
|
+
const list = SPANS.filter((span) => miss || span.hit)
|
|
324
|
+
list.forEach((span, i) => {
|
|
325
|
+
const y = WF.y + 46 + i * WF.rowH
|
|
326
|
+
const shown = Math.max(0, Math.min(span.ms, m - clock))
|
|
327
|
+
items.push(label(span.name, WF.x, y, { size: 19, color: shown > 0 ? 'ink' : 'dim' }))
|
|
328
|
+
items.push(rect(WF.w - WF.labelW, 1, { fill: 'grid', stroke: null }).at(x0 + (WF.w - WF.labelW) / 2, y + WF.rowH / 2))
|
|
329
|
+
if (shown > 0) {
|
|
330
|
+
const width = Math.max(2, shown * scale)
|
|
331
|
+
const color = span.name === 'postgres query' ? 'orange' : span.name.startsWith('redis') ? 'teal' : 'blue'
|
|
332
|
+
items.push(rect(width, 20, { fill: color, stroke: null, radius: 2 }).at(x0 + clock * scale + width / 2, y))
|
|
333
|
+
items.push(label(`${shown.toFixed(2)}`, x0 + clock * scale + width + 8, y, { size: 16, font: 'mono', color: 'dim' }))
|
|
334
|
+
}
|
|
335
|
+
clock += span.ms
|
|
336
|
+
})
|
|
337
|
+
return items
|
|
338
|
+
})
|
|
339
|
+
const waterfallHead = dynamic(() => {
|
|
340
|
+
const miss = isMiss.value >= 0.5
|
|
341
|
+
const total = miss ? MISS_MS : HIT_MS
|
|
342
|
+
const m = Math.min(total, packet.value)
|
|
343
|
+
return [
|
|
344
|
+
label(miss ? 'One request, cache miss' : 'One request, cache hit', WF.x, WF.y, { size: 19, color: 'dim', caps: true, weight: 600 }),
|
|
345
|
+
label(`${m.toFixed(2).padStart(6, ' ')} ms`, WF.x + WF.w, WF.y - 6, { size: 34, font: 'mono', color: miss ? 'orange' : 'yellow', align: 'right' }),
|
|
346
|
+
]
|
|
347
|
+
})
|
|
348
|
+
|
|
349
|
+
// ── The latency chart ───────────────────────────────────────────────────
|
|
350
|
+
|
|
351
|
+
const CH = { x: 60, y: 86, w: 820, h: 360, max: 600 }
|
|
352
|
+
const chartX = (t: number) => CH.x + ((t - SIM_START) / SIM_LEN) * CH.w
|
|
353
|
+
const chartY = (v: number) => CH.y + CH.h - (Math.min(CH.max, v) / CH.max) * CH.h
|
|
354
|
+
const chartFrame = new Node()
|
|
355
|
+
for (const v of [0, 100, 200, 300, 400, 500, 600]) {
|
|
356
|
+
chartFrame.add(line([CH.x, chartY(v)], [CH.x + CH.w, chartY(v)], { stroke: v === 0 ? 'faint' : 'grid', width: 1.2 }))
|
|
357
|
+
chartFrame.add(label(String(v), CH.x + CH.w + 8, chartY(v), { size: 16, font: 'mono', color: 'dim' }))
|
|
358
|
+
}
|
|
359
|
+
for (const t of [0, 200, 400, 600]) {
|
|
360
|
+
chartFrame.add(line([chartX(t), CH.y + CH.h], [chartX(t), CH.y + CH.h + 6], { stroke: 'faint', width: 1.2 }))
|
|
361
|
+
chartFrame.add(label(`${t} ms`, chartX(t), CH.y + CH.h + 24, { size: 16, font: 'mono', color: 'dim', align: 'center' }))
|
|
362
|
+
}
|
|
363
|
+
chartFrame.add(label('p99 latency, ms, measured at the load balancer', CH.x, CH.y - 44, { size: 19, color: 'dim', caps: true, weight: 600 }))
|
|
364
|
+
chartFrame.add(line([chartX(0), CH.y], [chartX(0), CH.y + CH.h], { stroke: 'yellow', width: 1.2, dash: [4, 6] }))
|
|
365
|
+
chartFrame.add(label('key expires', chartX(0) + 8, CH.y + 12, { size: 16, color: 'yellow' }))
|
|
366
|
+
|
|
367
|
+
const chartLines = dynamic(() => {
|
|
368
|
+
const now = Math.floor(simClock.value - SIM_START)
|
|
369
|
+
const series = (run: Run, end: number, color: ColorInput, width: number): Node | null => {
|
|
370
|
+
const points: Vec[] = []
|
|
371
|
+
for (let i = 0; i <= Math.min(SIM_LEN - 1, end); i += 2) points.push([chartX(SIM_START + i), chartY(run.p99[i]!)])
|
|
372
|
+
return points.length > 1 ? new Node(polyPath(points)).stroke(color, width) : null
|
|
373
|
+
}
|
|
374
|
+
const showSecond = useSecond.value >= 0.5
|
|
375
|
+
const items = [
|
|
376
|
+
series(stampede, showSecond ? SIM_LEN - 1 : now, showSecond ? 'red' : 'red', showSecond ? 2.4 : 3.2),
|
|
377
|
+
showSecond ? series(coalesced, now, 'teal', 3.4) : null,
|
|
378
|
+
].filter((node): node is Node => node !== null)
|
|
379
|
+
return items
|
|
380
|
+
})
|
|
381
|
+
|
|
382
|
+
const peakA = label(`no protection: ${stampede.peak.toFixed(0)} ms peak, ${missCount} queries`, CH.x + CH.w - 6, CH.y + 18, { size: 19, font: 'mono', color: 'red', align: 'right' })
|
|
383
|
+
const peakB = label(`single flight: ${coalesced.peak.toFixed(0)} ms peak, ${coalesced.queries} query`, CH.x + CH.w - 6, CH.y + 46, { size: 19, font: 'mono', color: 'teal', align: 'right' })
|
|
384
|
+
|
|
385
|
+
// ── Header and footer ───────────────────────────────────────────────────
|
|
386
|
+
|
|
387
|
+
const title = label('One key expires.', -880, -492, { size: 62, font: 'serif' })
|
|
388
|
+
const route = label('GET /products/:sku', 880, -492, { size: 22, font: 'mono', color: 'dim', align: 'right' })
|
|
389
|
+
const caveat = label('Illustrative hop times. Queueing is simulated per request, in this film\'s source.', 880, 510, { size: 16, color: 'faint', align: 'right' })
|
|
390
|
+
const ratio = label(`${(MISS_MS / HIT_MS).toFixed(0)} times slower, for one request`, WF.x + WF.labelW, WF.y + 46 + 8 * WF.rowH, { size: 21, font: 'serif', color: 'orange' })
|
|
391
|
+
|
|
392
|
+
// ── Timeline ────────────────────────────────────────────────────────────
|
|
393
|
+
|
|
394
|
+
s.add(flows)
|
|
395
|
+
flows.opacity(0)
|
|
396
|
+
s.chapter('The system')
|
|
397
|
+
s.play(write(title), fade(flows, 1), fadeIn([lbBox, serviceBox, redisBox, keyBox, pgFrame], { lag: 0.1 }), { duration: 1.6 })
|
|
398
|
+
s.add(chartFrame, wireKey)
|
|
399
|
+
s.play(fadeIn([metrics, wireLabels, route, caveat]), draw(chartFrame, { lag: 0.01 }), draw(wireKey), { duration: 1.1 })
|
|
400
|
+
s.wait(1)
|
|
401
|
+
|
|
402
|
+
s.chapter('One hit')
|
|
403
|
+
s.add(waterfall, waterfallHead, tracer)
|
|
404
|
+
s.play(fadeIn([waterfall, waterfallHead]), packetAlpha.to(1), { duration: 0.5 })
|
|
405
|
+
s.play(packet.to(HIT_MS, { ease: linear }), { duration: 4.2 })
|
|
406
|
+
s.wait(0.8)
|
|
407
|
+
|
|
408
|
+
s.chapter('One miss')
|
|
409
|
+
s.play(packetAlpha.to(0), { duration: 0.3 })
|
|
410
|
+
isMiss.set(1)
|
|
411
|
+
packet.set(0)
|
|
412
|
+
s.play(packetAlpha.to(1), axisMax.to(MISS_MS * 1.04, { ease: smoother }), { duration: 0.9 })
|
|
413
|
+
s.play(packet.to(MISS_MS, { ease: linear }), { duration: 5.8 })
|
|
414
|
+
s.play(fadeIn(ratio, { shift: [0, 6] }), { duration: 0.7 })
|
|
415
|
+
s.wait(1)
|
|
416
|
+
|
|
417
|
+
s.chapter('Twelve thousand at once')
|
|
418
|
+
s.play(packetAlpha.to(0), { duration: 0.4 })
|
|
419
|
+
s.add(chartLines)
|
|
420
|
+
s.play(fadeIn(chartLines), { duration: 0.2 })
|
|
421
|
+
s.play(simClock.to(SIM_END - 1, { ease: linear }), { duration: 13 })
|
|
422
|
+
s.play(fadeIn(peakA), { duration: 0.6 })
|
|
423
|
+
s.wait(1)
|
|
424
|
+
|
|
425
|
+
s.chapter('Single flight')
|
|
426
|
+
s.play(simClock.to(SIM_START, { ease: smoother }), { duration: 1.2 })
|
|
427
|
+
useSecond.set(1)
|
|
428
|
+
s.play(simClock.to(SIM_END - 1, { ease: linear }), { duration: 11 })
|
|
429
|
+
s.play(fadeIn(peakB), { duration: 0.7 })
|
|
430
|
+
s.wait(3)
|
|
431
|
+
})
|
|
@@ -0,0 +1,132 @@
|
|
|
1
|
+
[
|
|
2
|
+
{
|
|
3
|
+
"id": "vizmatic-title",
|
|
4
|
+
"title": "Vizmatic",
|
|
5
|
+
"summary": "Lit curves gather into the wordmark and let go again, as a seamless ten-second loop.",
|
|
6
|
+
"topic": "Brand",
|
|
7
|
+
"duration": 10,
|
|
8
|
+
"posterTime": 0.8,
|
|
9
|
+
"featured": false,
|
|
10
|
+
"look": "midnight"
|
|
11
|
+
},
|
|
12
|
+
{
|
|
13
|
+
"id": "fourier-epicycles",
|
|
14
|
+
"title": "A drawing is a sum of circles",
|
|
15
|
+
"summary": "A real Fourier transform of an ampersand, redrawn by a chain of rotating arrows as the term count grows from 1 to 200.",
|
|
16
|
+
"topic": "Mathematics",
|
|
17
|
+
"duration": 48.15,
|
|
18
|
+
"posterTime": 30.5,
|
|
19
|
+
"featured": true,
|
|
20
|
+
"look": "midnight"
|
|
21
|
+
},
|
|
22
|
+
{
|
|
23
|
+
"id": "linear-maps",
|
|
24
|
+
"title": "A matrix moves the whole plane",
|
|
25
|
+
"summary": "A grid under one matrix: basis arrows, the determinant as area, and the two directions that stay on their lines.",
|
|
26
|
+
"topic": "Mathematics",
|
|
27
|
+
"duration": 37.6,
|
|
28
|
+
"posterTime": 36,
|
|
29
|
+
"featured": true,
|
|
30
|
+
"look": "midnight"
|
|
31
|
+
},
|
|
32
|
+
{
|
|
33
|
+
"id": "complex-maps",
|
|
34
|
+
"title": "The grid bends, its right angles survive",
|
|
35
|
+
"summary": "A grid unfolds under z squared and curls into a disk under a Mobius map, with the angle at every crossing measured live.",
|
|
36
|
+
"topic": "Mathematics",
|
|
37
|
+
"duration": 40.5,
|
|
38
|
+
"posterTime": 38.5,
|
|
39
|
+
"featured": true,
|
|
40
|
+
"look": "midnight"
|
|
41
|
+
},
|
|
42
|
+
{
|
|
43
|
+
"id": "euler-circle",
|
|
44
|
+
"title": "One point, two shadows",
|
|
45
|
+
"summary": "A point sweeps the unit circle, sine and cosine trace themselves, and the formula collapses into Euler's identity.",
|
|
46
|
+
"topic": "Mathematics",
|
|
47
|
+
"duration": 34.8,
|
|
48
|
+
"posterTime": 15.5,
|
|
49
|
+
"featured": true,
|
|
50
|
+
"look": "midnight"
|
|
51
|
+
},
|
|
52
|
+
{
|
|
53
|
+
"id": "gradient-descent",
|
|
54
|
+
"title": "Downhill, one step at a time",
|
|
55
|
+
"summary": "Real gradient descent on a two-basin loss surface: two starts 0.12 apart travel together, then finish in different minima.",
|
|
56
|
+
"topic": "Machine learning",
|
|
57
|
+
"duration": 38.5,
|
|
58
|
+
"posterTime": 28,
|
|
59
|
+
"featured": true,
|
|
60
|
+
"look": "midnight"
|
|
61
|
+
},
|
|
62
|
+
{
|
|
63
|
+
"id": "attention",
|
|
64
|
+
"title": "Attention, computed",
|
|
65
|
+
"summary": "Queries, keys, and values produce a live heatmap as softmax(QK^T / sqrt(d)) V builds up term by term.",
|
|
66
|
+
"topic": "Machine learning",
|
|
67
|
+
"duration": 32.9,
|
|
68
|
+
"posterTime": 31.5,
|
|
69
|
+
"featured": true,
|
|
70
|
+
"look": "midnight"
|
|
71
|
+
},
|
|
72
|
+
{
|
|
73
|
+
"id": "lorenz",
|
|
74
|
+
"title": "The rules are exact, the future is not",
|
|
75
|
+
"summary": "The Lorenz system integrated with real numbers: two starts a hair apart part ways, then 72 fill the butterfly.",
|
|
76
|
+
"topic": "Physics",
|
|
77
|
+
"duration": 44,
|
|
78
|
+
"posterTime": 41,
|
|
79
|
+
"featured": true,
|
|
80
|
+
"look": "midnight"
|
|
81
|
+
},
|
|
82
|
+
{
|
|
83
|
+
"id": "central-limit",
|
|
84
|
+
"title": "Twelve coin flips, nine hundred times",
|
|
85
|
+
"summary": "A Galton board settles into a histogram that meets the Gaussian curve, with mean and deviation measured from the balls.",
|
|
86
|
+
"topic": "Statistics",
|
|
87
|
+
"duration": 43.82,
|
|
88
|
+
"posterTime": 42.8,
|
|
89
|
+
"featured": false,
|
|
90
|
+
"look": "midnight"
|
|
91
|
+
},
|
|
92
|
+
{
|
|
93
|
+
"id": "pythagoras",
|
|
94
|
+
"title": "Move the pieces, keep the square",
|
|
95
|
+
"summary": "A proof by rearrangement: four triangles slide inside a square, and the leftover area writes the theorem.",
|
|
96
|
+
"topic": "Mathematics",
|
|
97
|
+
"duration": 27.45,
|
|
98
|
+
"posterTime": 26,
|
|
99
|
+
"featured": false,
|
|
100
|
+
"look": "midnight"
|
|
101
|
+
},
|
|
102
|
+
{
|
|
103
|
+
"id": "taylor-series",
|
|
104
|
+
"title": "Sine, from what it does at zero",
|
|
105
|
+
"summary": "Polynomials hug the sine curve further out as each term grows in, with the trusted range measured live.",
|
|
106
|
+
"topic": "Mathematics",
|
|
107
|
+
"duration": 24.4,
|
|
108
|
+
"posterTime": 16.5,
|
|
109
|
+
"featured": false,
|
|
110
|
+
"look": "midnight"
|
|
111
|
+
},
|
|
112
|
+
{
|
|
113
|
+
"id": "cache-miss",
|
|
114
|
+
"title": "One key expires",
|
|
115
|
+
"summary": "A dense service diagram comes alive: a hot key expires at 12,000 requests per second, and a simulated stampede hits Postgres.",
|
|
116
|
+
"topic": "Systems",
|
|
117
|
+
"duration": 49,
|
|
118
|
+
"posterTime": 30,
|
|
119
|
+
"featured": true,
|
|
120
|
+
"look": "midnight"
|
|
121
|
+
},
|
|
122
|
+
{
|
|
123
|
+
"id": "deck-example",
|
|
124
|
+
"title": "Why we rebuilt the renderer",
|
|
125
|
+
"summary": "A six-chapter talk that plays in stepped mode, with a live timeline and measured results.",
|
|
126
|
+
"topic": "Presentation",
|
|
127
|
+
"duration": 33,
|
|
128
|
+
"posterTime": 16,
|
|
129
|
+
"featured": false,
|
|
130
|
+
"look": "paper"
|
|
131
|
+
}
|
|
132
|
+
]
|