← Back to JavaScript

JavaScript Glossary

Key terms from the JavaScript course, linked to the lesson that introduces each one.

405 terms.

A

Abstract Syntax Tree
The result of parsing is called an Abstract Syntax Tree (AST).
Lesson 13 — Parsing and the Abstract Syntax Tree
access
An object with get and/or set methods for reading/writing the decorated element (not available for all kinds)
Lesson 2070 — The Decorator Function Signature
Accidental breaking changes
A maintainer renames an "internal" function that users were actually importing
Lesson 2526 — Semver in Practice: Trust and Reality
accumulator
The partially completed product moving down the line
Lesson 454 — The Reducer Function Signature
Actions
Actions are side effects that occur during a transition or while in a particular state.
Lesson 2426 — State and Transition Vocabulary
Allocation Instrumentation on Timeline
While heap snapshots give you static pictures of memory, Allocation Instrumentation on Timeline is like a video recording.
Lesson 1890 — Using Allocation Instrumentation on Timeline
Allocation sampling
A lighter-weight version that samples allocations periodically
Lesson 1884 — Opening DevTools Memory Profiler
Analogy
If Blob is like a sealed envelope containing data, File is that same envelope with a return address, postmark date, and label describing its contents.
Lesson 1295 — Chaining vs NestingLesson 1927 — Common Measurement PitfallsLesson 2367 — The File Interface
anonymous function
An anonymous function is simply a function without a name.
Lesson 382 — Anonymous Functions
any
You eat the first edible pizza; only panic if all are inedible
Lesson 1316 — Comparing any, race, all, and allSettled
Any name when importing
The importer chooses the name
Lesson 1411 — Default Export Syntax
Arguments
Arguments are the actual values you provide when calling that function.
Lesson 403 — Parameters vs Arguments: The Difference
Arity
Arity is simply the number of parameters a function expects.
Lesson 483 — Composition with Arity and CurryingLesson 1771 — Arity and Curry Depth
array
The blueprint showing all parts
Lesson 454 — The Reducer Function Signature
array literal
An array literal is the straightforward way to create an array in JavaScript.
Lesson 799 — Creating Arrays with Array Literals
Array of paths
Array of paths means "only these files have side effects; everything else is safe to tree shake."
Lesson 2469 — Side Effects and 'sideEffects' Field
Array-likes
Array-likes are objects that have a length property and numbered indices (like {0: 'a', 1: 'b', length: 2}), but don't necessarily have Symbol.iterator.
Lesson 1083 — Iterators vs Array-likes
ArrayBuffer
An ArrayBuffer is a fixed-length container that holds raw binary data in memory.
Lesson 2332 — What is an ArrayBuffer?
assertion
An assertion is a statement in your test code that declares what you expect to be true.
Lesson 2672 — What Are Assertions?
Associativity
Associativity is the rule that determines whether operators group from left-to-right or right-to-left when they share the same precedence level.
Lesson 271 — Associativity: Left-to-Right vs Right-to-Left
async generator
An async generator is a special function that combines two powerful features you already know:
Lesson 2038 — What Are Async Generators?
Asynchronous callbacks
Asynchronous callbacks are different: they're stored by the JavaScript environment and invoked later, after some event occurs (like a timer finishing or data arriving).
Lesson 1224 — Asynchronous CallbacksLesson 1225 — Callback Execution Context
auto-boxing
Behind the scenes, JavaScript performs a clever trick called auto-boxing.
Lesson 43 — Primitive Wrapper Objects

B

backpressure
Backpressure is the mechanism that solves this: it tells the producer to slow down or pause when the consumer can't keep up.
Lesson 1557 — Handling Write BackpressureLesson 1575 — What is Backpressure?
Batching
Batching means collecting multiple signal updates into a single transaction, then propagating changes once at the end.
Lesson 2123 — Batching and Glitch-Free Updates
Best practice
Explicit function calls are more maintainable
Lesson 719 — Why __proto__ Is Deprecated in Modern Code
Better performance
Maps are optimized for frequent additions and deletions
Lesson 1031 — What is a Map and Why Use It?
BigInt
BigInt is like a bank vault—handles any amount but requires more ceremony to use.
Lesson 1972 — When to Use BigInt vs Number
Bitwise operators
Bitwise operators are special operators that work at the lowest level of how computers store numbers: as sequences of 1s and 0s (binary).
Lesson 253 — What Are Bitwise Operators?
block
A block is any pair of curly braces that isn't part of a function or object.
Lesson 80 — Block Scope BasicsLesson 81 — Blocks vs Functions
blocking
This is called blocking behavior because each operation blocks (prevents) the next one from starting until it finishes.
Lesson 1170 — What 'Synchronous' Means in JavaScript
Blocking behavior
require() freezes your program until loading completes. Dynamic import() never blocks — perfect for web applications where freezing the UI is unacceptable.
Lesson 1429 — Dynamic Import vs require()
Blocks
Blocks are like rooms in a building — let and const can't leave the room they're declared in
Lesson 81 — Blocks vs Functions
Boolean
In JavaScript, a Boolean is the simplest data type — it can only be one of two values: true or false.
Lesson 192 — The Boolean Type and Its Two Values
Breaks assumptions
You think variables are independent when they're not
Lesson 52 — Pitfall: Unintended Shared State
browser runtime
The browser runtime is the complete environment where your code runs, and it includes the engine plus a collection of powerful tools called Web APIs.
Lesson 17 — Browser Runtime: DOM and Web APIs
Buffer
Buffer is Node.js-specific and includes additional methods for common binary operations (like toString() with various encodings, readInt32LE(), etc.).
Lesson 1582 — What is a Buffer?Lesson 1591 — Buffer and TypedArraysLesson 2326 — Buffer, ByteOffset, and BYTES_PER_ELEMENT
Building predictable functions
Functions that don't mutate their inputs are easier to test, reason about, and reuse. They're "pure" — same input always produces same output without side effects.
Lesson 837 — When to Prefer Non-Mutating Methods
Bun
Deno and Bun are newer runtimes built to address some of Node.js's limitations while adding modern conveniences.
Lesson 19 — Deno and Bun: Alternative Runtimes
bundler
A bundler is a build tool that takes multiple JavaScript files (modules) and combines them into one or more optimized output files that browsers can efficiently load and execute.
Lesson 2453 — What is a bundler and why do we need one?
byteLength
The total number of bytes the array occupies in memory
Lesson 2325 — Length and ByteLength Properties

C

