Share
Embed
๐ง๐ช React Brusselsย 2022
Deep diving on Concurrent React
Writing fluid user interfaces becomes increasingly challenging as application complexity increases. In this talk, weโll explore how proper scheduling improves your appโs experience by diving into some concurrent React features, understanding their rationales, and how they work under the hood.
Matheus Albuquerque PRO
October 14, 2022
Video
Transcript
108 slides
-
Salut, React Brussels! ๐ ๐ง๐ช DEEP DIVING ON CONCURRENT REACT
โข THE 14TH OF OCTOBER, 2022. -
DEEP DIVING ON CONCURRENT REACT ๐ง๐ซ @techlabs ๐ฆ @ythecombinator ๐จ๐ป
@medallia โ ALL THE LINKS! ๐ค ๐ง๐ท Matheus Albuquerque -
DEEP DIVING ON CONCURRENT REACT ๐บ DEEP DIVE! LETโS DISCUSS
MORE IN THE AFTER CONF! โ ALL THE LINKS! ๐ค -
#QUESTION ๐ค Iโve been looking forward so much to this
conference! Especially becauseโฆ -
PERFOMANCE PERCEIVED LOAD SPEED HOW QUICKLY A PAGE CAN LOAD
AND RENDER ALL OF ITS VISUAL ELEMENTS TO THE SCREEN SMOOTHNESS DO TRANSITIONS & ANIMATIONS RENDER AT A CONSISTENT FRAME RATE AND FLOW FLUIDLY? LOAD RESPONSIVENESS HOW QUICKLY A PAGE CAN LOAD/RUN ANY REQUIRED JS IN ORDER FOR COMPONENTS TO RESPOND TO USER INTERACTION RUNTIME RESPONSIVENESS AFTER THE PAGE LOAD, HOW QUICKLY CAN THE PAGE RESPOND TO USER INTERACTION? -
PERFOMANCE PERCEIVED LOAD SPEED HOW QUICKLY A PAGE CAN LOAD
AND RENDER ALL OF ITS VISUAL ELEMENTS TO THE SCREEN LOAD RESPONSIVENESS HOW QUICKLY A PAGE CAN LOAD/RUN ANY REQUIRED JS IN ORDER FOR COMPONENTS TO RESPOND TO USER INTERACTION RUNTIME RESPONSIVENESS AFTER THE PAGE LOAD, HOW QUICKLY CAN THE PAGE RESPOND TO USER INTERACTION? SMOOTHNESS DO TRANSITIONS & ANIMATIONS RENDER AT A CONSISTENT FRAME RATE AND FLOW FLUIDLY? -
#RESEARCH ๐ Phone users experience slow First Input Delay on
7x more websites. โโWeb Almanac By HTTP Archive, 2021 -
RESEARCH RESULTS: โ LONG TASKS DELAYED TTI โ MOBILE HAD
UP TO ห12X LONGER LONG TASKS โ OLDER DEVICES COULD BE SPENDING HALF OF THEIR LOAD-TIME ON LONG TASKS โโAKAMAI AND CHROME RESEARCH, 2017 LONG TASKS -
#QUESTION ๐ค If you were to summarize Concurrent React in
one word/expression, whatโd be your pick? -
#QUESTION ๐ค If you were to summarize Concurrent React in
one word/expression, whatโd be your pick? e.g. fibers = units of work Concurrent React = ??? -
DEEP DIVING ON CONCURRENT REACT 1st/2nd/3rd ANSWERS โ MEDALLIA SWAG
OTHERS โ STICKERS ๐ If you were to summarize Concurrent React in one word/expression, whatโd be your pick? -
LONG TASKS โ IF A TASK TAKES MORE THAN 50
MS, USER INPUT FEELS DELAYED โ BASED ON THE USER-CENTRIC PERFORMANCE MODEL CALLED RAIL โ THEY TAKE LONG AND BLOCK OTHER TASKS -
WORKERS โ DATA EXCHANGE IS THROUGH MESSAGE-PASSING โ NO ACCESS
TO ANY VARIABLES/CODE FROM THE PAGE THAT CREATED THEM OR VICE VERSA โ NO ACCESS TO THE DOM, MAKING UI UPDATES FROM A WORKER BARELY IMPOSSIBLE โ TWO MODELS: ACTORS & SHARED MEMORY ๐บ -
๐ญ ACTORS WORKERS โ EACH ACTOR FULLY OWNS THE DATA
IT IS OPERATING ON โ ACTORS CAN ONLY SEND/REACT TO MESSAGES โ THE MAIN THREAD IS ACTOR THAT OWNS THE DOM/UI โ postMessage HAS NO BUILT-IN UNDERSTANDING OF REQUEST AND RESPONSE โ BALANCE: MOVING CODE TO A WORKER VS COMMUNICATION OVERHEAD/WORKER BEING BUSY ๐ SHARED MEMORY โ ONE DEDICATED TYPE: SharedArrayBuffer -
๐ญ ACTORS WORKERS ๐ SHARED MEMORY โ ONE DEDICATED TYPE:
SharedArrayBuffer โ IF SENT VIA postMessage, THE OTHER END GETS A HANDLE TO THE EXACT SAME MEMORY CHUNK โ MOST OF THE WEB APIS ARE BUILT NO CONCURRENT ACCESS TO OBJECTS IN MIND โ YOU BUILD YOUR OWN CONCURRENT DATA STRUCTURES โ NO DIRECT WAY OF WORKING ON FAMILIAR OBJECTS/ ARRAYS; JUST A SERIES OF BYTES ๐บ โ EACH ACTOR FULLY OWNS THE DATA IT IS OPERATING ON -
WEB ASSEMBLY โ THE BEST EXPERIENCE FOR SHARED-MEMORY MODEL โ
DOESNโT OFFER THE "COMFORT" OF JAVASCRIPT โ FASTER WHEN YOU STAY WITHIN WASM โ JAVASCRIPT IS OFTEN FASTER AT DOM AND HIGH- LEVEL UI LIBRARIES CAN BE MORE PERFORMANT THAN LOW-LEVEL WASM IMPLEMENTATIONS ๐บ -
WORKERS โ GOOD FOR DATA PROCESSING AND CRUNCHING NUMBERS โ
HARD TO USE FOR UI-RELATED STUFF โ HARDER THAN ADJUSTING WORK FOR A SCHEDULER -
#QUESTION ๐ค If you were to summarize Concurrent React in
one word/expression, whatโd be your pick? -
DEEP DIVING ON CONCURRENT REACT If you were to summarize
Concurrent React in one word/expression, whatโd be your pick? -
โ A COOPERATIVE MULTITASKING MODEL โ A SINGLE INTERRUPTIBLE RENDERING
THREAD โ RENDERING CAN BE INTERLEAVED WITH OTHER MAIN THREAD TASKS (AND OTHER REACT RENDERS) โ AN UPDATE CAN HAPPEN IN THE BACKGROUND WITHOUT BLOCKING THE RESPONSE TO NEW INPUT SCHEDULING IN REACT -
โ ORIGINAL RENDER TASK USER INPUT โ โ HIGHER PRIORITY
RENDER TASK โ RESUME ORIGINAL RENDER TASK -
โ IT YIELDS EXECUTION IS BACK TO THE MAIN THREAD
EVERY 5MS โ IT'S SMALLER THAN A SINGLE FRAME EVEN ON 120FPS, SO IT WON'T BLOCK ANIMATIONS โ IN PRACTICE, RENDERING IS INTERRUPTIBLE HEURISTICS -
PRIORITY TIMEOUT WHEN I m m ediate SYNCHRONOUSLY TASKS THAT
NEED TO RUN SYNCHRONOUSLY UserBlocking 250MS RESULTS OF A USER INTERACTION (E.G. A BUTTON CLICK) Normal 5S UPDATES THAT DONโT HAVE TO FEEL INSTANTANEOUS Low 10S TASKS THAT CAN BE DEFERRED BUT MUST STILL COMPLETE EVENTUALLY (E.G. AN ANALYTICS NOTIFICATION) Idle NO TIMEOUT TASKS THAT DO NOT HAVE TO RUN AT ALL (E.G. HIDDEN OFFSCREEN CONTENT) -
โ ONE LANE = ONE BIT IN A BITMASK โ
ONE UPDATE IN REACT = ONE LANE โ UPDATES IN THE SAME LANE RENDER IN THE SAME BATCH. DIFFERENT LANES, SEPARATE BATCHES. โ 31 LEVELS OF GRANULARITY (= ONE BITMASK) RENDER LANES ๐บ -
โ ALLOWS TO CHOOSE WHETHER TO RENDER MULTIPLE TRANSITIONS IN
A SINGLE BATCH OR RENDER THEM INDEPENDENTLY โ REDUCES OVERHEAD OF MULTIPLE LAYOUT PASSES, STYLE RECALCULATIONS, AND MULTIPLE PAINTS RENDER LANES ๐บ -
#QUESTION ๐ค How do we benefit from these in our
everyday projects? -
Scheduling in React [for the rest of us] DEEP DIVING
ON CONCURRENT REACT -
SCHEDULING IN REACT HANDLING LOTS OF DATA WITH THE useTransition
HOOK TACKLING WASTED RENDERS WITH THE useSyncExternalStore HOOK HYDRATION IMPROVEMENTS WITH SELECTIVE HYDRATION & CONCURRENT REACT PROFILER ENHANCEMENTS INSPECT TRANSITIONS, GET WARNS, AND MUCH MORE! -
๐ NON-PRACTICALโฆ โ RENDERING MANY DATA-POINTS โ RENDERING ON A
<canvas> โ PROCESSING DATA -
DAILY VISITORS (BEFORE) const DailyVisitors = () = > {
const [data, setData] = useState(initialData); useEffect(() = > { setData(initialData); }, []); const onChange = (newData) = > { setData(newData); }; return ( <Dashboard data={data} initialData={initialData} onChange={onChange} /> ); }; export default DailyVisitors; -
DAILY VISITORS (AFTER) const DailyVisitors = () = > {
const [data, setData] = useState(initialData); const [, startTransition] = useTransition(); useEffect(() = > { setData(initialData); }, []); const onChange = (newData) = > { startTransition(() = > { setData(newData); }); }; return ( <Dashboard data={data} initialData={initialData} onChange={onChange} /> ); }; export default DailyVisitors; -
โ ห100K + POINTS PLOTTED โ SUPPORT FOR SEARCHING AND
FILTERING โ USED WORKERS + REDUX-SAGA UTILITIES + DEBOUNCING โ COULD'VE USED TRANSITIONS CASE #1: MAPS -
CASE #2: GAME ADMIN โ THOUSANDS OF REAL-TIME PLAYERS MESSAGING
โ SUPPORT FOR SEARCHING AND FILTERING โ USED VIRTUALIZATION AND MEMOIZATION โ COULD'VE USED TRANSITIONS -
useSyncExternalStore() function useSyncExternalStore<Snapshot>( subscribe: (onStoreChange: () = > void) =
> () = > void, getSnapshot: () = > Snapshot, getServerSnapshot?: () = > Snapshot ): Snapshot; -
#QUESTION ๐ค How do we benefit from these in our
everyday projects? -
useLocation() function Pathname() { const { pathname } = useLocation();
return <Badge title={pathname} subtitle="pathname" />; } function Hash() { const { hash } = useLocation(); return <Badge title={hash} subtitle="hash" />; } -
useLocation() function Pathname() { const { pathname } = useLocation();
return <Badge title={pathname} subtitle="pathname" />; } function Hash() { const { hash } = useLocation(); return <Badge title={hash} subtitle="hash" />; } OVER-RETURNING HOOK -
useLocation() function Pathname() { const { pathname } = useLocation();
return <Badge title={pathname} subtitle="pathname" />; } function Hash() { const { hash } = useLocation(); return <Badge title={hash} subtitle="hash" />; } -
useLocation() useHistorySelector() function useHistorySelector(selector) { const history = useHistory(); return
useSyncExternalStore(history.listen, () = > selector(history)); } function Pathname() { const pathname = useHistorySelector((history) = > history.location.pathname); return <Badge title={pathname} subtitle="pathname" />; } function Hash() { const hash = useHistorySelector((history) = > history.location.hash); return <Badge title={hash} subtitle="hash" />; } -
function useHistorySelector(selector) { const history = useHistory(); return useSyncExternalStore(history.listen, ()
= > selector(history)); } function Pathname() { const pathname = useHistorySelector((history) = > history.location.pathname); return <Badge title={pathname} subtitle="pathname" />; } function Hash() { const hash = useHistorySelector((history) = > history.location.hash); return <Badge title={hash} subtitle="hash" />; } useLocation() useHistorySelector() -
โ BEFORE, HYDRATION COULD ONLY BEGIN AFTER THE ENTIRE DATA
WAS FETCHED AND RENDERED โ USERS COULDNโT INTERACT WITH THE PAGE UNTIL HYDRATION WAS COMPLETE FOR THE WHOLE PAGE โ PARTS OF YOUR APP THAT LOAD FAST WOULD ALWAYS HAVE TO WAIT FOR THE SLOW ONES HYDRATION -
โ REACT WON'T WAIT FOR A COMPONENT TO LOAD TO
CONTINUE STREAMING THE REST OF THE HTML โ REACT PRIORITIZES HYDRATING THE PARTS THAT THE USER INTERACTED WITH BEFORE THE REST SELECTIVE HYDRATION -
โ COMPONENTS CAN BECOME INTERACTIVE FASTER BY ALLOWING THE BROWSER
TO DO OTHER WORK AT THE SAME TIME AS HYDRATION โ RESULTS IN LOWER FIRST INPUT DELAY (FID) AND INTERACTION TO NEXT PAINT (INP) SELECTIVE HYDRATION -
SELECTIVE HYDRATION <Layout> <Article /> <Suspense fallback={<Spinner />}> <Co m
m ents /> </Suspense> </Layout> -
TIMING USER TIMING ALLOWS YOU TO MARK POINTS IN TIME
AND THEN MEASURE THE DURATION BETWEEN THOSE MARKS. EVENT TIMING EVENT PROCESSING TIME + TIME UNTIL THE NEXT FRAME CAN BE RENDERED. THE BASIS FOR THE FID METRIC. ELEMENT TIMING MEASURE THE RENDER TIME OF SPECIFIC ELEMENTS. THE BASIS FOR THE LCP METRIC. RESOURCE TIMING RETRIEVE AND ANALYZE DETAILED NETWORK TIMING DATA REGARDING THE LOADING -
PROFILING LONG TASKS API REPORTS TASKS THAT TAKES LONGER THAN
50 MS AND IT'S THE BASIS FOR TTI AND TBT METRICS JS SELF-PROFILING API PROFILE SPECIFIC COMPLEX OPERATIONS AND IDENTIFY HOT SPOTS USING A SAMPLING PROFILER UserAgentSpecificMemory DETECT MEMORY LEAKS IN APPS THAT HANDLE A HUGE VOLUME OF DATA -
{ name: "same-origin-descendant", entryType: "longtask", startTime: 1023.40999995591, duration: 187.19000002602115, attribution:
[ { name: "unknown", entryType: "taskattribution", startTime: 0, duration: 0, containerType: "iframe", containerSrc: "child.html", containerId: "", containerName: "child1" } ] } { bytes: 1000000, breakdown: [ { bytes: 1000000, attribution: [ { url: "https://example.com", scope: "Window", }, ], types: ["JS", "DOM"], }, { bytes: 0, attribution: [], types: [], }, ], } { "frames": [ { "name": "Profiler" }, { "column": 0, "line": 100, "name": "", "resourceId": 0 }, { "name": "set innerHTML" }, { "column": 10, "line": 10, "name": "A", "resourceId": 1 } { "column": 20, "line": 20, "name": "B", "resourceId": 1 } ], "resources": [ "https://example.com/page", "https://example.com/app.js", ], "samples": [ { "stackId": 0, "timestamp": 161.99500000476837 }, { "stackId": 2, "timestamp": 182.43499994277954 }, { "timestamp": 197.43499994277954 }, { "timestamp": 213.32999992370605 }, { "stackId": 3, "timestamp": 228.59999990463257 }, ], "stacks": [ { "frameId": 0 }, { "frameId": 2 }, { "frameId": 3 }, { "frameId": 4, "parentId": 2 } ] } LONG TASKS SELF-PROFILING USERAGENT MEMORY ๐บ -
#PROTIP ๐ก Use observability services or libraries like web-vitals. But
remember you can also create your own abstractions on top of the web + React. -
โ I/O LIBRARIES LIKE react-fetch โ BUILT-IN <Cache> FOR DATA
FETCHING LIBRARIES TO INTEGRATE WITH <Suspense> โ <Suspense> FOR CPU-BOUND TREES TO IMMEDIATELY FALLBACK WITHOUT EVEN TRYING TO RENDER THE FUTURE ๐บ -
โ useInsertionEffect FOR STYLESHEET LIBRARIES โ THE <Offscreen> COMPONENT โ
SERVER COMPONENTS โ NATIVE SCHEDULING PRIMITIVES ON THE BROWSER THE FUTURE ๐บ -
SCHEDULING API โ A MORE ROBUST SOLUTION FOR SCHEDULING TASKS
โ CONTROL AND SCHEDULE PRIORITIZED TASKS IN A UNITED AND FLEXIBLE WAY โ INTEGRATED DIRECTLY INTO THE EVENT LOOP โ ALIGNED WITH THE WORK OF THE REACT TEAM AND IN COOPERATION WITH GOOGLE, W3C AND OTHERS -
scheduler.postTask() SCHEDULE AND CONTROL PRIORITIZING TASKS. scheduler.wait() YIELD AND RESUME
AFTER SOME AMOUNT OF TIME OR PERHAPS AFTER AN EVENT HAS OCCURRED. scheduler.yield() BREAK UP LONG TASKS BY YIELDING TO THE BROWSER AND CONTINUING AFTER BEING RESCHEDULED. isInputPending() DETERMINE IF THE CURRENT TASK IS BLOCKING INPUT EVENTS. SCHEDULING API -
#1 DEEP DIVING ON CONCURRENT REACT REACT HAS BEEN PUSHING
WEB APIS TO THE FUTURE E.G. THE SCHEDULER API -
#2 DEEP DIVING ON CONCURRENT REACT UNDERSTANDING THESE INTERNALS AND
THEIR RATIONALES HELPS US IMPLEMENT OUR OWN ABSTRACTIONS -
#3 DEEP DIVING ON CONCURRENT REACT SCHEDULING DOES NOT NECESSARILY
MEAN BETTER PERFORMANCE ๐บ -
#4 DEEP DIVING ON CONCURRENT REACT THERE'S NO SILVER BULLET.
IDENTIFY YOUR CORE METRICS. -
#5 DEEP DIVING ON CONCURRENT REACT THEREโS A LOT OF
INFORMATION OUT THERE -
#6 DEEP DIVING ON CONCURRENT REACT ALWAYS TRY TO CORRELATE
BUSINESS METRICS WITH PERFORMANCE -
DEEP DIVING ON CONCURRENT REACT THATโS ALL, FOLKS! THANKS! ๐ค
๐ง๐ช QUESTIONS? MATHEUS ALBUQUERQUE โ ALL THE LINKS! ๐ค