Index
Symbols
- “_” underscore prefix, Revealing Pattern-Revealing Pattern
A
- abstractions
- choosing, Finding the Right Abstractions-Finding the Right Abstractions, Composability and Scalability-Composability and Scalability, Abstractions Evolve in Small Steps-Abstractions Evolve in Small Steps, Do Repeat Yourself, Occasionally-Do Repeat Yourself, Occasionally
- premature adoption of, Modular Granularity, Finding the Right Abstractions, Factoring Similar Tasks-Factoring Similar Tasks
- when to use, Factoring Similar Tasks-Factoring Similar Tasks, Abstraction Matters-Abstraction Matters
- Amazon S3, Statelessness
- AngularJS, RequireJS, AngularJS, and Dependency Injection-RequireJS, AngularJS, and Dependency Injection, Modular JavaScript: A Necessity
- API shapes (see shapes)
- API-first principle, API First-API First
- architecture
- code patterns for (see patterns)
- modular, Modular JavaScript: A Necessity, Feature Isolation
- requirements of, limiting, Modular Granularity
- aspects, The Perks of Composition: Aspects and Extensions-The Perks of Composition: Aspects and Extensions
- async functions, Navigating Callbacks, Promises, and Asynchronous Functions
- asynchronous code flows, Navigating Callbacks, Promises, and Asynchronous Functions-Navigating Callbacks, Promises, and Asynchronous Functions
B
- Babel, ES6, import, Babel, and Webpack
- Backbone.js, Modular JavaScript: A Necessity
- black boxes, interfaces as, Interfaces as Black Boxes-Interfaces as Black Boxes
- book resources, Why Modular JavaScript?
- branch flipping, Guard Clauses and Branch Flipping-Guard Clauses and Branch Flipping
- Browserify, Node.js and the Advent of CommonJS
- build processes, Build, Release, Run-Build, Release, Run
C
- caching, Statelessness-Statelessness
- callback hell pattern, Containing Nested Complexity, Flattening Nested Callbacks-Flattening Nested Callbacks
- callbacks, Navigating Callbacks, Promises, and Asynchronous Functions-Navigating Callbacks, Promises, and Asynchronous Functions
- CI (continuous integration) environment, Build, Release, Run-Build, Release, Run
- CJS (CommonJS), Node.js and the Advent of CommonJS
- closures, Revealing Pattern
- code patterns (see patterns)
- complexity
- defining, Modularity Principles-Modularity Principles
- flexibility increasing, The Perks of Modular Design, Composability and Scalability
- from frameworks, Frameworks: The Good, the Bad, and the Ugly-Frameworks: The Good, the Bad, and the Ugly
- interfaces hiding, Introduction to Module Thinking-Introduction to Module Thinking
- internal, Internal Complexity-Frameworks: The Good, the Bad, and the Ugly
- from long branches, Guard Clauses and Branch Flipping-Guard Clauses and Branch Flipping
- from minimal variables, Embracing Variables over Clever Code-Embracing Variables over Clever Code
- from nesting, Containing Nested Complexity-Containing Nested Complexity, Flattening Nested Callbacks-Flattening Nested Callbacks
- from non-pyramidal code structure, An Interdependency Pyramid-Extracting Functions
- from state, Current State: It’s Complicated-Current State: It’s Complicated
- from tight coupling, Feature Entanglement and Tight Coupling
- component-level design (see module-level design)
- composition, Composability and Scalability-Composability and Scalability, Composition and Inheritance-Choosing Between Composition and Inheritance
- configuration management, Secure Configuration Management-Secure Configuration Management
- consistency, Consistency
- (see also CRUST)
- const bindings, Striving for Simple const Bindings-Striving for Simple const Bindings
- contact information for this book, How to Contact Us
- continuous integration (CI) environment, Build, Release, Run-Build, Release, Run
- conventions, coding, Frameworks: The Good, the Bad, and the Ugly-Frameworks: The Good, the Bad, and the Ugly
- (see also patterns)
- conventions, typographical, used in this book, Conventions Used in This Book
- CRUST (consistent, resilient, unambiguous, simple, tiny), CRUST: Consistent, Resilient, Unambiguous, Simple, and Tiny-Tiny Surface Areas, CRUST Considerations-Trade-Offs When Designing Internals
- current state, Current State: It’s Complicated-Current State: It’s Complicated
- cyclomatic complexity, Modularity Principles
D
- data persistence, Eliminating Incidental State, Statelessness
- (see also state)
- data store, Statelessness
- data structures
- containing logic using, Restricting and Clustering Logic-Restricting and Clustering Logic
- design based on, Data Structures Are King-Data Structures Are King
- isolating from logic, Isolating Data and Logic-Isolating Data and Logic
- debugging, Error Handling, Mitigation, Detection, and Solving
- denormalization, Eliminating Incidental State
- dependency injection, RequireJS, AngularJS, and Dependency Injection-RequireJS, AngularJS, and Dependency Injection
- dependency management, Explicit Dependency Management-Explicit Dependency Management
- deployment processes, Build, Release, Run
- destructuring, Destructuring, Rest, and Spread-Destructuring, Rest, and Spread
- development methodology, Development Methodology and Philosophy
- (see also modular design; module-level design)
- API-first principle, API First-API First
- build processes, Build, Release, Run-Build, Release, Run
- configuration management, Secure Configuration Management-Secure Configuration Management
- dependency management, Explicit Dependency Management-Explicit Dependency Management
- interfaces as black boxes, Interfaces as Black Boxes-Interfaces as Black Boxes
- parity divergences, minimizing, Parity in Development and Production-Parity in Development and Production
- state management, State Management-State Management, State as Entropy-Leveraging Immutability, Statelessness-Statelessness
- disposability, Statelessness
- documentation, Documentation as an Art-Documentation as an Art, Interfaces as Black Boxes
- dot env files, Secure Configuration Management
- DRY (Don’t Repeat Yourself) principle, Do Repeat Yourself, Occasionally-Do Repeat Yourself, Occasionally
E
- early exits or returns (see guard clauses)
- ECMAScript modules (ESM), ES6, import, Babel, and Webpack
- Ember.js, Modular JavaScript: A Necessity
- entropy, state as, State Management, State as Entropy
- .env.browser.json file, Secure Configuration Management
- .env.defaults.json file, Secure Configuration Management
- .env.json file, Secure Configuration Management
- .env.production.json file, Secure Configuration Management
- .env.staging.json file, Secure Configuration Management
- environment variables, Secure Configuration Management
- environment-specific logic, minimizing, Parity in Development and Production-Parity in Development and Production
- ephemeral state, Eliminating Incidental State
- error handling, Error Handling, Mitigation, Detection, and Solving
- ES6, ES6, import, Babel, and Webpack
- ESLint, Template Literals
- ESM (ECMAScript modules), ES6, import, Babel, and Webpack
- event emission, Event Emission
- event handling, Finding the Right Abstractions-Finding the Right Abstractions, Design for Today-Abstractions Evolve in Small Steps, The Perks of Composition: Aspects and Extensions-The Perks of Composition: Aspects and Extensions, Statelessness
- extension functions, The Perks of Composition: Aspects and Extensions
F
- factories (see object factories)
- feature entanglement (see tight coupling)
- feature isolation, Feature Isolation-Feature Isolation
- flexibility, The Perks of Modular Design, Composability and Scalability, Trade-Offs When Designing Internals
- frameworks, Frameworks: The Good, the Bad, and the Ugly-Frameworks: The Good, the Bad, and the Ugly
- functional aspects, The Perks of Composition: Aspects and Extensions-The Perks of Composition: Aspects and Extensions
- functions, Modular Granularity-Modular Granularity
- (see also module-level design)
- breaking apart, Slicing Large Functions-Slicing Large Functions
- conditionals in, Embracing Variables over Clever Code
- consistent shape of, Consistency, Unambiguity
- extracting from code, Extracting Functions-Extracting Functions
- pure, State Management, Leveraging Immutability
- pyramidal structure for, An Interdependency Pyramid-An Interdependency Pyramid
- for similar tasks, Factoring Similar Tasks-Factoring Similar Tasks
G
- generators, Navigating Callbacks, Promises, and Asynchronous Functions
- global scope, Script Tags and Closures, The Perks of Modular Design
- granularity, Introduction to Module Thinking, Modular Granularity-Modular Granularity
- guard clauses, Guard Clauses and Branch Flipping-Guard Clauses and Branch Flipping, Slicing Large Functions
I
- IIFE (Immediately Invoked Function Expression), Script Tags and Closures
- immutability, Leveraging Immutability
- incidental state, Eliminating Incidental State-Eliminating Incidental State
- inheritance, Composition and Inheritance-Inheritance Through Classes, Choosing Between Composition and Inheritance
- input sanitization, Interfaces as Black Boxes
- interfaces
- as black boxes, Interfaces as Black Boxes-Interfaces as Black Boxes
- complexity hidden by, Introduction to Module Thinking-Introduction to Module Thinking
- documenting, Documentation as an Art-Documentation as an Art
- resiliency in, Resiliency-Resiliency
- simplicity in, Simplicity-Simplicity
- tiny surface area of, Tiny Surface Areas
- touchpoints of, Introduction to Module Thinking, Revealing Pattern-Revealing Pattern, Abstractions Evolve in Small Steps
- well-designed, benefits of, The Perks of Modular Design, API First-API First, Trade-Offs When Designing Internals
- iterators, Navigating Callbacks, Promises, and Asynchronous Functions
J
- JavaScript
- books about, Why Modular JavaScript?
- history of modularity in, A Brief History of Modularity-ES6, import, Babel, and Webpack, Modular JavaScript: A Necessity-Modular JavaScript: A Necessity
- modern features of, Leveraging Modern JavaScript-Navigating Callbacks, Promises, and Asynchronous Functions
- modular design with (see modular design)
- JSON, Message Passing and the Simplicity of JSON-Message Passing and the Simplicity of JSON
L
- layers
- for business logic, Introduction to Module Thinking, Statelessness
- for horizontal scaling, Modular Granularity
- when needed, Feature Isolation, Frameworks: The Good, the Bad, and the Ugly
M
- maintainability, The Perks of Modular Design
- message passing, Message Passing and the Simplicity of JSON-Message Passing and the Simplicity of JSON
- MobX, Statelessness
- modular design, Introduction to Module Thinking-Introduction to Module Thinking
- (see also development methodology)
- abstractions in (see abstractions)
- benefits of, The Perks of Modular Design-The Perks of Modular Design
- books about, Why Modular JavaScript?
- composition in (see composition)
- CRUST principles for, CRUST: Consistent, Resilient, Unambiguous, Simple, and Tiny-Tiny Surface Areas
- granularity with, Introduction to Module Thinking, Modular Granularity-Modular Granularity
- interfaces in (see interfaces)
- JavaScript features for, Leveraging Modern JavaScript-Navigating Callbacks, Promises, and Asynchronous Functions
- JavaScript history of, A Brief History of Modularity-ES6, import, Babel, and Webpack, Modular JavaScript: A Necessity-Modular JavaScript: A Necessity
- necessity of, Modular JavaScript: A Necessity-Modular JavaScript: A Necessity
- patterns for (see patterns)
- readability in, Resiliency
- scalability with (see scalability)
- SRP (single responsibility principle), Single Responsibility Principle-Single Responsibility Principle
- state management in, State Management-State Management
- module-level design
- composability, Composability and Scalability-Composability and Scalability
- context of, considering, Applying Context
- CRUST principles for, CRUST Considerations-Trade-Offs When Designing Internals
- data structures in, Data Structures Are King-Restricting and Clustering Logic
- debugging, Error Handling, Mitigation, Detection, and Solving
- documentation, Documentation as an Art-Documentation as an Art
- error handling, Error Handling, Mitigation, Detection, and Solving
- frameworks for, Frameworks: The Good, the Bad, and the Ugly-Frameworks: The Good, the Bad, and the Ugly
- nesting, reducing complexity of, Containing Nested Complexity-Containing Nested Complexity
- pace of development, Abstractions Evolve in Small Steps-Move Deliberately and Experiment
- priorities for, Trade-Offs When Designing Internals-Trade-Offs When Designing Internals
- refactoring code (see refactoring code)
- removing code, Removing Code-Removing Code
- requirements of, limiting, Design for Today-Design for Today
- scalability, Composability and Scalability-Composability and Scalability
- splitting modules, Feature Isolation-Feature Isolation
- state, minimizing, State as Entropy-Leveraging Immutability
- testing, Error Handling, Mitigation, Detection, and Solving
- tight coupling, avoiding, Feature Entanglement and Tight Coupling
- “Move Fast and Break Things” mantra, Move Deliberately and Experiment
- multiline strings, Template Literals
N
- nconf npm package, Secure Configuration Management
- nesting, reducing complexity of, Containing Nested Complexity-Containing Nested Complexity, Flattening Nested Callbacks-Flattening Nested Callbacks
- Node.js, Node.js and the Advent of CommonJS
- NODE_ENV variable, Secure Configuration Management
O
- object factories, State Management, Object Factories-Object Factories
- object spread, Destructuring, Rest, and Spread
- online resources, for this book, How to Contact Us
P
- parity divergences, minimizing, Parity in Development and Production-Parity in Development and Production
- patterns
- callback hell, Containing Nested Complexity, Flattening Nested Callbacks-Flattening Nested Callbacks
- event emission, Event Emission
- IIFE, Script Tags and Closures
- message passing, Message Passing and the Simplicity of JSON-Message Passing and the Simplicity of JSON
- object factories, State Management, Object Factories-Object Factories
- promise hell, Containing Nested Complexity, Flattening Nested Callbacks
- revealing module, Revealing Pattern-Revealing Pattern, Revealing Module-Revealing Module
- performance
- priority of, Modular Granularity, Trade-Offs When Designing Internals, Eliminating Incidental State
- Webpack features for, ES6, import, Babel, and Webpack
- persistence, Eliminating Incidental State, Statelessness
- (see also state)
- production build processes, Build, Release, Run
- promise hell pattern, Containing Nested Complexity, Flattening Nested Callbacks
- promises, Navigating Callbacks, Promises, and Asynchronous Functions-Navigating Callbacks, Promises, and Asynchronous Functions
- pure functions, State Management, Leveraging Immutability
- pyramidal code structure, An Interdependency Pyramid-An Interdependency Pyramid
R
- React, Modular JavaScript: A Necessity
- readability, Resiliency, Do Repeat Yourself, Occasionally, Embracing Variables over Clever Code-Embracing Variables over Clever Code
- README-driven development, Documentation as an Art
- realized state, Eliminating Incidental State
- Redis, Statelessness
- Redux, Statelessness
- refactoring
- branch flipping, Guard Clauses and Branch Flipping-Guard Clauses and Branch Flipping
- breaking apart functions, Slicing Large Functions-Slicing Large Functions
- determining when needed, Internal Complexity, Refactoring Complex Code
- extracting functions, Extracting Functions-Extracting Functions
- guard clauses, Guard Clauses and Branch Flipping-Guard Clauses and Branch Flipping
- nested callbacks, flattening, Flattening Nested Callbacks
- pyramidal structure for, An Interdependency Pyramid-An Interdependency Pyramid
- for similar tasks, Factoring Similar Tasks-Factoring Similar Tasks
- variables used in, Embracing Variables over Clever Code-Embracing Variables over Clever Code
- RequireJS, RequireJS, AngularJS, and Dependency Injection-RequireJS, AngularJS, and Dependency Injection
- resiliency, Resiliency-Resiliency
- rest parameters, Destructuring, Rest, and Spread-Destructuring, Rest, and Spread
- reusability
- code removal and, Removing Code
- functions for, Factoring Similar Tasks-Factoring Similar Tasks
- revealing module pattern, Revealing Pattern-Revealing Pattern, Revealing Module-Revealing Module
S
- scalability
- horizontal, with composition, Composability and Scalability-Composability and Scalability, Composition and Inheritance
- horizontal, with layers, Modular Granularity, Frameworks: The Good, the Bad, and the Ugly
- vertical, with inheritance, Composition and Inheritance
- scope
- global scope, Script Tags and Closures, The Perks of Modular Design
- hoisting and, An Interdependency Pyramid
- nesting and, Containing Nested Complexity-Feature Entanglement and Tight Coupling, Flattening Nested Callbacks
- removing functions from, Extracting Functions
- <script> tag, Script Tags and Closures
- security
- configuration management, Secure Configuration Management-Secure Configuration Management
- input sanitization, Interfaces as Black Boxes
- in production, Build, Release, Run, Parity in Development and Production
- shapes
- consistent, benefits of, Introduction to Module Thinking, Consistency, Unambiguity
- consistent, finding, Factoring Similar Tasks
- data structures determining, Data Structures Are King
- short circuits (see guard clauses)
- simplicity, Simplicity-Simplicity, Trade-Offs When Designing Internals
- spread operator, Destructuring, Rest, and Spread
- SRP (single responsibility principle), The Perks of Modular Design, Single Responsibility Principle-Single Responsibility Principle
- staging build processes, Build, Release, Run
- state
- caching, Statelessness-Statelessness
- complexity of, State Management, Current State: It’s Complicated-Current State: It’s Complicated
- containing, Containing State-Containing State
- as entropy, State Management, State as Entropy
- ephemeral, Eliminating Incidental State
- incidental, Eliminating Incidental State-Eliminating Incidental State
- levels of, State Management
- minimizing, State Management-State Management, State as Entropy-Leveraging Immutability, Statelessness-Statelessness
- realized, Eliminating Incidental State
- state management solution, Statelessness
- stateless servers, Statelessness
- strings, template literals for, Template Literals
- surface area, tiny, Tiny Surface Areas
T
- TDD (test-driven design), Documentation as an Art
- template literals, Template Literals
- testing, Error Handling, Mitigation, Detection, and Solving, Build, Release, Run
- tight coupling, Feature Entanglement and Tight Coupling
- tiny surface areas, Tiny Surface Areas
- touchpoints, exposing, Introduction to Module Thinking, Revealing Pattern-Revealing Pattern, Abstractions Evolve in Small Steps
- Twelve Factor App, Development Methodology and Philosophy
U
- unambiguity, Unambiguity
- underscore “_” prefix, Revealing Pattern-Revealing Pattern
V
- variables, readability increased by, Embracing Variables over Clever Code-Embracing Variables over Clever Code
W
- Webpack, ES6, import, Babel, and Webpack
- website resources, for this book, How to Contact Us
..................Content has been hidden....................
You can't read the all page of ebook, please click here login for view all page.