call stack
The call stack is JavaScript's internal to-do list for functions.
Lesson 1181 — What is the Call Stack?
callback pattern
This is called a callback pattern — the function you pass gets "called back" by the outer function.
Lesson 429 — Passing Functions as Arguments
callback queue
A callback queue is an array of functions maintained in closure scope that you accumulate over time and then execute all at once (or in a controlled sequence).
Lesson 519 — Callback Queues
Callback-based async
Callback-based async is like giving them your number and continuing your day—they'll call when ready.
Lesson 1517 — FS Module Overview: Sync vs Async vs Promises API
catastrophic backtracking
This is called catastrophic backtracking.
Lesson 1688 — Common Quantifier Pitfalls
Catch block
Handles the error if one is thrown. The error object contains details about what went wrong.
Lesson 2435 — The Traditional Throw/Try-Catch Pattern
chunk
the data being written (Buffer or string)
Lesson 1555 — Creating a Writable Stream
Clarity
The double underscores suggest it's internal/private
Lesson 719 — Why __proto__ Is Deprecated in Modern Code
Class declarations
Class declarations are named and exist in their entire scope, but unlike function declarations, they're not hoisted — you can't use them before the line they're declared.
Lesson 756 — When to Use Class Declarations vs Expressions
Class decorator returns a class
The returned class replaces the original entirely
Lesson 2077 — Returning Values from Decorators
Clear communication
Signals which properties are stable public API vs implementation details
Lesson 1829 — Convention-Based Privacy with Underscore Prefix
Clearer intent
The code shows you're extracting specific values
Lesson 915 — What is Array Destructuring?
closure
A closure is a function that retains access to variables from its outer (enclosing) scope, even after that outer scope has finished executing and "exited."
Lesson 496 — What a Closure Actually Is
columnNumber
The column number (Mozilla-specific)
Lesson 1148 — Error Object Properties
Combining comparison and logical operators
x > 5 && y < 10 is clear, but x > 5 && y < 10 || z === 0 benefits from grouping
Lesson 273 — When to Rely on Precedence vs Parentheses
Compact notation
Compact notation is perfect for dashboards and social media (showing "2.4K likes" instead of "2,400 likes").
Lesson 2205 — Grouping and Notation Options
comparator function
A comparator function is your solution: it's a custom function you pass to sort() that compares two elements and tells sort() which should come first.
Lesson 819 — sort() with Comparator FunctionsLesson 898 — Writing a Numeric Comparator
Compilation
Compilation means translating all the code into machine language before running it.
Lesson 14 — Interpretation vs Compilation
Composition
Composition means creating functionality by combining simple, focused objects or functions together, rather than forcing objects to inherit behavior from parent classes.
Lesson 1817 — What Composition Means
computed property
A computed property is a value that's derived from other properties instead of being stored directly.
Lesson 663 — Using Getters for Computed Properties
Configuration Structure
.eslintrc used nested objects with special keys like extends, env, and plugins. Flat config uses a flat array where each object represents a configuration layer you explicitly compose.
Lesson 2573 — Migrating from .eslintrc to Flat Config
Consistent Style Within a Project
Some teams prefer all declarations at the top. Others like definitions near their first use. What matters most is consistency across your codebase.
Lesson 426 — Best Practices for Function Ordering
Console open
Logged objects are retained indefinitely
Lesson 1878 — Console.log in Production Code
Const
Const is a locked drawer—you can't swap out what's inside, but if it's a container of items, you can still rearrange those items.
Lesson 76 — Var vs Let vs Const Summary
constructor method
The constructor method is a special method inside a class that runs automatically whenever you create a new instance using the new operator.
Lesson 747 — The Constructor Method
Content-Type
Tells the server what format your request body is in (like application/json when sending JSON data).
Lesson 2262 — Setting Request Headers
counter factory
A counter factory is a function that returns a new counter object (or function) every time you call it.
Lesson 510 — Counter Factories
CPU Cache Efficiency
Contiguous memory means better CPU cache utilization. When you access one element, nearby elements are likely already in cache—critical for loops processing large datasets.
Lesson 2330 — Performance Characteristics
Curry depth
Curry depth refers to how many nested function calls are needed before you get the final result.
Lesson 1771 — Arity and Curry Depth
Currying
Currying is a functional programming technique that converts a function taking multiple arguments into a sequence of functions, each taking a single argument.
Lesson 1764 — What Is Currying?

D

data URL
A data URL is a special type of URL that contains the actual file content inline, rather than pointing to an external resource.
Lesson 2359 — Data URLs with Base64
Debugging
Identifying which specific process instance is misbehaving
Lesson 1501 — Process.pid and Process.ppid
declarations
Hoisting is JavaScript's behavior during the compilation phase where declarations are processed before any code executes.
Lesson 90 — What is Hoisting?Lesson 381 — Function Expressions
Decorators
Decorators are a way to augment (modify or enhance) classes, methods, properties, and other class members by attaching metadata or wrapping them with additional behavior—without editing their original code.
Lesson 2067 — What Decorators Are and Why They Exist
Deduplication
Deduplication means npm identifies when multiple packages require compatible versions of the same dependency.
Lesson 2505 — Dependency Hoisting and Deduplication
Deep copies
Deep copies are essential when you have nested objects/arrays and need true independence
Lesson 2396 — Shallow vs Deep Copy
Deep dependency chains
A changes B, B changes C, C changes D
Lesson 2143 — Derived State and Automatic Recalculation
Default values or normalization
Automatically clean or format data as objects are created, keeping your constructor logic clean and declarative.
Lesson 2073 — Field Decorators
delimiter
The split() method transforms a string into an array by dividing it wherever a specific character or substring (called a delimiter) appears.
Lesson 173 — Splitting Strings into Arrays with split
dependency graph
Dependency resolution is the process of walking through your code's import/require statements and building a complete map—called a dependency graph—of every module your application uses.
Lesson 2446 — Dependency Resolution
Derived state
Derived state is data calculated from other data sources.
Lesson 2143 — Derived State and Automatic Recalculation
descriptor
An object specifying the property's attributes
Lesson 610 — Object.defineProperty
Detached DOM trees
Detached DOM trees are referenced in JavaScript but removed from the page
Lesson 1870 — What Qualifies as a Memory Leak in JavaScript
Distance calculations
Distance calculations are the classic example.
Lesson 1596 — Math.abs for Absolute Values
dot notation
The dot notation is the most straightforward syntax: you write the object's name, followed by a dot (.), followed by the property name you want to access.
Lesson 591 — Accessing Properties with Dot Notation
duplex stream
A duplex stream is a stream that is both readable and writable at the same time.
Lesson 1561 — What Are Duplex Streams?
Dynamic import
Dynamic import is different: it's a function-like syntax (import()) that loads modules on demand, during runtime, whenever and wherever you call it.
Lesson 1420 — What is Dynamic Import?
Dynamic Scope
The variable's location is determined by where the function is called from. The scope chain changes based on the call stack at runtime.
Lesson 490 — Static vs Dynamic Scope

E

