Index

A

• API Data
  • about / API data
  • load latency / Load latency
  • large data sets, working with / Working with large data sets
• appearance
  • about / Appearance
• application composition
  • about / Application composition
  • feature enablement approach / Feature enablement
  • new feature impact / New feature impact
  • essential libraries / Essential libraries
• architectural perspectives, scaling influencers / Architectural perspectives
• architectural trade-offs
  • creating / Making architectural trade-offs
  • constants, defining / Defining your constants
  • performance for ease of development / Performance for ease of development
  • performance for configurability / Configurability for performance
  • performance for substitutability / Performance for substitutability
  • development for addressability / Ease of development for addressability
  • maintainability for performance / Maintainability for performance
  • maintainability, features / Less features for maintainability
  • frameworks, leveraging / Leveraging frameworks
• architecture
  • improving / Improving the architecture
  • failure scenarios, documenting / Documenting failure scenarios
  • component classification, improving / Improving component classification
  • complex components / Complexity promotes failure

B

• backend
  • decoupling / Decoupling the backend
  • API, mocking / Mocking the backend API
  • front-end entry points / Frontend entry points
  • tools, mocking / Mocking tools
  • mock data sets, mocking / Generating mock data sets
  • actions, performing / Performing actions
• behavior
  • about / Behavior
  • configuring / Configuring behavior
  • components, enabling / Enabling and disabling components
  • components, disabling / Enabling and disabling components
  • quantities, modifying / Changing quantities
  • order, modifying / Changing order
  • notifications, configuring / Configuring notifications
  • inline options / Inline options
  • performance implications / Configurable behavior performance
• boilerplate / Modules
• browser environment
  • working in / The browser is a unique environment
  • component design / Component design
  • component communication / Component communication
  • load time / Load time
  • responsiveness / Responsiveness
  • addressability / Addressability
  • configurability / Configurability
• Browserify / Modules

C

• collections
  • about / Models/Collections
  • extending / Extending models/collections
• command-response / Message-passing models
• Common Locale Data Repository (CLDR)
  • about / Maintaining locales
• communication bottlenecks
  • about / Communication bottlenecks
  • indirection, reducing / Reducing indirection
  • code, profiling / Profiling code
• communication data schema
  • about / Communication data schema
  • naming conventions / Naming conventions
  • data format / Data format
  • common data / Common data
• communication models
  • about / Communication models
  • message-passing models / Message-passing models
  • event models / Event models
• communication overhead
  • about / Communication overhead
  • event frequency / Event frequency
  • callback execution time / Callback execution time
  • callback complexity / Callback complexity
• communication responsibility, areas
  • about / Areas of communication responsibility
  • backend API / Backend API
  • web socket updates / Web socket updates
  • DOM updates / DOM updates
• component artifacts
  • about / Component artifacts
  • component dependencies / Component dependencies
  • components, building / Building components
• component code
  • organizing / Organizing component code
• component layers
  • about / Component layers
  • event flow direction / Event flow direction
  • developer responsibilities, mapping to / Mapping to developer responsibilities
  • code, mentally-mapping / Mentally mapping the code
• components
  • decomposing / Decomposing components
  • debugging / Maintaining and debugging components
  • maintaining / Maintaining and debugging components
  • complex components, re-factoring / Re-factoring complex components
  • artifacts / Component artifacts
  • building / Building components
  • loading / Loading components
  • modules, loading / Loading modules
  • lazy module, loading / Lazy module loading
  • module load latency / Module load latency
  • optimizing / Component optimization
  • state, maintaining / Components that maintain state
  • side-effects, dealing with / Dealing with side-effects
  • DOM rendering techniques / DOM rendering techniques
  • optimizing, at runtime / Optimizing components at runtime
• conflicting features
  • about / Conflicting features
  • overlapping functionality / Overlapping functionality
  • irrelevant features / Irrelevant features
  • customer demand / Customer demand
• console.error() function / Logging and debugging
• continuous integration / End-to-end tests and continuous integration
• controllers
  • about / Controllers/Views
  • extending / Extending controllers/views

D

• debounced / Controllers/Views
• debounced function
  • URL / Controllers/Views
• design failures, reasons
  • about / Design failures
  • unnecessary components / Unnecessary components
  • inefficient data processing / Inefficient data processing
  • creative markup / Excessively creative markup

E

• end-to-end tests
  • using / End-to-end tests and continuous integration

