Upgrade to Pro
— share decks privately, control downloads, hide ads and more …
Speaker Deck
Features
Speaker Deck
PRO
Sign in
Sign up for free
Search
Search
React+Redux @ Scale
Search
Daniel Cousineau
June 26, 2017
Programming
1
330
React+Redux @ Scale
Given at QCon NYC 2017
https://qconnewyork.com/ny2017/presentation/reactredux-scale-talk
Daniel Cousineau
June 26, 2017
Tweet
Share
More Decks by Daniel Cousineau
See All by Daniel Cousineau
Time is a Social Construct
dcousineau
1
560
React @ Scale
dcousineau
0
170
Frontend Performance & You
dcousineau
0
280
Feature Flags & You
dcousineau
2
96
Reframing The Problem - DCJS July 2016
dcousineau
0
120
YAFT
dcousineau
2
150
Queues and the beanstalkd
dcousineau
1
660
How Not Writing PHP Makes You Better At PHP
dcousineau
0
380
JavaScript for PHP Developers
dcousineau
4
690
Other Decks in Programming
See All in Programming
[FEConf 2025] 모노레포 절망편, 14개 레포로 부활하기까지 걸린 1년
mmmaxkim
0
1.6k
旅行プランAIエージェント開発の裏側
ippo012
2
910
JSONataを使ってみよう Step Functionsが楽しくなる実践テクニック #devio2025
dafujii
1
530
プロポーザル駆動学習 / Proposal-Driven Learning
mackey0225
2
1.3k
Ruby Parser progress report 2025
yui_knk
1
440
速いWebフレームワークを作る
yusukebe
5
1.7k
時間軸から考えるTerraformを使う理由と留意点
fufuhu
16
4.8k
The Past, Present, and Future of Enterprise Java with ASF in the Middle
ivargrimstad
0
120
250830 IaCの選定~AWS SAMのLambdaをECSに乗り換えたときの備忘録~
east_takumi
0
390
複雑なドメインに挑む.pdf
yukisakai1225
5
1.2k
Navigating Dependency Injection with Metro
zacsweers
3
960
テストコードはもう書かない:JetBrains AI Assistantに委ねる非同期処理のテスト自動設計・生成
makun
0
320
Featured
See All Featured
Automating Front-end Workflow
addyosmani
1370
200k
Writing Fast Ruby
sferik
628
62k
Rails Girls Zürich Keynote
gr2m
95
14k
Balancing Empowerment & Direction
lara
3
620
Distributed Sagas: A Protocol for Coordinating Microservices
caitiem20
333
22k
Rebuilding a faster, lazier Slack
samanthasiow
83
9.2k
Building a Scalable Design System with Sketch
lauravandoore
462
33k
Bash Introduction
62gerente
615
210k
KATA
mclloyd
32
14k
The Illustrated Children's Guide to Kubernetes
chrisshort
48
50k
GitHub's CSS Performance
jonrohan
1032
460k
Building an army of robots
kneath
306
46k
Transcript
React+Redux @ Scale
@dcousineau
None
None
None
None
Rules
None
“Rules”
None
None
Scalability is the capability of a system, network, or process
to handle a growing amount of work, or its potential to be enlarged to accommodate that growth. – Wikipedia
Part 1: React
Rule: Components should be stateless
Reality: State is the enemy, but also inevitable
onClick(e) { const value = e.target.value; const formatted = value.toUpperCase();
this.setState({value: formatted}); }
onClick() { this.setState((previousState, currentProps) => { return { show: !previousState.show,
}; }); }
onClick(e) { this.setState({value: e.target.value}); this.props.onChange(this.state.value); }
onClick(e) { this.setState({value: e.target.value}, () => { this.props.onChange(this.state.value); }); }
Rule: Don’t use Context, it hides complexity
Reality: Sometimes complexity should be hidden
None
None
class TextCard extends React.Component { static contextTypes = { metatypes:
React.PropTypes.object, }; render() { const {cardData} = this.props; const {metatypes} = this.context; return ( <div> The following is either editable or displayed: <metatypes.text value={cardData.text} onChange={this.props.onChange} /> </div> ) } } function selectCardComponent(cardData) { switch (cardData.type) { case 'text': return TextCard; default: throw new Error(`Invalid card type ${cardData.type}`); } }
class TextCard extends React.Component { static contextTypes = { metatypes:
React.PropTypes.object, }; render() { const {cardData} = this.props; const {metatypes} = this.context; return ( <div> The following is either editable or displayed: <metatypes.text value={cardData.text} onChange={this.props.onChange} /> </div> ) } } function selectCardComponent(cardData) { switch (cardData.type) { case 'text': return TextCard; default: throw new Error(`Invalid card type ${cardData.type}`); } }
const metatypesEdit = { text: class extends React.Component { render()
{ return <input type="text" {...this.props} />; } } } const metatypesView = { text: class extends React.Component { render() { return <span>{this.props.value}</span>; } } }
class CardViewer extends React.Component { static childContextTypes = { metatypes:
React.PropTypes.object }; getChildContext() { return {metatypes: metatypesView}; } render() { const {cardData} = this.props; const CardComponent = selectCardComponent(cardData); return <CardComponent cardData={cardData} /> } }
class CardEditor extends React.Component { static childContextTypes = { metatypes:
React.PropTypes.object }; getChildContext() { return {metatypes: metatypesEdit}; } render() { const {cardData} = this.props; const CardComponent = selectCardComponent(cardData); return <CardComponent cardData={cardData} /> } }
Part 2: Redux
Rule: “Single source of truth” means all state in the
store
Reality: You can have multiple “single sources”
this.state.checked = true;
this.props.checked = true; this.props.checked = true; this.props.checked = true; this.state.checked
= true;
this.props.checked = true; this.props.checked = true; this.props.checked = true; this.props.checked
= true; checked: true connect()();
window.location.*
Rule: Side effects should happen outside the Redux cycle
Reality: This doesn’t mean you can’t have callbacks
function persistPostAction(post, callback = () => {}) { return {
type: 'PERSIST_POST', post, callback }; } function *fetchPostsSaga(action) { const status = yield putPostAPI(action.post); yield put(persistPostCompleteAction(status)); yield call(action.callback, status); } class ComposePost extends React.Component { onClickSubmit() { const {dispatch} = this.props; const {post} = this.state; dispatch(persistPostAction(post, () => this.displaySuccessBanner())); } }
class ViewPostPage extends React.Component { componentWillMount() { const {dispatch, postId}
= this.props; dispatch(fetchPostAction(postId, () => this.logPageLoadComplete())); } }
Rule: Redux stores must be normalized for performance
Reality: You must normalize to reduce complexity
https://medium.com/@dcousineau/advanced-redux-entity-normalization-f5f1fe2aefc5
{ byId: { ...entities }, keyWindows: [`${keyWindowName}`], [keyWindowName]: { ids:
['id0', ..., 'idN'], ...meta } }
{ byId: { 'a': userA, 'b': userB, 'c': userC, 'd':
userD }, keyWindows: ['browseUsers', 'allManagers'], browseUsers: { ids: ['a', 'b', 'c'], isFetching: false, page: 1, totalPages: 10, next: '/users?page=2', last: '/users?page=10' }, allManagers: { ids: ['d', 'a'], isFetching: false } }
function selectUserById(store, userId) { return store.users.byId[userId]; } function selectUsersByKeyWindow(store, keyWindow)
{ return store.users[keyWindow].ids.map(userId => selectUserById(store, userId)); }
function fetchUsers({query}, keyWindow) { return { type: FETCH_USERS, query, keyWindow
}; } function fetchManagers() { return fetchUsers({query: {isManager: true}}, 'allManager'); } function receiveEntities(entities, keyWindow) { return { type: RECEIVE_ENTITIES, entities, keyWindow }; }
function reducer(state = defaultState, action) { switch(action.type) { case FETCH_USERS:
return { ...state, keyWindows: uniq([...state.keyWindows, action.keyWindow]), [action.keyWindow]: { ...state[action.keyWindow], isFetching: true, query: action.query } }; case RECEIVE_ENTITIES: return { ...state, byId: { ...state.byId, ...action.entities.users.byId }, keyWindows: uniq([...state.keyWindows, action.keyWindow]), [action.keyWindow]: { ...state[action.keyWindow], isFetching: false, ids: action.entities.users.ids } }; } }
function reducer(state = defaultState, action) { switch(action.type) { case FETCH_USERS:
return { ...state, keyWindows: uniq([...state.keyWindows, action.keyWindow]), [action.keyWindow]: { ...state[action.keyWindow], isFetching: true, query: action.query } }; case RECEIVE_ENTITIES: return { ...state, byId: { ...state.byId, ...action.entities.users.byId }, keyWindows: uniq([...state.keyWindows, action.keyWindow]), [action.keyWindow]: { ...state[action.keyWindow], isFetching: false, ids: action.entities.users.ids } }; } }
function selectUsersAreFetching(store, keyWindow) { return !!store.users[keyWindow].isFetching; } function selectManagersAreFetching(store) {
return selectUsersAreFetching(store, 'allManagers'); }
function reducer(state = defaultState, action) { switch(action.type) { case UPDATE_USER:
return { ...state, draftsById: { ...state.draftsById, [action.user.id]: action.user } }; case RECEIVE_ENTITIES: return { ...state, byId: { ...state.byId, ...action.entities.users.byId }, draftsById: { ...omit(state.draftsById, action.entities.users.byId) }, keyWindows: uniq([...state.keyWindows, action.keyWindow]), [action.keyWindow]: { ...state[action.keyWindow], isFetching: false, ids: action.entities.users.ids } }; } }
function reducer(state = defaultState, action) { switch(action.type) { case UPDATE_USER:
return { ...state, draftsById: { ...state.draftsById, [action.user.id]: action.user } }; case RECEIVE_ENTITIES: return { ...state, byId: { ...state.byId, ...action.entities.users.byId }, draftsById: { ...omit(state.draftsById, action.entities.users.byId) }, keyWindows: uniq([...state.keyWindows, action.keyWindow]), [action.keyWindow]: { ...state[action.keyWindow], isFetching: false, ids: action.entities.users.ids } }; } }
function selectUserById(store, userId) { return store.users.draftsById[userId] || store.users.byId[userId]; }
function reducer(state = defaultState, action) { switch(action.type) { case UNDO_UPDATE_USER:
return { ...state, draftsById: { ...omit(state.draftsById, action.user.id), } }; } }
Part 3: Scale
Rule: Keep dependencies low to keep the application fast
Reality: Use bundling to increase PERCEIVED performance
class Routes extends React.Component { render() { return ( <Switch>
<Route exact path="/" component={require(‘../home').default} /> <Route path="/admin" component={lazy(require(‘bundle-loader?lazy&name=admin!../admin’))} /> <Route component={PageNotFound} /> </Switch> ); } }
require('bundle-loader?lazy&name=admin!../admin’)
const lazy = loader => class extends React.Component { componentWillMount()
{ loader(mod => this.setState({ Component: mod.default ? mod.default : mod }) ); } render() { const { Component } = this.state; if (Component !== null) { return <Component {...this.props} />; } else { return <div>Is Loading!</div>; } } };
None
Rule: Render up-to-date data
Reality: If you got something render it, update it later
None
None
None
None
None
None
Epilog: Scale?
Rule: Scale is bytes served, users concurrent
Reality: Scale is responding to bytes served and users concurrent
How fast can you deploy?
None
Pre: Clear homebrew & yarn caches 1. Reinstall node &
yarn via brew 2. Clone repo 3. Run yarn install 4. Run production build 1. Compile & Minify CSS 2. Compile Server via Babel 3. Compile, Minify, & Gzip via Webpack 190.64s ~3 min
<Feature name="new-feature" fallback={<OldFeatureComponent />}> <NewFeatureComponent /> </Feature>
None
Team 1 Team 2 Merge Feature A Merge Feature B
Deploy Deploy OMG ROLLBACK DEPLOY!!! Merge Feature C Merge Bugfix for A Deploy Deploy BLOCKED!!! Deploy
Team 1 Team 2 Merge Feature A Merge Feature B
Deploy Deploy Rollout Flag A Rollout Flag B OMG ROLLBACK FLAG A!!! Merge Feature C Deploy Merge Bugfix for A Deploy Rollout Flag A Rollout Flag C
Can you optimize your directory structure around team responsibilities? If
teams are organized by “product domain”, Can you organize code around product domain?
Final Thoughts
Strict rules rarely 100% apply to your application. Remembering the
purpose behind the rules is valuable.
Code behavior should be predictable and intuitable. Be realistic about
the problem you’re actually solving.
You will not get it perfect the first time. Optimize
your processes for refactoring.
Questions?