e-notation
JavaScript lets you use scientific notation (also called e-notation) to express these values more clearly.
Lesson 102 — Scientific Notation (e-notation)
EACCES
EACCES (Error ACCESs) means you lack permission to read, write, or execute the file.
Lesson 1530 — Error Handling Patterns in FS Operations
early exit
This is called early exit and short-circuiting.
Lesson 377 — Early Exit and Short-Circuiting
early return
An early return means exiting a function before reaching its end.
Lesson 420 — Early Returns for Control Flow
early returning
This is called early returning in functions and short-circuiting in loops.
Lesson 1898 — Early Returns and Short-Circuiting
Easier to learn
The syntax (how you write code) reads more naturally
Lesson 1 — JavaScript: A High-Level Programming Language
Easier to test
small functions are simple to verify
Lesson 1777 — What is Function Composition?
Easier to understand
each step is explicit and named
Lesson 1777 — What is Function Composition?
Ecosystem Support
NPM is the default—every package works with it, every tutorial assumes it, and CI/CD pipelines support it without configuration. Yarn and PNPM have excellent compatibility, but you might occasionally hit edge cases with obscure packages or corporate proxies. If you're joining an existing project or using bleeding-edge tools, check their documentation for package manager requirements.
Lesson 2536 — Choosing the Right Package Manager
EEXIST
EEXIST means a file or directory already exists when you tried to create it.
Lesson 1530 — Error Handling Patterns in FS Operations
effect
In reactive systems, an effect is a function that runs automatically when the signals it depends on change.
Lesson 2120 — Effects and Side Effects
either switch
Think of it like two light switches controlling the same bulb — if either switch (or both) is flipped on, the light turns on.
Lesson 256 — Bitwise OR (|)
Encapsulate logic
the calculation stays hidden inside the object
Lesson 659 — Defining Getters with the 'get' Keyword
Encapsulation
Encapsulation is the practice of bundling data (properties) and behavior (methods) together while controlling what the outside world can see and modify.
Lesson 1827 — What Encapsulation Means in JavaScript
encoding
the character encoding (if chunk is a string)
Lesson 1555 — Creating a Writable Stream
end
The byte index where your slice ends, exclusive (default: blob.size)
Lesson 821 — copyWithin(): Copying Elements Within the Same ArrayLesson 2366 — Slicing Blobs
Endianness
Endianness refers to the order in which these bytes are stored.
Lesson 2329 — Byte Order and Endianness
ENOENT
ENOENT (Error NO ENTry) means "file or directory not found"—the path you specified doesn't exist.
Lesson 1530 — Error Handling Patterns in FS Operations
Environment
require() is Node.js (CommonJS). Dynamic import() works in both browsers and modern Node.js (ES Modules).
Lesson 1429 — Dynamic Import vs require()
Error handling context
If you return await, errors are caught within the current function's scope. If you just return the promise, errors bubble up directly to the caller.
Lesson 1350 — Await and Return Values
Error identification
The toString() output is more descriptive
Lesson 1153 — Setting the Error Name Property
Error path testing
Testing the failure case at each level means creating separate test scaffolds for errors at level 1, level 2, level 3, etc. That's exponential test case growth.
Lesson 1251 — Testing Callback Hell Code
ES Modules load asynchronously
the browser or runtime can fetch and parse multiple files in parallel before executing any code. This is why ESM needs the type="module" attribute in HTML.
Lesson 1450 — CJS and ESM: Two Module Systems
ES Modules use live bindings
imports stay connected to their source, so changes in the exporting module are reflected in all importing modules.
Lesson 1450 — CJS and ESM: Two Module Systems
event
An event is a trigger or signal that may cause a state change.
Lesson 2426 — State and Transition Vocabulary
event channel
Instead, they communicate through an intermediary called an event channel or event bus.
Lesson 1844 — The Pub/Sub Pattern
Example scenario
An e-commerce site showing product prices in different locales—Intl.NumberFormat is perfect.
Lesson 1653 — When to Use Intl vs Third-Party Libraries
Expensive operations
If each transformation is costly (API calls, heavy computation), lazy evaluation only pays that cost for items you actually consume.
Lesson 2055 — When Lazy Evaluation Wins
Explicit coercion
Explicit coercion is when you deliberately convert types using constructors like Number(), String(), or Boolean().
Lesson 274 — What is Type Coercion?
exports
A shorthand reference to module.exports
Lesson 1447 — The Module Wrapper Function
Expressing intent
the matcher name documents what you're actually testing
Lesson 2681 — Custom Matchers
Expressions
Expressions are not hoisted—the variable exists, but it's undefined until the assignment runs
Lesson 381 — Function Expressions

F

factory function
A factory function is just a regular function that returns a new object every time you call it.
Lesson 668 — What Are Factory Functions?Lesson 1806 — Factory Functions: Return Plain Objects
Factory functions
Factory functions are plain functions that build and return new objects.
Lesson 671 — Factory Functions vs Constructor Functions
false
The internal buffer is full or exceeds the high water mark. This is your signal to stop writing and wait.
Lesson 1557 — Handling Write BackpressureLesson 1577 — The write() Return ValueLesson 2469 — Side Effects and 'sideEffects' Field
file descriptor
A file descriptor is a numeric identifier that the operating system assigns to an open file.
Lesson 1526 — File Descriptors and fs.open()/fs.close()
File Matching
The old system used overrides arrays with files patterns. Flat config makes every configuration object potentially file-specific using top-level files and ignores keys.
Lesson 2573 — Migrating from .eslintrc to Flat Config
File size matters
Sending large images, videos, or files where bandwidth is limited
Lesson 2360 — Base64 Overhead and When to Avoid It
fileName
The file where the error occurred (Mozilla-specific)
Lesson 1148 — Error Object Properties
Financial calculations
Financial calculations are the classic example.
Lesson 126 — When to Use BigInt Instead
First iteration
sum is 0, price is 10 → returns 10
Lesson 457 — Summing Numbers with Reduce
flat config
Starting with ESLint 8.21.0, a new configuration system called flat config was introduced (and became the default in ESLint 9.0).
Lesson 2570 — Introduction to Flat Config (eslint.config.js)
Flexibility over security
Privacy is about organization, not protection
Lesson 1991 — When to Use Private Fields
forEach
forEach is like a tour guide: you visit each stop to do something, but you're not building anything new
Lesson 858 — When to Use forEach vs map
forEach arrays method
forEach arrays method is slightly slower.
Lesson 374 — For vs ForEach vs For...of Performance
Fourth iteration
sum is 40, price is 30 → returns 70
Lesson 457 — Summing Numbers with Reduce
Frequent membership checks
has() is much faster than includes()
Lesson 1066 — Array vs Set: Handling Unique Values
Fulfilled
The food arrives successfully at your door. Order complete!
Lesson 1263 — What is a Promise?Lesson 1264 — Promise States
function
A function is a reusable piece of code you define with the function keyword.
Lesson 81 — Blocks vs Functions
function declaration
A function declaration is the most traditional way to define a named function in JavaScript.
Lesson 379 — Function Declaration Syntax
function declarations
You've already learned that function declarations are fully hoisted — meaning you can call them before they appear in your code.
Lesson 96 — Function Expressions vs DeclarationsLesson 423 — Function Expression Hoisting Behavior
function expression
A function expression is when you create a function and assign it to a variable, just like you'd assign a number or string.
Lesson 381 — Function Expressions
Function inlining
Function inlining is an optimization where the JavaScript engine replaces a function call with the actual body of the function itself.
Lesson 1913 — What Is Function Inlining?
Function name
A descriptive identifier (follows variable naming rules)
Lesson 379 — Function Declaration Syntax
function signatures
While the application syntax looks identical (@decorator), the decorator function signatures are completely different.
Lesson 2102 — Legacy Class and Method Decorators
Functions
Functions are like entire separate buildings — var, let, and const all stay inside their function
Lesson 81 — Blocks vs Functions
functor
A functor is a container that implements a map method, while a monad adds flatMap (or chain) for flattening nested containers.
Lesson 1799 — Functor/Monad Pattern Mismatch in JS

G