F

• failure recovery
  • about / Failure recovery
  • failed operations, retrying / Retrying failed operations
  • components, restarting / Restarting components
  • manual user intervention / Manual user intervention
  • pitfalls / When we can't recover from failures...
• fault tolerance
  • about / Fault tolerance
  • critical behavior, classifying / Classifying critical behavior
  • errant behavior, detecting / Detecting and containing errant behavior
  • errant behavior, containing / Detecting and containing errant behavior
  • defective components, disabling / Disabling defective components
  • degrading functionality / Gracefully degrading functionality
• feature design process
  • about / Feature design process
  • API, designing / Designing the API
  • mock, implementing / Implementing the mock
  • feature, implementing / Implementing the feature
  • mock data, reconciling with API data / Reconciling mock data with API data
• features
  • mapping, to components / Mapping features to components
  • generic features / Generic features
  • specific features / Specific features
• frameworks versus libraries
  • about / Frameworks versus libraries
  • patterns, implementing / Implementing patterns consistently
  • built in performance / Performance is built in
  • community wisdom / Leverage community wisdom
  • scales / Frameworks don't scale out-of-the-box

G

• generic component configuration
  • about / Generic component configuration
  • configuration values, determining / Deciding on configuration values
  • hard-coded default values, using / Stored and hard-coded default values
  • stored default values, using / Stored and hard-coded default values
  • backend implications / Backend implications
  • configuration values, loading / Loading configuration values
• generic components
  • extending / Extending generic components
  • common data, identifying / Identifying common data and functionality
  • functionality, identifying / Identifying common data and functionality
  • router components, extending / Extending router components
  • models, extending / Extending models/collections
  • collections, extending / Extending models/collections
  • views, extending / Extending controllers/views
  • controllers, extending / Extending controllers/views
• generic component types
  • about / Generic component types
  • modules / Modules
  • routers / Routers
  • models / Models/Collections
  • collections / Models/Collections
  • controllers / Controllers/Views
  • views / Controllers/Views
  • templates / Templates
  • application-specific components / Application-specific components

H

• hash URIs / Hash URIs

I

• indirection / Defining your constants
• influencer checklist
  • about / Influencer checklist
  • scaling user checklist / User checklist
  • scaling feature checklist / Feature checklist
  • developer checklist / Developer checklist

J

• JavaScript
  • profiling, URL / Profiling code

L

• locales
  • about / Locales
  • supporting / Supporting locales
  • deciding / Deciding on locales to support
  • maintaining / Maintaining locales
  • setting / Setting the locale
  • selecting / Choosing locales
  • preferences, storing / Storing locale preferences
  • in URIs / Locales in URIs
  • performance implications / Configurable locale performance
• logging and debugging
  • about / Logging and debugging
  • error logs / Meaningful error logs
  • potential failure warnings / Warning about potential failures
  • informing users / Informing and instructing users
  • instructing, users / Informing and instructing users
• loosely-coupled communication
  • about / Loosely-coupled communication
  • components, substituting / Substituting components
  • unexpected events, handling / Handling unexpected events

M

• mock scenarios
  • testing / Testing mock scenarios
  • mock APIs / Mock APIs and test fixtures
  • generation tools / Scenario generation tools
• models
  • about / Models/Collections
  • extending / Extending models/collections

P

• performance and complexity implications
  • about / Performance and complexity
  • exception handling / Exception handling
  • component state, checking / State checking
  • other components, notifying / Notifying other components
• performance implications
  • about / Performance implications
  • configurable locale performance / Configurable locale performance
  • configurable behavior performance / Configurable behavior performance
  • configurable theme performance / Configurable theme performance
• pluggable business logic
  • about / Pluggable business logic
  • extending, versus configuring / Extending versus configuring
  • stateless business logic / Stateless business logic
• preference types
  • locales / Preference types, Locales
  • behavior / Preference types, Behavior
  • appearance / Preference types, Appearance
• publish-subscribe / Message-passing models

R

• referential transparency / Dealing with side-effects
• router configuration
  • about / Router configuration
  • static route declarations / Static route declarations
  • registration events / Registration events
  • routes, deactivating / Deactivating routes
• routers
  • about / Routers
  • extending / Extending router components
  • working / How routers work
  • responsibilities / Router responsibilities
  • events / Router events
  • troubleshooting / Troubleshooting routers
  • conflicting / Conflicting routes
  • initial configuration, logging / Logging initial configuration
  • route events, logging / Logging route events
  • invalid resource states, handling / Handling invalid resource states
