What you will learn in The Joy of JavaScript
Chapter by chapter
Concepts explained in this book
- compositionA pipeline is a composition pattern where output from one stage becomes input to the next stage in sequence.
- streamingA stream is a sequence of one or more values or events that can be consumed incrementally over time.
- ValidationA computation or data structure that represents success or failure and supports propagating results through the successful branch while preserving failure context.
- pure functionA pure function is a function whose output is determined solely by its explicit inputs and whose evaluation has no externally observable side effects.
- higher-order functionA higher-order function is a function that takes one or more functions as arguments and/or returns a function as its result.
- curryingA technique that transforms a function of multiple arguments into a sequence of functions each taking a single argument.
- moduleA module system is a set of rules and mechanisms for organizing code into modules and controlling how they export and import bindings.
- mixinA composition approach that combines reusable behavior into objects by mixing in properties or methods from multiple sources.
- observableAn Observable is a push-based abstraction that represents a stream of values or events over time and can be subscribed to for delivery of those emissions.
- functorA functor is a structure or abstraction that provides a mapping operation over contained values while preserving the surrounding structure.
- promiseA JavaScript Promise is an object representing the eventual completion or failure of an asynchronous operation and its resulting value or reason.
- monadAn abstraction for sequencing computations through a context that can carry values and effects while supporting composition via flatMap-like chaining.
- functional, stateless philosophyA programming paradigm that models computation as the evaluation of functions, often emphasizing immutability and function composition.
- side effectA side effect is any observable change to state or the external world caused by evaluating an expression or executing a function beyond producing a return value.
- data transformationA map is a function or method that applies a transformation to each element or value in a structure and returns a corresponding structure.
- immutable collectionAn object whose fields cannot be changed after creation and whose state is represented without in-place mutation.
- flatmapFunctional composition operations that transform values and flatten nested computations or containers.
- prototypeIn JavaScript object creation, the prototype is an object that serves as the shared delegate from which other objects can inherit properties and methods.
- blockchainA blockchain is a distributed append-only ledger composed of chronologically ordered blocks linked by cryptographic hashes.
- point-free styleA functional programming style in which functions are composed without explicitly naming the intermediate argument being transformed.
- algebraic data typeA composite type formed by combining simpler types with sum and product structure to represent a finite set of possibilities.
- property lookupThe process by which a language determines which property value or method is returned when a property access occurs.
- delegationA composition style in which an object forwards behavior or property lookup to another object through delegation links rather than copying or class inheritance.
- database transactionA book-local transaction object in the blockchain domain that models a transfer record and related behavior.
- symbolSymbol is the JavaScript built-in function object used to create symbol values, with static methods for symbol-related operations such as global lookup.
- Object.create()A JavaScript built-in function that creates a new object with a specified prototype object.
- prototype-based object orientationAn inheritance style in which an object delegates property and method lookup to objects linked in its prototype chain.
- initializerA callable JavaScript function intended to initialize a newly created object when invoked with construction semantics.
- async/awaitAn async function is a JavaScript function that returns a Promise and can suspend execution while awaiting asynchronous work.
- IdA book-local identity container type that wraps a single value without adding additional computational context.
- event loopAn event loop is a runtime scheduling mechanism that repeatedly dequeues and executes pending callbacks or tasks to drive asynchronous execution.
- async iteratorAn async iterator is an iterator interface for producing values asynchronously, typically yielding a sequence of promised results over time.
- push modelPush-based programming is a style where data is delivered to consumers when it becomes available rather than being pulled on demand.
- proof of workA computational procedure that requires searching for a value meeting a difficulty condition, often by repeated hashing.
- classA class is a programming-language construct that defines a type’s structure or behavior and provides a basis for creating or representing objects.
- blockA block is a fixed unit of data in a blockchain that groups transactions and metadata for chaining to prior blocks.
- operatorA composable function or transformation that processes an observable sequence or stream element by element.
- abstract data typeA data abstraction defined by its behavior and operations rather than by its concrete representation.
- pipe operatorA syntax that forwards a value through a sequence of operations, commonly used in functional programming languages.
- generatorA generator is a function or function-derived object in JavaScript that can produce a sequence of values over time and support iterator semantics.
- HasValidationA book-local mixin that adds validation behavior to objects by contributing a validation API.
- proxyA Proxy is a JavaScript object that wraps a target object and intercepts fundamental operations on it through handler traps.
- import statementA JavaScript module feature for bringing exported bindings or module namespaces into the current module.
- imperative programmingA programming paradigm that describes computation as a sequence of commands that change program state.
- throwA throw expression is an expression form that raises an exception from within an expression context.
- Object.assignObject.assign is a JavaScript built-in function that copies enumerable own properties from source objects to a target object.
- iteratorAn iterator object is an object that implements the iterator protocol by providing a next method that produces iteration results.
- MoneyAn immutable value object representing an amount of currency identified by its quantity and currency unit.
- calculateHashcalculateHash is a book-local method name for computing a hash value from selected properties.
- WalletA book-local user-facing object representing a holder of blockchain addresses or keys.
- CommonJSA server-side JavaScript module specification that defines modules using synchronous loading and the require/module.exports convention.
- hash functionThe process of computing a fixed-size digest or hash value from input data using a hash function.
- declarative programmingA style of programming that expresses the desired result rather than the step-by-step control flow used to compute it.
- asynchronous generatorAn async generator is a generator construct that produces asynchronous iteration, allowing values to be yielded over time with async semantics.
- iterable protocolSymbol.iterator is a built-in JavaScript symbol that defines the method an object uses to provide its iterator.
- then methodA Promise method used to register fulfillment and rejection handlers and compose promise-based workflows.
- inheritance configurationAn arrangement of objects and prototype links that determines how properties and behavior are inherited.
- pull modelA communication or data-flow model in which a consumer requests data when it needs it.
- concatenative object extensionAn object-composition pattern that extends an object by copying additional properties into it after its initial creation.
- recursionA technique in which a function calls itself directly or indirectly to solve a problem by reducing it to smaller instances.
- metaprogrammingMetaprogramming is the practice of writing programs that inspect, generate, or modify other programs or their own structure.
- import/export syntaxA JavaScript module feature for making bindings or values available to other modules.
- type-lifting functionA type-lifting function is a constructor-like function that places a raw value into a context or container type.
- private memberA class method that cannot be accessed from outside the class definition.
- Promise#catchA Promise method used to register a handler for promise rejection.
- HasHashHasHash is a book-local mixin pattern that adds hashing-related behavior to an object or class.
- isValidA book-local function that returns a validation result indicating whether an element satisfies the required checks.
- ReflectReflect is a JavaScript built-in object that provides methods for performing reflective operations on objects.
- decoratorA wrapper-like construct that augments method behavior without changing the method's core implementation.
- referential transparencyA property of an expression whose value can be replaced by that value without changing program behavior, assuming no observable side effects.
- closureA function together with the lexical environment in which it was created, allowing it to retain access to enclosed bindings.
- cross-cutting concernCross-cutting behavior is behavior that affects multiple parts of a program and is not naturally localized to a single module or class.
- modularityA software design approach that structures a program as separate modules with well-defined responsibilities and interfaces.
- pseudoclassical modelA JavaScript object-creation style that emulates class-based inheritance using constructor functions and prototype links.
- cryptocurrencyA digital currency that uses cryptographic techniques to secure transactions and control the creation of new units.
- bind operatorA proposed JavaScript operator syntax for binding a method or function call to a receiver, often written ::.
- prototype pollutionA vulnerability or failure mode in which modifying a prototype affects many objects that inherit from it.
- callbackA callback is a function passed as an argument to another function to be invoked later or in response to an event or condition.
- nested promiseA promise arrangement in which one Promise is returned from another Promise reaction so the inner asynchronous work rejoins the outer chain.
- promise chainA promise chain is a sequence of linked Promise reactions in which each step receives the result or failure of the previous step.
- propA book-local helper function that returns a property value from an object by property name, often in curried form.
- partial applicationPartial application is the creation of a new function by binding some arguments of an existing function while leaving the remaining arguments to be supplied later.
- filesystem APIAn interface exposed by a runtime or operating system for reading, writing, and managing files and directories.
- balanceThe amount of value associated with an account or wallet after transactions are accounted for.
- composeMA composition function that sequences operations by using monadic flatMap to pass intermediate results through a chain.
- reflectionA programming paradigm in which a program can inspect or modify its own structure and behavior.
- Symbol.observableA well-known JavaScript symbol proposed for defining how an object converts to or exposes an observable representation.
- immediately invoked function expressionA function expression that is defined and executed immediately, often to create a private scope and avoid leaking bindings.
- copy-on-writeA mutation strategy in which changes are made by creating modified copies rather than altering an existing value in place.
- differential inheritanceA prototype-based inheritance style in which a derived object shares a linked parent object and adds or overrides differences.
- value objectAn immutable object whose equality and identity are determined by its attribute values rather than by a stable external identifier.
- closed contextAn execution context that encloses and controls the behavior of operations without exposing internal control flow to the outside.
- object literalA JavaScript syntax form for creating an object directly from a literal expression.
- serializationThe process of converting data or objects from one representation into another for storage, transmission, or reconstruction.
- iterableAn iterable is an object or value that can be consumed by an iteration protocol to produce a sequence of elements.
- method fusionAn optimization technique that combines multiple chained operations into fewer passes over a data structure to reduce allocation and overhead.
- subscribesubscribe is the operation that attaches a consumer to an observable or similar event source so emissions are delivered to that consumer.
- async iterableAn async iterable is a value or object that produces a sequence of elements asynchronously during iteration.
- inheritanceA code-reuse relationship in which one object or construct acquires or specializes behavior and data from another.
- reduction operationA function or method that combines a collection of values into a single accumulated result.
- publish/subscribe modelAn architecture in which publishers emit events or messages to subscribers without requiring direct coupling between them.
- function bindingThe JavaScript method that creates a new function with a bound this value and optional leading arguments.
- thisthis is a JavaScript binding whose value depends on the call site and refers to the current execution context or receiver.
- higher-kinded compositionA composition approach in which objects compose through higher-level interfaces or abstractions analogous to function composition.
- unsubscribeunsubscribe is the operation that detaches a consumer from an observable or similar event source so emissions stop being delivered.
- default valueA function parameter that takes a predefined value when no argument is supplied.
- dynamic module systemA module system in which dependencies and module interfaces are determined programmatically at runtime rather than by static language syntax.
- static module systemA module system in which module dependencies and exports are declared by fixed language syntax that can be analyzed before execution.
- new keywordThe JavaScript operator keyword that creates a new object instance by invoking a constructor function or class.
- prototype chain configurationThe arrangement of prototype links and object relationships that determines lookup and inheritance behavior in an object system.
- TC39TC39 is the ECMAScript Technical Committee that develops and maintains the JavaScript language standard.
- tree-shakingA bundler optimization that removes unused exports, modules, or code paths from a program during build time.
- SubscriptionA Subscription is an object that represents an ongoing connection to a stream or observable source for receiving values over time.
- unidirectional data pipelineUnidirectional data flow is an architecture in which data moves in one direction through a system from source to sink.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.