Index
A
- abstract dispatcher interface
- about / Abstract dispatcher interface
- store registration / Store registration
- payloads, dispatching / Dispatching payloads
- dependencies, handling / Handling dependencies
- action constants
- organizing / Organizing action constants
- action creators
- testing / Testing action creators
- synchronous functions / Synchronous functions
- asynchronous functions / Asynchronous functions
- action names
- about / Action names and constants
- conventions / Action name conventions
- static action data / Static action data
- actions
- about / Impacted components
- scaling / Actions that scale
- Alt
- using / Using Alt
- core ideas / The core ideas
- stores, creating / Creating stores
- action creators, declaring / Declaring action creators
- state changes, listening for / Listening for state changes
- views, rendering / Rendering views and dispatching actions
- actions, dispatching / Rendering views and dispatching actions
- API calls
- making / Making API calls
- as common case / APIs are the common case
- and user interactivity / API calls and user interactivity
- combining / Combining API calls
- complex action creators / Complex action creators
- action creators, composing / Composing action creators
- application data
- and UI state / Application data and UI state
- transforming / Two of the same thing
- tightly coupled transformations / Tightly coupled transformations
- feature centric / Feature centric
B
- bare bone views, skeleton architecture
- about / Bare bone views
- missing data, finishing / Finding missing data
- actions, identifying / Identifying actions
- benchmarking tools
- about / Benchmarking tools
- code, benchmarking / Benchmarking code
- state transformations / State transformations
- benefits, explicit actions
- updates via hidden side-effects / Updates via hidden side-effects
- data changes state / Data changes state in one place
- multiple actions / Too many actions?
- hierarchical structures / Layers over hierarchies
- multiple component hierarchies / Multiple component hierarchies
- hierarchy depths / Hierarchy depth and side-effects
- side-effects / Hierarchy depth and side-effects
- data-flow / Data-flow and layers
- architectural layers / Data-flow and layers
- benefits, ReactJS
- about / ReactJS is a good fit for Flux
- unidirectional / ReactJS is unidirectional
- new data, re-rendering / Re-rendering new data is easy
- small code footprint / Small code footprint
C
- challenges, dispatcher
- about / Challenges with the dispatcher
- educational purposes / Educational purposes
- singleton dispatchers / Singleton dispatchers
- manual store registration / Manual store registration
- error-prone dependency management / Error-prone dependency management
- challenges, MV*
- about / Challenges with MV*
- separation of concerns / Separation of concerns
- updates, cascading / Cascading updates
- model update responsibilities / Model update responsibilities
- changing information
- adapting to / Adapting to changing information
- API data, changing / Changing API data
- feature functionality, changing / Changing feature functionality
- impacted components / Impacted components
- component life cycle
- issues / Component life cycle difficulties
- unused resources, reclaiming / Reclaiming unused resources
- dependencies, hidden / Hidden dependencies
- memory leaks / Memory leaks
- conceptual problems, Flux
- data flow direction / Data flow direction
- predictable root cause / Predictable root cause
- consistent notifications / Consistent notifications
- simple architectural layers / Simple architectural layers
- loosely coupled rendering / Loosely coupled rendering
- core Flux components
- dispatcher, customizing / Customizing the dispatcher
- base store, implementing / Implementing a base store
- actions, creating / Creating actions
- core ideas, Alt
- compliant / The core ideas
- automates boilerplate / The core ideas
- no dispatcher / The core ideas
- core ideas, Redux
- no dispatcher / The core ideas
- one store to rule them all / The core ideas
- dispatch to the store / The core ideas
- pure reducers / The core ideas
D
- data, mocking
- about / Mocking data
- existing APIs, mocking / Mocking existing APIs
- new APIs, mocking / Mocking new APIs
- action creators, replacing / Replacing action creators
- dependencies
- hidden / Hidden dependencies
- development methodologies
- about / Development methodologies
- upfront Flux activities / Upfront Flux activities
- Flux application, maturing / Maturing a Flux application
- dispatcher
- abstract dispatcher interface / Abstract dispatcher interface
- challenges / Challenges with the dispatcher
- module, building / Building a dispatcher module
- store registration, improving / Improving store registration
- dispatcher module, building
- about / Building a dispatcher module
- store references, encapsulating / Encapsulating store references
- dependencies, handling / Handling dependencies
- actions, dispatching / Dispatching actions
- downsides, ReactJS
- about / The downsides of ReactJS
- virtual DOM / Virtual DOM and memory
- memory / Virtual DOM and memory
- JSX / JSX and markup
- markup / JSX and markup
- vendor lock-in / Vendor lock-in
- duplicate store data
- reducing / Reducing duplicate store data
- generic store data / Generic store data
- generic stores, registering / Registering generic stores
- generic data, combining with specific data / Combining generic and specific data
E
- end-to-end scenarios, skeleton architecture
- about / End-to-end scenarios
- action checklist / Action checklist
- store checklist / Store checklist
- view checklist / View checklist
- explicit actions
- benefits / Explicit over implicit
F
- feature action creators
- about / Feature action creators
- modularity, need for / When modularity is needed
- modular architecture / Modular architecture
- Flux
- set of patterns / Flux is a set of patterns
- data entry points / Data entry points
- state, managing / Managing state
- updates, keeping synchronous / Keeping updates synchronous
- information architecture / Information architecture
- about / Flux isn't another framework
- advantages / Flux isn't another framework
- used, for solving conceptual problems / Flux solves conceptual problems
- components / Flux components
- keeping synchronous / Keeping Flux synchronous
- synchronicity / Why synchronicity?
- asynchronous behavior, encapsulating / Encapsulating asynchronous behavior
- asynchronous action semantics / Asynchronous action semantics
- ReactJS, using with / Using ReactJS with Flux
- interpretation / Flux is open to interpretation
- implementation options / Implementation option 1 – just the patterns, Implementation option 2 – use a Flux library
- library, using / Implementation option 2 – use a Flux library
- own Flux components, rolling over / Roll your own Flux
- ideas, borrowing / Borrowing ideas from Flux
- unidirectional data flow / Unidirectional data flow
- information design / Information design is king
- Flux action / Action
- Flux components
- about / Flux components
- action / Action
- dispatcher / Dispatcher
- store / Store
- views / View
- Flux package
- installing / Installing the Flux package
- Flux structures
- are static / Flux structures are static
- models, comparing to / Comparison to models
- static views / Static views
G
- garbage-collected / Component life cycle difficulties
- generic stores
- about / Reducing duplicate store data
H
- Handlebars
- using / Using jQuery and Handlebars
- benefits / Why jQuery and Handlebars?
- templates, rendering / Rendering templates
- views, composing / Composing views
- hidden updates
- renouncing / Renouncing hidden updates
- Flux, breaking / How to break Flux
- store data, obtaining / Getting store data
- immutable / Everything is immutable
I
- Immutable.js
- using / Using Immutable.js
- immutable lists / Immutable lists and maps
- immutable maps / Immutable lists and maps
- immutable transformations / Immutable transformations
- change detection / Change detection
- immutable data
- cost / The cost of immutable data
- garbage collection / Garbage collection is expensive
- batched mutations / Batched mutations
- cost offsetting / Offsetting the cost
- Incremental DOM
- reference link / New hotness
- information design, skeleton architecture
- models / Users don't understand models
- stores, mapping / Stores map to what the user sees
- implementation / What do we have to work with?
- installation
- Flux package / Installing the Flux package
- inter-store dependencies
- about / Impacted components
J
- Jest
- about / Hello Jest
- key aspects / Hello Jest
- jQuery
- using / Using jQuery and Handlebars
- benefits / Why jQuery and Handlebars?
- events, handling / Handling events
M
- Model View Controller (MVC) / Data entry points
- MV*
- challenges / Challenges with MV*
P
- packaging Flux components
- about / Packaging Flux components
- monolithic Flux / The case for monolithic Flux
- packages, enabling scale / Packages enable scale
- installable Flux components / Installable Flux components
- pain points
- implementing / Implementation pain points
- asynchronous actions, dispatching / Dispatching asynchronous actions
- stores, partioning / Partitioning stores
- parameterized action creators
- about / Parameterized action creators
- redundant actions, removing / Removing redundant actions
- generic feature, maintaining / Keeping actions generic
- partials, creating / Creating action partials
- performance goals
- about / Performance goals
- user-perceived performance / User perceived performance
- measured performance / Measured performance
- requirements / Performance requirements
- profiling tools
- about / Profiling tools
- asynchronous actions / Asynchronous actions
- store memory / Store memory
- CPU utilization / CPU utilization
- promises
- returning / Returning promises
- synchronous feature / Synchronizing without promises
- asynchronous behavior, composing / Composing asynchronous behavior
- errors, handling / Handling errors
R
- ReactJS
- using, with Flux / Using ReactJS with Flux
- view state, setting / Setting the view state
- views, composing / Composing views
- reacting, to events / Reacting to events
- routing / Routing and actions
- actions / Routing and actions
- benefits / ReactJS is a good fit for Flux
- downsides / The downsides of ReactJS
- Redux
- using / Using Redux
- core ideas / The core ideas
- reducers / Reducers and stores
- stores / Reducers and stores
- actions / Redux actions
- components, rendering / Rendering components and dispatching actions
- actions, dispatching / Rendering components and dispatching actions
S
- scaling information
- about / Scaling information, What scales well?
- minimal information, needs / Minimal information required
- actions, scaling / Actions that scale
- singleton pattern
- about / Singleton pattern
- skeleton architecture
- general organization / General organization
- directory structure / Directory structure
- dependency management / Dependency management
- information design / Information design
- stores / Putting stores into action
- stateful action creators
- about / Stateful action creators
- integrating, with other systems / Integrating with other systems
- web socket connectivity / Web socket connectivity
- static views
- about / Static views
- store complexity
- dealing with / Dealing with store complexity
- multiple stores / Too many stores
- feature domains / Rethinking feature domains
- store dependencies
- handling / Handling store dependencies
- waiting for / Waiting for stores
- data dependencies / Data dependencies
- UI dependencies / UI dependencies
- store registration
- improving / Improving store registration
- base store class / Base store class
- action method / An action method
- stores
- inactive / Inactive stores
- data, deleting / Deleting store data
- inactive stores, optimizing / Optimizing inactive stores
- data, keeping / Keeping store data
- testing / Testing stores
- listeners, testing / Testing store listeners
- initial conditions, testing / Testing initial conditions
- stores, skeleton architecture
- about / Putting stores into action
- API data, fetching / Fetching API data
- API resource state, changing / Changing API resource state
- local actions / Local actions
- and feature domains / Stores and feature domains
- top-level features, identifying / Identifying top-level features
- API data, irrelevant / Irrelevant API data
- data, structuring / Structuring store data
U
- unidirectional data
- about / Unidirectional data
- flowing, from starting point to finish point / From start to finish
- no side-effects / No side-effects
- unidirectional data flow
- enforcing / Enforcing unidirectional data flow
- backwards / Backwards, sideways, and leaky data flow
- sideways / Backwards, sideways, and leaky data flow
- leaky data flow / Backwards, sideways, and leaky data flow
- stores / Too many stores?
- actions / Not enough actions
- immutability, enforcing / Enforcing immutability
- update order
- viewing / View update order
- store registration order / Store registration order
- view rendering, prioritizing / Prioritizing view rendering
V
- VanillaJS
- using / Using VanillaJS
- options, keeping open / Keeping my options open
- React, using / Moving to React
- React, benefits / New hotness
- Veu.js
- reference link / New hotness
- view responsibilities
- about / View responsibilities
- store data, rendering / Rendering store data
- subview structure / Subview structure
- user interactivity / User interactivity
- views
- stateless views / Keeping views stateless
- UI state / UI state belongs in stores
- DOM querying, avoiding / No querying the DOM
- responsibilities / View responsibilities
- views data
- passing / Passing views data
- passing, via change event / Data via the change event
- rendering decision, making / Views decide when to render