• routes / Routers
  • triggering / Triggering routes
  • user action / User actions
  • users, redirecting / Redirecting users
• routing approaches
  • about / Approaches to routing
  • hash URIs / Hash URIs
  • traditional URIs / Traditional URIs

S

• scaling constraints
  • about / Scaling constraints
  • JavaScript artifact size / JavaScript artifact size
  • network bandwidth / Network bandwidth
  • memory consumption / Memory consumption
  • CPU consumption / CPU consumption
  • back-end capabilities / Backend capabilities
• scaling development
  • about / Scaling development
  • resources, searching / Finding development resources, How do we find the right development resources?
  • responsibilities / Development responsibilities
  • multiple resources / Too many resources
  • example / Scaling development example
  • responsibilities, allocating / How do we allocate development responsibilities?
  • resources hiring, avoiding / Can we avoid hiring too many resources?
• scaling features
  • about / Scaling features
  • application value / Application value
  • killer features / Killer features versus features that kill
  • data-driven features / Data-driven features
  • products, competing with / Competing with other products
  • existing features, modifying / Modifying existing features
  • supporting user groups and roles / Supporting user groups and roles
  • new services / Introducing new services
  • real-time data, consuming / Consuming real-time data
  • example / Scaling features example
  • checklist / Feature checklist
• scaling features checklist
  • core value proposition / What's the core value proposition of our software?
  • feasibility, determining / How do we determine the feasibility of a feature?
  • informed decisions, making / Can we make informed decisions about our features?
  • competitor / Who's our competition?
  • features, enhancing / How do we make what we have better?
  • user management, integrating into features / How do we integrate user management into our features?
  • coupling ,to backend services / Are our features tightly coupled to backend services?
  • front-end, synchronizing with back-end data / How does the frontend stay synchronized with backend data?
• scaling influencers
  • about / Scaling influencers
  • uses / The need for scale
  • user base, growing / Growing user base
  • new features, building / Building new features
  • developers, hiring / Hiring more developers
  • architectural perspectives / Architectural perspectives
• scaling user
  • checklist / User checklist
• scaling user checklist
  • about / User checklist
  • software business model / What's the business model of our software?
  • application, user roles / Does our application have different user roles?
  • software, used for communication / Do our users communicate with each other using our software?
  • application support / How do we support our application?
  • feedback, collecting from user / How do we collect feedback from users?
  • user notification, sending / How do we notify users with relevant information?
  • user metrics, collecting / What type of user metrics should we collect?
• scaling users
  • about / Scaling users
  • license fees / License fees
  • subscription fees / Subscription fees
  • consumption fees / Consumption fees
  • sd-supported option / Ad-supported
  • open source / Open source
  • user communication channels / Communicating users
  • support mechanisms / Support mechanisms
  • feedback mechanisms / Feedback mechanisms
  • users, notifying / Notifying users
  • user metrics / User metrics
  • example / Scaling users example

T

• themes
  • modifying / Changing the look and feel
  • theme tools, using / Theme tools
  • selecting / Selecting a theme
  • style preferences / Individual style preferences
  • performance implications / Configurable theme performance
• TODO application / Frameworks don't scale out-of-the-box
• toolchain / Toolchains and automation
• traceable component communication
  • about / Traceable component communication
  • events, subscribing to / Subscribing to events
  • globally-logging events / Globally-logging events
  • event life-cycle / Event lifecycle
• traditional URIs / Traditional URIs
• trie structure / Router responsibilities

U

• unit testing tools
  • about / Unit testing tools
  • built, into frameworks / Tools built into frameworks
  • standalone unit testing tools / Standalone unit testing tools
  • toolchains / Toolchains and automation
  • automation / Toolchains and automation
• uri() function / Automating resource URIs
• URI parts and patterns
  • about / URI parts and patterns
  • information, encoding / Encoding information
  • designing / Designing URIs
• URIs
  • designing / Designing URIs
  • resource, mapping to / Mapping resources to URIs
  • building manually / Building URIs manually
  • resource URIs, automating / Automating resource URIs
  • locales / Locales in URIs

V

• view components / DOM updates
• views
  • about / Controllers/Views
  • extending / Extending controllers/views
• virtual DOM / DOM rendering techniques

W

• web analytics toolkit
  • URL / Growing user base