Garbage collection
Garbage collection is the automatic process by which JavaScript identifies and reclaims memory that's no longer needed.
Lesson 1860 — What is Garbage Collection?
Garbage collection roots
Garbage collection roots are the starting points the engine uses to determine reachability.
Lesson 1862 — Roots and Reference Chains
generator function
A generator function is different—it's like a road trip with rest stops.
Lesson 1096 — What Are Generator Functions?
getter
A getter is a special type of object property that looks like a regular property when you access it, but actually executes a function behind the scenes.
Lesson 659 — Defining Getters with the 'get' Keyword
Glob patterns
Glob patterns are wildcard expressions that match file paths.
Lesson 2595 — Configuring File Patterns
global object
The global object is a special, always-available object that sits at the top of JavaScript's scope chain.
Lesson 1459 — The Global Object Concept
guard
A guard is a boolean condition that checks whether a transition should proceed.
Lesson 2430 — Guarded Transitions
guard clause
A guard clause is an if statement at the beginning of your code that checks for invalid conditions and exits early using return.
Lesson 315 — Guard Clauses and Early Returns

H

Hard to debug
The variable "works" but pollutes the global scope
Lesson 1465 — Implicit Global Access
Hard to modify
adding steps means more nesting
Lesson 1242 — What is Callback Hell?
Hard to test
isolating individual operations is nearly impossible
Lesson 1242 — What is Callback Hell?
hash
The fragment identifier (e.g., #top)
Lesson 2311 — Accessing and Modifying URL Components
headers
A Headers object containing all response headers. Use methods like get('content-type') to inspect server-provided metadata about caching, content types, or authentication tokens.
Lesson 2256 — The Response ObjectLesson 2267 — The Request Constructor and OptionsLesson 2274 — The Response Object Structure
hex
Represents each byte as two hexadecimal characters
Lesson 1584 — Buffer Encoding
Hidden dependencies
A MINOR update pulls in a transitive dependency with breaking changes
Lesson 2526 — Semver in Practice: Trust and Reality
high-level programming language
A high-level programming language means JavaScript handles the complicated, technical details automatically so you can focus on solving problems.
Lesson 1 — JavaScript: A High-Level Programming Language
higher-order function
A higher-order function is simply a function that does at least one of these two things:
Lesson 435 — The Higher-Order Function ConceptLesson 439 — What Makes a Function Higher-Order
Hoisting
Hoisting is npm's solution: it "lifts" shared dependencies up to the top level of node_modules whenever possible.
Lesson 2505 — Dependency Hoisting and Deduplication
Husky
Husky is a tool that makes Git hooks easy to install, configure, and share across your entire team.
Lesson 2598 — Git Hooks and Husky

I

Immutability
Immutability means keeping data unchanged.
Lesson 689 — Why Object Cloning Matters
implicit binding
This is called implicit binding — you don't have to manually pass the object in; JavaScript does it for you.
Lesson 649 — How 'this' Works in Method Calls
implicit block
This is called an implicit block or braceless syntax.
Lesson 316 — Implicit Blocks vs Explicit Braces
independent operations
Identifying these independent operations is the first step toward writing faster async code.
Lesson 1365 — Identifying Independent Async Operations
Infinite or unknown-length data
Generate values indefinitely or until a condition is met
Lesson 1127 — When to Choose Lazy vs. Eager
Infinity
Infinity represents a value larger than any other number—essentially, mathematical infinity.
Lesson 36 — Special Number Values: NaN, Infinity
Initialization
Initialization is the moment you give a variable its first value.
Lesson 70 — Variable Initialization
Input validation fails
a function receives invalid arguments
Lesson 1140 — The throw Statement
Interpretation
Interpretation means reading and executing code line-by-line, on the fly.
Lesson 14 — Interpretation vs Compilation
invariant
An invariant is something that doesn't change.
Lesson 372 — Minimizing Work Inside the Loop Body
iterable
An iterable is an object that has the ability to be iterated over—it contains a [Symbol.iterator] method that returns an iterator.
Lesson 2010 — Making Your Own Iterable ObjectLesson 2011 — Iterables vs Iterators
iterables
The ones that can are called iterables—they follow a special contract called the Iterator Protocol.
Lesson 360 — Iterables and the Iterator ProtocolLesson 1083 — Iterators vs Array-likes
iterator
An iterator is the object doing the actual work—it has a next() method that returns {value, done} objects one at a time.
Lesson 2011 — Iterables vs Iterators
iterator protocol
The iterator protocol is JavaScript's formal agreement about how objects can be looped over.
Lesson 1073 — What Is the Iterator Protocol?
Iterator Reuse Patterns
The iterable-iterator pattern (where an object can spawn fresh iterators) is more explicit and debuggable when written manually.
Lesson 1095 — When Custom Iterators Beat Generators

J

JavaScript engine
A JavaScript engine is a special program that reads your JavaScript code and executes it.
Lesson 9 — What is a JavaScript Engine?
JavaScript objects
JavaScript objects are live data structures in memory.
Lesson 687 — JSON vs JavaScript Objects
JS heap size
Total memory your JavaScript is using
Lesson 1893 — Performance Monitor for Memory Trends

K

Key type limitations
Object keys are always converted to strings (or symbols). If you try to use a number or object as a key, JavaScript silently stringifies it:
Lesson 1065 — Object vs Map: When Objects Fall Short
kind
A string telling you what is being decorated: "class", "method", "getter", "setter", "field", or "accessor"
Lesson 2070 — The Decorator Function Signature

L

label
A label is a name you attach to a loop, letting you specifically target that loop with break or continue statements—even from inside nested loops.
Lesson 366 — Labeled statements: Targeting specific loops
labeled statement
A labeled statement is simply a statement preceded by an identifier and a colon.
Lesson 330 — What Are Labeled Statements?
lastModified
A timestamp in milliseconds since the Unix epoch, indicating when the file was last changed
Lesson 2367 — The File Interface
Latest
The absolute newest published version, regardless of your version constraints
Lesson 2493 — npm outdated and Version Checking
Lazy loading
Lazy loading means these chunks only download when actually needed—like when a user navigates to a specific page or clicks a button to open a feature.
Lesson 2444 — Code Splitting and Lazy Loading
length
The number of elements in the typed array
Lesson 2325 — Length and ByteLength Properties
Let
Let is a labeled drawer that only opens in the right room.
Lesson 76 — Var vs Let vs Const Summary
lexical scope
Lexical scope means that variable accessibility is determined by the physical structure of your code — by where functions are written in the source code.
Lesson 88 — Scope and Closures PreviewLesson 486 — What is Lexical Scope?
lineno
The line number where it happened
Lesson 2153 — Handling Errors in Workers
lineNumber
The line number where the error occurred (Mozilla-specific)
Lesson 1148 — Error Object Properties
Lint-staged
Lint-staged is a tool that runs linters (like ESLint) and formatters (like Prettier) only on Git-staged files—the ones you're about to commit.
Lesson 2593 — What is Lint-Staged?
Local scope operations
If you create an array within a function and manipulate it before returning, mutation is safe because no external code can access that intermediate state:
Lesson 914 — When to Mutate: Performance Trade-Offs
Locale
A BCP 47 language tag like 'en-US', 'de-DE', or an array of locales.
Lesson 2234 — Intl.Collator Constructor and Options
Logging
Track when properties are read or modified for debugging.
Lesson 2080 — Accessor Decorators (Getters and Setters)
lookbehind
Lookahead and lookbehind are zero-width assertions.
Lesson 1711 — What Are Lookahead and Lookbehind?

M

Maintenance and Stability
Node's test runner is stable but still maturing. Jest is battle-tested but slower to adopt modern features. Vitest is modern but younger with a smaller ecosystem.
Lesson 2661 — Choosing the Right Test Runner
Maintenance nightmares
Tracking down which script owns which global is painful
Lesson 1466 — Global Namespace Pollution
MAJOR
Breaking changes (18 → 20 means incompatible updates)
Lesson 2484 — Installing Node.js and NPMLesson 2518 — What is Semantic Versioning?
Major Framework Ecosystems
Popular libraries like Angular, NestJS, and TypeORM were built entirely on legacy decorators. Migrating millions of lines of code is a massive undertaking, so these ecosystems continue using the old syntax while planning gradual transitions.
Lesson 2105 — When You Might Still See Legacy Decorators
map
A Map is a built-in JavaScript data structure that stores key-value pairs, similar to objects.
Lesson 858 — When to Use forEach vs mapLesson 1031 — What is a Map and Why Use It?
mappings
The magic string! A Base64 VLQ-encoded sequence that maps each position in the minified code to positions in the original sources. Think of it as GPS coordinates connecting every semicolon and variable in the bundle back to its birthplace.
Lesson 2476 — Source Map File Structure
Memoization
Memoization is a specific form where you cache function results based on their arguments.
Lesson 1899 — Caching and Memoization for Repeated Work
method chaining
This pattern is called method chaining or a fluent interface.
Lesson 656 — Method Chaining and Returning 'this'
microtask starvation
This condition is called microtask starvation — tasks are "starved" of execution time because microtasks hog the event loop.
Lesson 1198 — Microtask Starvation
Migration Complexity
The two decorator systems have different signatures and behaviors. Automated migration isn't always possible, requiring careful manual review of each decorator.
Lesson 2105 — When You Might Still See Legacy Decorators
minimist
minimist is a lightweight library that transforms raw command-line arguments into a friendly JavaScript object.
Lesson 1513 — Argument Parsing Libraries: minimist
mixin
A mixin is an object or function that provides reusable methods which can be copied into other objects.
Lesson 1808 — Mixins: Sharing Behavior Without InheritanceLesson 1820 — The Mixin Pattern
Mocha
Mocha is the veteran—flexible, minimal, and unopinionated.
Lesson 2652 — The Test Runner Landscape
module
An object representing the current module
Lesson 1447 — The Module Wrapper Function
Multiple statements
If either branch needs to do more than return a value, if/else is cleaner.
Lesson 233 — Ternary Pitfalls and Readability

N

named export syntax
In ES Modules, named export syntax is the mechanic that lets you explicitly mark which variables, functions, or classes should be available to other modules.
Lesson 1409 — Named Export Syntax
Named exports
Named exports are the gold standard for tree shaking.
Lesson 2447 — Dead Code EliminationLesson 2468 — Export Patterns That Enable Tree Shaking
names
An array of original variable and function names before minification. For example, ["calculateTotal", "userInput"] instead of ["a", "b"].
Lesson 2476 — Source Map File Structure
NaN's unique inequality
NaN is the only JavaScript value that doesn't equal itself (NaN !== NaN). A simple === check will incorrectly report two NaN values as unequal, even though they're conceptually the same special value.
Lesson 2410 — Edge Cases: Null, Undefined, and NaN
Natural reading
The code reads like plain English
Lesson 352 — For...of with Strings
nested if statement
A nested if statement is simply an if statement placed inside another if statement's block.
Lesson 314 — Nested If Statements
nested state
A nested state is a state within another state.
Lesson 2431 — Nested and Hierarchical States
Nitro
JavaScriptCore (also called Nitro) is Apple's JavaScript engine that runs code in Safari and any browser built with WebKit on macOS and iOS.
Lesson 12 — JavaScriptCore: Safari's Engine
No arguments
The callback receives nothing—it can't access resolve values or rejection reasons
Lesson 1282 — The .finally() Method
No context
The error appears isolated, disconnected from the larger operation
Lesson 1250 — Debugging Nested Callbacks
No inherited properties
Maps are clean; they only contain what you put in them
Lesson 1031 — What is a Map and Why Use It?
No text translation needed
Your UI labels are fixed in one language, or you have only a handful of static strings
Lesson 2247 — Identifying Simple i18n Requirements
no-unused-vars
no-unused-vars is the rule identifier you can look up
Lesson 2564 — Interpreting ESLint Error Messages
Non-zero
Non-zero (typically 1) means "something went wrong" (error)
Lesson 1500 — Process.exit() and Exit Codes
none
Fully mutable; you can add, modify, or delete any header. This is the default for headers you create yourself with new Headers().
Lesson 2283 — Headers Immutability and Guards
Nullish values
Nullish values are only null and undefined — values that represent the absence of a value.
Lesson 1948 — Nullish vs Falsy Values
nyc
nyc is the older, battle-tested option (especially with Babel/transpiled code):
Lesson 2717 — Generating Coverage Reports

O

object
The object you're modifying
Lesson 610 — Object.defineProperty
object itself
Even though 0 and "" are falsy primitives, their wrapper objects are truthy because the object itself is what gets evaluated, not its wrapped value.
Lesson 291 — Truthy Objects That Seem Falsy
object literal
An object literal is a way to create an object by writing it directly in your code using curly braces {} and listing its properties as key-value pairs.
Lesson 589 — What is an Object Literal?
Object literals and constructor functions
Object literals and constructor functions are generally the fastest for creating objects.
Lesson 730 — Performance Considerations
Object URL
An Object URL is a special temporary URL (starting with blob:) that points to that in-memory data.
Lesson 2369 — Creating Object URLs
Observable
An Observable is like a stream that can emit multiple values over time, and it gives you fine-grained control over when and how that stream operates.
Lesson 2128 — Observables vs Promises
ok
A boolean shortcut: true if status is in the range 200–299, false otherwise. Perfect for quick success checks without memorizing status codes.
Lesson 2256 — The Response ObjectLesson 2274 — The Response Object Structure
On-demand computation
Expensive operations run only when values are needed, not before.
Lesson 1119 — What Makes a Sequence Lazy?
One-time use
Once iterated, the iterator is exhausted
Lesson 162 — matchAll(): Iterating Over All Matches
Only synchronous code
Only synchronous code is allowed—no async operations, Promises, or callbacks
Lesson 1504 — Process Event: 'exit'
only-if-cached
Only use cached responses, fail if nothing is cached (requires mode: 'same-origin').
Lesson 2273 — Request Cache Control
operators
In RxJS, operators are functions that take an observable and return a new observable with modified behavior.
Lesson 2132 — Operators: Map and Filter
OptionalDependencies
OptionalDependencies are packages that enhance functionality but aren't required.
Lesson 2541 — PeerDependencies and Optional Dependencies
Options
Options is an object with three key properties:
Lesson 2220 — Creating a RelativeTimeFormat Instance
Own properties
Own properties are fastest because they're found on the first lookup.
Lesson 704 — Property Lookup Performance

P

Parallel execution
If tasks are independent and can run simultaneously, use Promise.all instead
Lesson 2037 — When to Prefer For-Await-Of
Parameter decorators
Parameter decorators are even more limited.
Lesson 2103 — Property and Parameter Decorators in Legacy Syntax
Parameters
Parameters are the variable names you define when creating a function.
Lesson 403 — Parameters vs Arguments: The Difference
partial application
This is called partial application—you're applying part of the arguments now, leaving the rest for later.
Lesson 563 — Partial Application with bind()
pathname
The path portion (e.g., /products/shoes)
Lesson 2311 — Accessing and Modifying URL Components
PeerDependencies
PeerDependencies are packages your library expects the host application to provide, not packages you install yourself.
Lesson 2541 — PeerDependencies and Optional Dependencies
Pending
Your order is placed and the restaurant is preparing it. You're waiting.
Lesson 1263 — What is a Promise?Lesson 1264 — Promise States
Performance
Object literals are slightly faster because they don't require a constructor function call. Modern engines optimize both, but literals have the edge.
Lesson 387 — Function Constructor (Rarely Used)Lesson 599 — Object Literals vs. new Object()
Performance benefits
Streams enable pipelining. While one chunk is being read from disk, the previous chunk can be processed or sent over the network. No waiting for everything to complete before starting — operations happen concurrently.
Lesson 1549 — Why Use Streams?
performance budget
A performance budget is a set of numerical limits you decide on before you start optimizing.
Lesson 1932 — Setting Performance Budgets
Performance critical
Avoiding copy overhead is essential
Lesson 2179 — PostMessage vs Shared Memory: When to Use Each
Performance Monitor
The Performance Monitor is a live dashboard in Chrome DevTools that shows real-time metrics while your application runs.
Lesson 1893 — Performance Monitor for Memory Trends
Performance-critical code
Number operations are faster
Lesson 1972 — When to Use BigInt vs Number
Performance-critical loops
The sequential nature may be slower than parallel approaches
Lesson 2037 — When to Prefer For-Await-Of
Piping
Piping is a mechanism that connects a readable stream directly to a writable stream, automatically handling the flow of data between them.
Lesson 1572 — What is Piping?
Plain properties
Plain properties are perfect for simple data storage—when you just need to hold a value without any special behavior.
Lesson 667 — When to Use Getters/Setters vs Plain Properties
Plugins
Plugins are npm packages that bundle additional rules, configurations, and sometimes custom parsers for specialized code scenarios.
Lesson 2567 — What Are ESLint Plugins?
Practical mismatch
JavaScript's strength is pragmatic, imperative-functional hybrids. Forcing pure functional patterns adds complexity without the compile-time guarantees that justify it in other languages. You end up with abstraction overhead and little benefit.
Lesson 1799 — Functor/Monad Pattern Mismatch in JS
Preconditions aren't met
required data is missing or malformed
Lesson 1140 — The throw Statement
predicate function
A predicate function is simply a function that returns true or false based on some test.
Lesson 467 — Every with Predicate FunctionsLesson 470 — Some with Predicate Functions
Predictable Memory
A Float64Array with 1000 elements always uses exactly 8,000 bytes. Regular arrays have unpredictable overhead that varies by JavaScript engine.
Lesson 2330 — Performance Characteristics
Preserving context
You need to lock in this before the function gets called in an unpredictable context
Lesson 557 — Why Manual 'this' Binding Exists
Prettier
Prettier is like an auto-formatter in a word processor—it just makes everything neat and aligned, but it doesn't check if your sentences make sense.
Lesson 2576 — What Prettier Is and Isn't
Profiling
Profiling means measuring where your code actually spends its time, so you know what's worth fixing.
Lesson 378 — Profiling Before Optimizing Loops
Progressive enhancement
Progressive enhancement means building your application so it works without workers but benefits from them when available.
Lesson 2197 — Progressive Enhancement with Workers
Promise
A Promise is a special object in JavaScript that represents the eventual completion (or failure) of an asynchronous operation.
Lesson 1263 — What is a Promise?Lesson 2128 — Observables vs Promises
Promise chaining
Promise chaining is the technique of calling .then() on a promise, which itself returns a new promise, allowing you to attach another .then() to that result.
Lesson 1288 — What Promise Chaining Is
Promisifying
Promisifying means wrapping these callback-based functions in a Promise, transforming them into cleaner, chainable code that works beautifully with async/await.
Lesson 1260 — Promisifying Callback-Based APIs
prop
prop is similar but designed for single objects:
Lesson 1792 — Creating Point-Free Helper Functions
propertyName
The property key (as a string)
Lesson 610 — Object.defineProperty
prototype
In JavaScript, a prototype is a special object that acts as a template or blueprint from which other objects can inherit properties and methods.
Lesson 697 — What is a Prototype?
Pull Model
The subject only sends a notification (or a reference to itself). Observers then query the subject for the specific data they need.
Lesson 2111 — Push vs Pull Models
pure annotation
A pure annotation is a special comment (/#__PURE__/) placed directly before a function call.
Lesson 2470 — Pure Annotations
pure function
A pure function is like a reliable vending machine: you put in the same coins, you always get the same snack, and the machine doesn't randomly redecorate your office while you wait.
Lesson 1741 — What Makes a Function Pure
Push
The full article arrives in your inbox
Lesson 2111 — Push vs Pull Models
Push Model
The subject sends complete data to observers when notifying them. When something changes, the subject packages up all relevant information and delivers it directly to each observer's update method.
Lesson 2111 — Push vs Pull Models

R

Re-exporting
Re-exporting means importing something from one module and immediately exporting it from your current module.
Lesson 1414 — Export Lists and Re-exporting
read-modify-write race
This is called a read-modify-write race.
Lesson 2183 — Race Conditions Without Atomics
Readability
The literal syntax {} is clean, concise, and instantly recognizable. new Object() is verbose and looks like legacy code.
Lesson 387 — Function Constructor (Rarely Used)Lesson 599 — Object Literals vs. new Object()
Readable
Variables are defined where someone naturally looks first
Lesson 99 — Best Practices: Declare Before Use
Recursive custom implementations
Recursive custom implementations are the slowest but most flexible.
Lesson 2402 — Performance Considerations
Regular methods work fine
if .toArray() is clear enough, don't overcomplicate with Symbol.iterator
Lesson 1022 — When to Use Well-Known Symbols
Rejected
The restaurant cancels your order due to an ingredient shortage. Order failed.
Lesson 1263 — What is a Promise?Lesson 1264 — Promise States
Relative time formatting
Relative time formatting means displaying time differences in natural, conversational language relative to now—like "5 minutes ago," "tomorrow," or "in 3 weeks."
Lesson 1654 — Intl.RelativeTimeFormat Overview
request
Headers attached to a Request object. Certain headers (like Host) are forbidden because the browser controls them for security.
Lesson 2283 — Headers Immutability and Guards
require
The function you use to import other modules
Lesson 1447 — The Module Wrapper Function
Result type
This is called a Result type or Either pattern.
Lesson 1167 — Result Types and Either Pattern
Returns
the original value at that index (before any change)
Lesson 2186 — Atomics.compareExchange for Lock-Free Updates
Reusability
Named functions can be called from multiple places
Lesson 1254 — Naming Callbacks for Clarity
Reusing results
Arrays can be iterated multiple times; generators are one-time-use
Lesson 1127 — When to Choose Lazy vs. Eager
reviver parameter
The reviver parameter is an optional second argument to JSON.parse().
Lesson 683 — The Reviver Parameter
roots
The GC starts from special starting points called roots (like global variables, currently executing functions, and their local variables) and traces all references outward.
Lesson 1861 — Reachability: The Core Concept
Rule of thumb
Tasks taking more than 50ms risk causing dropped frames (at 60 FPS, each frame has ~16ms). These are prime candidates for worker offloading.
Lesson 2192 — Measuring Task Duration with Performance APIs

S

Safe copying
Data is cloned by default, preventing shared-state bugs
Lesson 2168 — PostMessage Overview: Sending Data Between Contexts
Safety matters most
No risk of race conditions since data is copied
Lesson 2179 — PostMessage vs Shared Memory: When to Use Each
SameValueZero
Maps use an internal algorithm called SameValueZero for this comparison.
Lesson 1040 — Key Equality and Reference
Scientific notation
Scientific notation is useful for extremely large or small numbers in technical contexts.
Lesson 2205 — Grouping and Notation Options
Scope
Scope is the set of rules that determines where in your code a variable can be accessed.
Lesson 77 — What is Scope?
scope chain lookup
Instead, it follows a systematic search process called scope chain lookup.
Lesson 84 — Scope Chain Lookup
Second iteration
sum is 10, price is 25 → returns 35
Lesson 457 — Summing Numbers with Reduce
Security risks
Global variables are accessible everywhere, including third-party scripts
Lesson 387 — Function Constructor (Rarely Used)Lesson 1465 — Implicit Global Access
Separation of concerns
The algorithm (process and sort) is separate from the policy (how to sort)
Lesson 437 — Functions as Configuration
Set
A Set is a built-in JavaScript collection that stores unique values.
Lesson 1044 — What is a Set?
setter
A setter is a special method that intercepts property assignments.
Lesson 660 — Defining Setters with the 'set' Keyword
setters
Getters and setters are special methods that look like regular properties from the outside, but execute functions behind the scenes.
Lesson 658 — What Are Getters and Setters?
setTimeout
setTimeout is best for general-purpose delays where precise timing isn't critical:
Lesson 1212 — When to Use setTimeout vs Alternatives
Shared mutable state
Shared mutable state is the primary culprit.
Lesson 2670 — Avoiding Test Interdependence
Short
Compact dashboards, where space is limited but clarity matters
Lesson 1658 — Style Options: Long, Short, and NarrowLesson 2225 — Style: long, short, and narrow
short-circuit evaluation
This behavior is called short-circuit evaluation.
Lesson 218 — Short-Circuit Evaluation with ||
short-circuiting
This is called short-circuiting—like a circuit breaker tripping at the first sign of trouble.
Lesson 1328 — Promise.all and Error Short-Circuiting
side effect
In bundling terms, a side effect is code that does something beyond just exporting values—it modifies global state, patches prototypes, imports CSS, or runs code immediately when imported.
Lesson 2120 — Effects and Side EffectsLesson 2469 — Side Effects and 'sideEffects' Field
side effects
Actions (also called side effects) are functions that run:
Lesson 2429 — Adding Side Effects and Actions
signal
A signal is a reactive container that holds a single value and automatically notifies any dependent code when that value changes.
Lesson 2117 — What Are Signals?Lesson 2118 — Signal Creation and Reading
Signed
Signed means it can represent both positive and negative numbers
Lesson 254 — The Binary Number System Refresher
Simplicity matters
Arrays are familiar, easier to debug, and work with existing array methods
Lesson 1127 — When to Choose Lazy vs. Eager
Single async operation
Plain await is simpler for one-off promises
Lesson 2037 — When to Prefer For-Await-Of
Single asynchronous operations
Single asynchronous operations are best handled with Promises:
Lesson 2145 — When Simple Callbacks or Promises Are Better
Single-use iterables
The iterator exhausts after one pass, and subsequent iterations yield nothing
Lesson 2014 — Reusable vs Single-Use Iterators
Size Comparison
Size Comparison means tracking bundle size over time.
Lesson 2473 — Verifying Tree Shaking Results
Source code
Source code is written with modern syntax (const, arrow functions, etc.)
Lesson 2445 — Transpilation for Browser Compatibility
source map
A source map is a special file (usually .map) that acts as a bridge between transformed code and your original source.
Lesson 2475 — What Are Source Maps?
sourceContent
An optional array containing the actual text of your original files. This lets debuggers show your source code even if the original files aren't deployed to production.
Lesson 2476 — Source Map File Structure
sources
An array of original file paths (e.g., ["src/utils.js", "src/main.js"]). These are the files you actually wrote, before bundling.
Lesson 2476 — Source Map File Structure
Speed
Real network calls, database queries, and file operations are slow. Mocked versions return instantly, making your test suite run in seconds instead of minutes.
Lesson 2059 — Iterator Memory Overhead vs Direct Array AccessLesson 2694 — What is Mocking and Why Mock?
spread operator
The spread operator is your best friend here:
Lesson 1758 — Immutable Array Updates: Adding Elements
stack
A string containing the call stack trace (you've seen this before!)
Lesson 1148 — Error Object Properties
stack overflow
JavaScript throws a "Maximum call stack size exceeded" error, commonly known as a stack overflow.
Lesson 1186 — Stack Overflow Errors
Stage 3 Decorators Proposal
The Stage 3 Decorators Proposal represents the current, near-final specification for decorators in JavaScript.
Lesson 2068 — The Stage 3 Decorators Proposal
standard
The "JavaScript Standard Style" with no semicolons
Lesson 2568 — Using Shareable Configs with 'extends'
state
A state represents a distinct condition or mode your system can be in at any given moment.
Lesson 2426 — State and Transition Vocabulary
Statement Coverage
Statement Coverage is similar to line coverage but counts logical statements rather than physical lines.
Lesson 2716 — What Code Coverage Measures
Static imports
Static imports are declarations like import { foo } from './module.js'.
Lesson 2467 — Static vs Dynamic Imports
static initialization block
A static initialization block is a special static {} block inside a class that runs automatically when the class itself is loaded—not when you create instances.
Lesson 796 — Class Static Initialization Blocks
static method
A static method is a function defined on a class that belongs to the class itself, not to individual instances.
Lesson 780 — What Are Static Methods?
static properties
Just as static methods belong to the class rather than instances, static properties are variables stored on the class itself.
Lesson 785 — Static Properties
static scope
Lexical scope (also called static scope) means that a function's access to variables is determined by its physical location in the code when you write it, not where you call it.
Lesson 82 — Lexical Scope
status
The numeric HTTP status code (e.g., 200, 404, 500). This tells you the outcome category: success (2xx), redirection (3xx), client error (4xx), or server error (5xx).
Lesson 2256 — The Response ObjectLesson 2274 — The Response Object Structure
statusText
A human-readable phrase matching the status code (e.g., "OK", "Not Found"). While descriptive, it's less reliable than status since servers can customize it.
Lesson 2274 — The Response Object Structure
strictNullChecks
Treats null and undefined as distinct types that must be handled explicitly. You can't accidentally pass null where only a string is expected.
Lesson 2628 — Understanding Strict Mode in @ts-check
string
A string is JavaScript's way of storing text.
Lesson 37 — String: Sequences of Characters
string coercion
This automatic conversion is called string coercion.
Lesson 275 — String Coercion with the + Operator
string literal
A string literal is simply the way you write text values directly in your code.
Lesson 145 — String Literals: Single and Double Quotes
Style preference
return await makes it explicit that you're waiting for an async operation. Direct return is more concise when you don't need to do anything with the value.
Lesson 1350 — Await and Return Values
Subscribing
Subscribing is what starts the Observable, like pressing "play" on a streaming service.
Lesson 2130 — Subscribing to Observables
symbol
A symbol is a primitive data type in JavaScript that represents a unique, immutable identifier.
Lesson 1001 — What Are Symbols?
Symbols
Symbol properties are completely ignored during cloning. They simply won't appear in the cloned object.
Lesson 57 — Comparing PrimitivesLesson 694 — structuredClone Limitations
Synchronous
Synchronous means that JavaScript executes your code sequentially, one statement at a time, in the order it appears.
Lesson 1170 — What 'Synchronous' Means in JavaScriptLesson 1517 — FS Module Overview: Sync vs Async vs Promises API
Syntax Complexity
Nested generics and complex conditional types become unreadable. A TypeScript interface is elegant; the JSDoc equivalent can span multiple lines of comment syntax.
Lesson 2621 — Editor Support and Limitations

T

tabWidth
Number of spaces per indentation level (default: 2). Controls how far code is indented when nested.
Lesson 2578 — Core Configuration Options
target
The index where you want to paste the copied elements
Lesson 821 — copyWithin(): Copying Elements Within the Same Array
Team Experience
A team familiar with Jest will be productive faster than forcing them to learn something "better." Migration costs are real.
Lesson 2661 — Choosing the Right Test Runner
ternary operator
The ternary operator is JavaScript's only operator that takes three operands.
Lesson 227 — The Ternary Operator Syntax
Test Isolation
You want to test your code, not someone else's API or the reliability of your network connection. If your function processes data from an API, mocking that API ensures you're testing your processing logic, not whether the API is up.
Lesson 2694 — What is Mocking and Why Mock?
test runner
A test runner is a specialized tool that automatically discovers, executes, and reports on your test suites.
Lesson 2651 — What is a Test Runner?
Testing
Testing is difficult due to tangled callback chains
Lesson 1262 — Balancing Pragmatism and Refactoring
Think of it like this
You're handing the test runner a "ticket" (the Promise) and saying, "Don't mark this test complete until you can redeem this ticket." The runner patiently waits for redemption (resolution) or learns the ticket is invalid (rejection).
Lesson 2686 — Returning Promises from Tests
Think of it this way
Generators are like automatic transmission—easy and sufficient for most driving. Custom iterators are manual transmission—more work, but you get precise control when performance or special handling matters.
Lesson 1095 — When Custom Iterators Beat Generators
Third iteration
sum is 35, price is 5 → returns 40
Lesson 457 — Summing Numbers with Reduce
third number
In semantic versioning (like 2.4.7), the third number is the patch version.
Lesson 2521 — PATCH: Bug Fixes and Safe Updates
Third-party code patterns
A library requires a specific structure that triggers warnings (e.g., console statements in a debug wrapper)
Lesson 2607 — When to Disable Rules
throttle
Debounce and throttle are patterns that use closures to track timing state and limit execution frequency.
Lesson 517 — Debounce and Throttle Functions
tilde
The caret opens a wider gate: "Let in anything that promises backward compatibility (minors and patches)." The tilde is more conservative: "Only let in the safest fixes (patches only)."
Lesson 2524 — Caret (^) vs Tilde (~) Ranges
Traditional for loops
Traditional for loops are typically the fastest.
Lesson 374 — For vs ForEach vs For...of Performance
trailing comma
Interestingly, JavaScript permits you to place a comma after the last element as well—this is called a trailing comma (or "dangling comma").
Lesson 808 — Trailing Commas in Array Literals
transform stream
A transform stream is a special type of duplex stream that sits between a readable and writable stream, actively modifying or transforming the data as it passes through.
Lesson 1564 — Transform Streams Explained
transition
A transition is the rule that defines moving from one state to another in response to an event.
Lesson 2426 — State and Transition Vocabulary
transition function
A transition function is the heart of a finite-state machine.
Lesson 2428 — Transition Functions and Event Handling
Tree shaking
Tree shaking is a dead code elimination technique that removes exports you've defined but never actually import or use anywhere in your application.
Lesson 2466 — What is Tree Shaking?
true
The data was successfully written to the internal buffer, and there's still room for more. Keep writing if you want!
Lesson 1557 — Handling Write BackpressureLesson 1577 — The write() Return Value
type
The MIME type (inherited from Blob, but more meaningful for actual files)
Lesson 2367 — The File Interface
type coercion
Type coercion is JavaScript's way of automatically converting a value from one type to another when needed.
Lesson 56 — When == Performs Type CoercionLesson 210 — Comparing Different TypesLesson 274 — What is Type Coercion?

U

Uint8Array
Uint8Array is standard JavaScript available in browsers and all JavaScript environments.
Lesson 1591 — Buffer and TypedArrays
Undeclared
Undeclared means the variable doesn't exist at all—you never created it
Lesson 32 — undefined: The Default Value
undefined
undefined means the variable exists but has no value (yet)
Lesson 32 — undefined: The Default Value
Unicode
Unicode is a universal standard that assigns a unique number (called a "code point") to every character from every writing system—including letters, numbers, symbols, and even emojis.
Lesson 183 — What is Unicode and Why It Matters
User navigation
A user clicks away while data is still loading
Lesson 2300 — Why AbortController Exists

V

Vitest
Vitest is the modern challenger, designed for projects using Vite.
Lesson 2652 — The Test Runner Landscape

W

Wanted
The latest version that satisfies your package.json version range (e.g., if you specified ^1.2.0, it might show 1.5.0 but not 2.0.0)
Lesson 2493 — npm outdated and Version Checking
WeakMap
A WeakMap is a special collection similar to Map, but with strict limitations on what can be used as keys.
Lesson 1056 — WeakMap Basics and Key RestrictionsLesson 1831 — WeakMap for Private Data
WeakSet
A WeakSet is perfect when you need to keep track of which objects you've already seen or processed, but you don't want to prevent those objects from being cleaned up when they're no longer needed elsewhere in your code.
Lesson 1061 — WeakSet Use Case: Tracking Object Sets
Web APIs
The browser runtime is the complete environment where your code runs, and it includes the engine plus a collection of powerful tools called Web APIs.
Lesson 17 — Browser Runtime: DOM and Web APIsLesson 2343 — Why TextEncoder and TextDecoder Exist
well-known symbols
Well, JavaScript reserves a special set of symbols—called well-known symbols—that act like "configuration hooks" for built-in operations.
Lesson 1011 — What Are Well-Known Symbols?
When it matters
For large modules in browsers, dynamic import() prevents blocking the main thread. For small Node.js scripts, require() is simpler if you don't mind blocking.
Lesson 1429 — Dynamic Import vs require()
Window object
The Window object is the global browser environment.
Lesson 1490 — The DOM and Window as Browser-Specific APIs
Worker threads
Worker threads are Node.js's answer to parallel computation.
Lesson 2158 — What Are Worker Threads in Node.js?
Wrapping and rethrowing
Wrapping and rethrowing means catching an error, creating a new error with additional information, and throwing that new error instead.
Lesson 1166 — Wrapping and Rethrowing Errors

X

XState
XState is the most popular JavaScript FSM library.
Lesson 2433 — FSM Libraries: XState Overview