Glossary

Acronyms

API (application programming interface): A documented interface through which one software component requests data or services from another.
CLI (command-line interface): A text-based interface in which a user runs programs by typing commands.
CT (computational thinking): A way of formulating problems and representing solutions so that a person, computer, or combination of both can carry them out and check them.
IDE (integrated development environment): An application that combines a code editor with tools for running, navigating, and debugging programs.
IEM (Industrial Engineering and Management): A field that combines engineering, operations, data, technology, and organizational decision-making.

Terms

absolute path: A path that identifies a location from the file-system root, including a drive when required.
absolute reference: A cell reference whose row and column remain fixed when copied.
abstraction: Keeping the details that matter for the current purpose while leaving out details that do not.
acceptance criterion: A condition used to decide whether a result satisfies a specification.
accumulator: A variable that stores a running result as values are processed.
action: An operation or output that an algorithm may carry out.
action entry: The instruction in a decision rule that says whether an action is performed.
aggregation: A calculation such as Sum, Count, or Average that combines values from several records.
algorithm: A clear sequence of steps that takes allowed input, produces the required result, and stops.
alias: Another name or reference that refers to the same object.
argument: A value or expression supplied to a function when it is called.
arithmetic operator: An operator used for a numeric calculation, such as addition, division, or exponentiation.
assembly language: A low-level symbolic notation whose instructions correspond closely to the machine instructions of a particular processor family.
assertion: A statement that checks a condition the program requires and raises an error when the condition does not hold, written in Python with assert.
assignment: Binding a name to a value in a program.
assignment operator: The equals sign (=) used in Python to bind a name to a value.
assignment statement: A statement that binds a name to a value, usually with the assignment operator.
assumption: A condition treated as true when formulating or evaluating a problem, even though it may require verification.
augmented assignment: An assignment that updates a name using its current value, such as count += 1.
Average: A PivotTable aggregation that averages numeric values.
Big-O notation: Notation for an upper bound on how work or storage grows with input size, ignoring constant factors. It does not specify elapsed time on a particular computer.
bit: The smallest unit of binary information, with a value of either 0 or 1.
black box: A component understood through its inputs and outputs without requiring knowledge of its internal implementation.
Boolean value: One of the 2 logical values True and False.
boundary: The line that states what a computational task or representation includes and excludes.
boundary case: A test case at or immediately beside a threshold where behavior may change.
boundary-value analysis: Selecting tests at and immediately beside an ordered threshold where required behavior changes.
branch: A name that points to a Git commit and moves forward when a new commit is made on that branch.
breakpoint: A marker on a line that tells the debugger to pause the program there so its state can be inspected.
built-in function: A function supplied by Python and available without importing another module.
byte: A unit of digital storage containing 8 bits.
bytecode: An intermediate instruction representation designed for execution by a virtual machine rather than directly by a hardware processor.
cache: Temporary storage that keeps reusable data so later access can be faster.
call stack: The ordered stack of active function calls that Python uses to remember where each call must return.
case-sensitive: Treating uppercase and lowercase letters as different, so name and Name are different identifiers.
cell: An addressed location in a worksheet, such as G2.
chained comparison: Two or more comparisons written together, such as 10 <= age <= 17.
class: A definition used to create objects that share specified data and behavior.
code: Text or other notation written in a programming language as part of a program.
code cell: A notebook section containing code that can be run.
code editor: A text editor designed for writing source code.
code point: The number that identifies one character in a character-encoding standard such as Unicode.
code review: Reading someone else’s code against the specification to find defects, unclear passages, and missing checks before the code is relied on.
coding: Writing instructions or other text in a programming language; one part of programming.
collection: One value or structure that groups multiple items so they can be handled together.
Columns: The PivotTable area that spreads categories horizontally.
comment: Text in source code that the interpreter ignores, written for the people who read the code, marked in Python with #.
commit: A saved snapshot of tracked project files, with an author, a message, and links to its parent commits when present.
comparison operator: An operator that compares values, such as ==, <, or >=.
compile time: The phase in which source code is translated or analyzed before the relevant instructions execute.
compiler: A program that translates source code into another representation before execution, such as bytecode or machine code.
computational task: A task that clearly states the information it receives, the required result, and the rules, so that a person or computer can carry it out consistently.
computer memory: Electronic storage that a running program uses to hold instructions, values, and other working information.
condition: A question or logical statement whose result controls which instruction or action applies.
condition entry: The result required for one condition in a decision rule, such as Yes, No, or Any.
conditional: A statement that chooses which block of code runs by evaluating a condition, written in Python with if, elif, and else.
conditional aggregation: Applying a measure to records selected by stated criteria.
conditional expression: An expression that produces one of 2 values according to a condition, written in Python as a if condition else b and also called the ternary operator.
Conditional formatting: Formatting that draws attention to values that meet a rule.
confirmation test: A failed test repeated after a correction to check that the specific defect has been addressed.
console: A text-based input and output area through which a user interacts with a running program.
constant: A named value that a program is expected to leave unchanged.
constraint: A condition that a permitted input, state, action, or result must satisfy.
control flow: The order in which an algorithm or program executes operations and follows decisions or repetitions.
control total: An independently calculated value used to check a reported result.
Count: A PivotTable aggregation that counts nonempty entries in the selected field.
CPython: The standard Python implementation, which compiles Python source code to bytecode and executes that bytecode.
CSV: A text file containing a flat table, with fields separated by a delimiter such as a comma.
dashboard: One worksheet that brings together the measures and comparisons needed for a stated analytical purpose.
data: Recorded facts, measurements, observations, or symbols that can be organized and processed.
data pipeline: A repeatable sequence that imports, cleans, combines, checks, and reports data.
data structure: A way of organizing data so a program can store, access, and update it systematically.
data type: A classification of values according to the operations they support and how they behave.
Data Validation: A command that can restrict manually entered data to a list or numeric range.
debug console: A prompt provided by the debugger for evaluating expressions in the paused program’s current state.
debugger: A tool that can pause a program, execute it step by step, and inspect its state to help locate defects.
decision rule: One complete IF-THEN case in a decision table: if its condition entries match, the algorithm produces its stated result.
decision table: A table that relates combinations of conditions to the actions or outputs required by a rule system.
decision threshold: An ordered value at which a specification requires a decision or output to change.
decomposition: Dividing a larger problem or procedure into smaller parts with clear responsibilities.
default argument: A parameter value that Python uses when the caller omits the corresponding argument.
default dictionary: A Python defaultdict that uses a supplied factory to create and insert a value when a missing key is accessed with square brackets.
defect: An error that makes an algorithm or program violate its specification for at least one permitted input.
definite iteration: Repetition controlled by a known count or a bounded collection of items.
delimiter: A character, such as a comma or tab, that separates fields in a text file.
dependency: Software that a program needs to run, such as an installed package.
deserialization: Reconstructing a Python object from its stored or transmitted representation.
dictionary: A mutable Python collection that associates unique keys with values.
dictionary comprehension: An expression that creates a dictionary by producing key-value pairs from an iterable, optionally selecting elements with a condition.
dictionary key: A unique, hashable object used to identify an associated value in a Python dictionary.
dictionary unpacking: Using ** before a mapping in a dictionary display to insert its key-value pairs into the new dictionary. Later values replace earlier values for the same key.
directory: A named container in a file system that can hold files and other directories; it is also called a folder.
disassembly: A human-readable listing of low-level instructions produced from bytecode or machine code by a tool.
docstring: A string literal used as the first statement in a Python module, function, class, or method to document it.
duplicate key: Repeated values in a field that is expected to identify each reference record uniquely.
dynamic typing: A typing approach in which values carry type information and many type checks occur while the program runs.
empirical distribution: The observed frequency of each distinct value in a dataset, expressed as counts or probabilities.
empty string: A string that contains no characters, written as "" or ''.
environment variable: A named setting maintained by the operating system and made available to programs.
escape sequence: A backslash followed by characters that represent another character, such as \n for a newline.
exact-match lookup: A lookup that retrieves a field using an exactly matching shared key.
Excel Table: A named Excel object with headers, filters, and calculated columns whose references can expand when records are added.
exception: An object Python raises when it cannot continue normally, which stops the current operation unless the program handles it.
exception handling: Code that catches an exception and decides what the program does next, written in Python with try and except.
executable: Able to be run by suitable software and computer hardware.
expected result: The outcome required by the specification for a test case, stated before the algorithm is evaluated.
expression: Code that a programming language evaluates to produce a value.
extension: An installed component that adds a feature to an application such as VS Code.
f-string: A Python string prefixed with f that can evaluate expressions placed inside braces.
falsy: Describes a value that Python treats as False when it is used as a condition, such as 0, an empty string, an empty collection, or None.
feasible case: A raw combination permitted by the constraints of the scenario.
field: One named item in a record, usually shown as a column in a flat table.
field button: A dropdown shown on a PivotChart that filters or arranges one of its PivotTable fields.
file: A named collection of data stored so a program can read or change it.
file extension: The suffix at the end of a filename that indicates its format or intended use, such as .py or .ipynb.
file path: A sequence of directory names and an optional filename that identifies a location in a file system.
Filters: The PivotTable area that restricts the records included in the summary.
flat: Data in which every record uses the same columns.
floating-point value: A numeric value represented with Python’s float type, usually as a binary approximation.
floor division: Division whose quotient is rounded down toward negative infinity; Python writes it with //.
flowchart: A diagram that uses standard shapes and arrows to show operations, decisions, inputs, outputs, and control flow.
formal language: A system of symbols and precisely stated rules for forming valid expressions.
formula: An Excel calculation that implements a rule.
formula bar: The part of Excel that shows the selected cell’s formula or stored value.
formula dependent: A cell whose formula uses another cell.
formula precedent: A cell used by a formula.
formulation: Stating the result a task must produce, the information it can use, and the boundaries, assumptions, and constraints that apply.
framework: Reusable software that provides a structure for building an application and rules for how its components work together.
frequency: The number of times a value occurs in a dataset.
frozen set: An immutable Python set, created with frozenset(), that can be used as a dictionary key or as an element of another set.
full replacement: Source files containing the current records, including retained records, additions, and corrections, that replace the previous snapshot.
function: A named operation that can receive values, perform instructions, and produce a result or effect.
function body: The indented block of statements that runs when a Python function is called.
function call: A request to run a function, written with the function name followed by parentheses containing any arguments.
function contract: A statement of what a function receives, what it promises to return, and how it behaves at boundaries or with invalid input.
function signature: The part of a function definition that identifies the function and states its parameters and related calling information.
function stub: A function with a name and a temporary body that will be implemented later. A stub may raise NotImplementedError to report that its implementation is missing.
generalization: Expressing an idea or approach so that it can be reused in other relevant cases.
global variable: A variable defined outside functions in a module’s global scope.
grand total: A PivotTable result that summarizes all records included after its filters are applied.
hash value: An integer used to locate an object in a hash-based collection. Equal hashable objects have equal hash values, but different objects can share a hash value.
hashable: Able to be used as a dictionary key or set element. A hashable object has a hash value that stays unchanged during its lifetime and supports equality comparisons; equal objects have equal hash values.
header: The first row of a flat table when that row contains the field names.
high-level language: A programming language that provides abstractions for many processor, memory, and hardware details.
home directory: A user’s personal directory provided by the operating system.
human judgment: A decision that depends on human values, experience, or context that the stated data and rules do not fully capture.
identifier: A valid name used to identify a variable, function, class, or another program element.
immutable: Unable to be changed after creation; an apparent change instead produces or refers to another value.
in place: Changing the original collection rather than returning a separate changed copy.
incremental delivery: A delivery containing only changes or new records, with an explicit rule for applying them.
indefinite iteration: Repetition that continues while or until a condition has a specified result.
indentation: Spaces at the start of a line that show which statements belong to the same code block in Python.
index: A position number used to access an item in a sequence. In Python, indices start at 0.
indexing: Accessing one item in a sequence by its position.
inline comment: A comment placed after a statement on the same line, explaining that statement.
input: Information supplied to a task, algorithm, or program.
input domain: The complete set of input values or situations permitted by a problem specification.
input partition: A non-overlapping group of inputs expected to receive the same kind of treatment from an algorithm.
instruction-set architecture: The documented machine instructions, registers, data formats, and related rules exposed by a processor design.
integer: A whole-number value represented by Python’s int type.
interactive interpreter: A running language implementation that reads and executes one entered statement at a time.
intermediate representation: A form produced between source code and final execution, used by a compiler, interpreter, or virtual machine.
interpreter: A program that manages the execution of instructions represented as source code or an intermediate form.
invariant: A condition that should remain true while an algorithm progresses through repeated operations.
iteration: A control-flow pattern in which operations repeat under an explicit continuation or stopping rule.
JSON: A data format whose records can contain nested lists or objects.
just-in-time compilation: Translation of intermediate instructions into machine code while a program is running.
kernel: The running process that executes code cells in a notebook.
key-value pair: A key together with the value associated with it in a dictionary.
keyword: A word reserved by a programming language for a special purpose and unavailable as an ordinary variable name.
keyword argument: An argument supplied with its parameter name, such as distance_km=100.
language implementation: Software that prepares and executes programs written in a programming language.
launcher: A program that selects and starts another installed program.
left outer join: A join that retains every record from the left table, including records with no match on the right.
library: Reusable code that provides related functions, classes, or other components for programs to use.
limited-entry decision table: A decision table whose conditions use a small fixed set of entries, such as Yes, No, and Any.
linear search: Searching a sequence by checking its items one at a time until a match is found or the sequence ends.
list: An ordered, mutable Python collection written with square brackets, such as [1, 2, 3].
listing: A numbered publication element that presents code or pseudocode.
literal: A fixed value written directly in source code, such as 24, True, or "Hello".
local variable: A variable created inside a function and available in that function’s local scope.
logging: Recording messages about what a program does while it runs, so its behavior can be examined afterward.
logic error: A defect that lets a program run without an error message while producing a result the specification does not allow.
logical operator: An operator such as and, or, or not that combines or negates logical expressions.
loop: A section of an algorithm whose instructions repeat.
loop iteration: One execution of the body of a loop.
loop-control state: The state value used by a repetition condition to decide whether another iteration occurs.
low-level language: A programming language or notation that exposes processor instructions, memory, or other hardware details more directly.
machine code: Binary instructions in a form that a computer processor can execute directly.
machine language: The binary instructions that a particular processor can execute directly; those instructions may operate on encoded data.
machine learning: An approach in which a program derives its rules from examples in data instead of following rules a person wrote by hand.
maintenance release: An update within a software version series that contains compatible corrections and improvements.
Markdown: A plain-text notation for headings, lists, links, and other document structure.
measure: A reported quantity such as a count, total, or average, stated with its unit and the records it includes.
membership operator: An operator such as in that checks whether a value occurs in a collection.
merge: An operation that combines changes from another branch or commit into the current branch.
method: A function accessed through a value or object, such as name.upper().
mixed reference: A cell reference that fixes either the row or the column while allowing the other to change when copied.
modular programming: Organizing a program as smaller components with distinct responsibilities that can be understood and reused separately.
modularity: Organizing an algorithm or program into clearly bounded parts with focused responsibilities and explicit connections.
module: A separately organized component that groups related responsibilities or reusable procedures.
modulo: The remainder operation associated with floor division; Python writes it with %.
mutable: Able to be changed after creation without replacing the object with a new one.
mutation: A change to the contents of an existing mutable object.
naming convention: A shared rule for constructing names consistently so their purpose and role are easier to recognize.
nested list: A list that contains other lists.
nested loop: A loop inside another loop.
None: Python’s special value for representing the absence of a value.
notebook: A document that stores runnable code cells, text cells, and their output.
object: A value represented and managed by a programming-language runtime; in Python, names refer to objects.
objective: A measurable result to improve, such as reducing delay or cost. Not every computational task has an objective.
observed result: The outcome produced when an algorithm is followed or executed for a test case.
operand: A value used by an operator in an expression.
operating system: The main software that manages a computer and runs applications, such as Windows, macOS, or Linux.
operator: A symbol or word that applies an operation to one or more values.
ordered dictionary: A Python OrderedDict that preserves insertion order and provides operations for changing that order. Regular Python dictionaries also preserve insertion order.
output: Information or a result produced by a task, algorithm, or program.
overflow: A condition in which a numeric result is outside the largest magnitude supported by its representation.
package: An installable unit of reusable software. The term import package separately refers to a structure that organizes Python modules.
package manager: A tool that installs, updates, and removes software packages and their dependencies.
parameter: A labeled input value used by several formulas.
parameter: A name in a function definition that receives the value of a corresponding argument when the function is called.
parent directory: The directory that immediately contains a file or another directory.
pass: One complete run of the outer loop in a sorting algorithm.
pass statement: A Python statement that performs no action and can temporarily fill a required statement block.
PATH: An environment variable listing directories that the operating system searches for executable programs.
pattern recognition: Noticing a repeated structure or a useful similarity among cases or information.
PivotChart: A chart linked to a PivotTable that follows its grouping, filters, and refreshes.
PivotTable: An Excel summary that groups records and calculates a result for each group.
PivotTable cache: A saved copy of source values that a PivotTable uses until the PivotTable refreshes.
population: The complete set of records included in a reported measure.
Power Query: The Excel tool that records import, cleaning, and combination operations as named steps.
precedence: The rules that determine which operators Python applies first in an expression.
precondition: A condition that must be true before an algorithm or procedure is used.
probability: A number from 0 to 1 that represents how likely an outcome is.
procedure: A named or clearly bounded group of operations with one responsibility and explicit inputs and outputs.
processed data: Derived data exported after processing.
processor: The hardware component that executes machine-code instructions.
product rule: A counting method that multiplies the number of available choices at each step when a complete case contains one choice from every step.
program: A set of computer instructions and related information that a computer can run.
programming: Creating a program that a computer can run.
programming construct: A reusable control structure, such as sequence, selection, or iteration, used to organize program behavior.
programming language: A language with precise words, symbols, and rules for writing instructions that a computer can run.
progress measure: A decreasing count or finite bound used to explain why repetition cannot continue forever.
project folder: The folder opened in an editor to hold the files for one programming project.
pseudo-random number: A value produced by a deterministic algorithm that behaves like a random draw.
pseudocode: A structured, language-independent notation for expressing the logic of an algorithm.
Python Install Manager: The official Windows application for installing and selecting Python runtimes.
Pythonic: Consistent with Python’s established idioms and emphasis on readable, direct code.
query: A recorded sequence of steps for importing and transforming data in Power Query.
randomization: Generating random numbers or sequences to represent variation or uncertainty.
range: A group of worksheet cells, such as G2:G2101.
raw combination: One possible selection of one permitted value for every condition, before constraints rule out any selections.
raw data: Received source files preserved unchanged.
reconciliation: Comparing a reported result with an independently calculated value or control total.
record: The fields that describe one item, event, person, or observation in a dataset.
refactoring: Restructuring an algorithm or program without changing its intended external behavior so that it is easier to understand or modify.
reference: Information that allows a program to locate and access an object stored in memory.
refresh: Repeating the recorded processing steps on the current source data.
regression test: A previously passed test repeated after a change to check that behavior which should remain correct has not been damaged.
relative path: A path interpreted from another directory, usually the current working directory.
relative reference: A cell reference whose row and column are relative to the formula’s position.
replication: One complete trial of a simulation using its own sequence of random inputs.
repository: A Git data store containing a project’s saved commits, branch references, and other version-control metadata.
representation: A deliberately chosen way to describe relevant parts of a situation, problem, or process.
retest: Repeating a failed test and related tests after a change to check the resulting behavior.
return statement: A statement that ends a function call and optionally supplies a value to the caller.
return value: The value supplied to the caller when a function finishes.
root directory: The top-level directory of a file system or project. On Unix-like systems, / is the file system root. A project root is the folder containing that project’s files and subdirectories.
rounding error: A small difference caused when a computer represents or calculates with an approximation of a number.
row meaning: What one record in a table represents; also called its grain.
Rows: The PivotTable area that lists categories vertically and controls their nesting.
run time: The phase in which a program executes, processes inputs, changes state, and produces outputs.
runtime error: An error raised while a program runs, such as dividing by zero or reading a name that does not exist.
sampling with replacement: Drawing an item while leaving it available for later draws.
schema: A definition of the required fields, types, permitted values, units, and missing-value rules for records.
scientific notation: A way to write a number as a coefficient multiplied by a power of 10, such as 1.23e-4.
scope: The region of a program in which a particular name can be accessed.
script: A saved source-code file that can be run as a program.
seed: A value that sets the starting state of a pseudo-random number generator so its sequence can be reproduced.
selection: A control-flow pattern in which a condition determines which operation occurs next.
semi-structured: Data in which a record can contain another object or a list.
sequence: A control-flow pattern in which operations occur in a defined order.
serialization: Converting a Python object into a representation that can be stored or transmitted.
set: A Python collection that stores unique elements without a fixed positional order.
short-circuit evaluation: The rule that stops evaluating a logical expression once the result is settled, so and skips the right side after a false left side and or skips it after a true one.
simulation: Studying a system by repeatedly running a simplified model of its behavior under different conditions.
slicer: A control for filtering a chart interactively.
slicing: Creating a subsequence by specifying a start, end, and optional step.
snake case: A naming style that joins lowercase words with underscores, as in student_count.
solver: Software that searches for a solution to a mathematical model, often while satisfying constraints or optimizing an objective.
source code: The human-readable text of a program before or during its translation and execution by programming-language tools.
specification: An inspectable agreement describing permitted inputs, required outputs, rules, constraints, assumptions, invalid cases, and acceptance criteria.
stack frame: The information for one active function call, including its parameters, local variables, and return location.
staging area: The snapshot of tracked files prepared for the next Git commit. Staging a change updates this snapshot; later working-file edits must be staged separately.
standard library: The modules and packages supplied with a Python installation.
state: The information that describes a system or procedure at a particular moment and may change as operations occur.
static typing: A typing approach in which many type checks occur before the program runs.
step into: A debugger command that pauses on the first line inside the function called by the current line.
step out: A debugger command that finishes the current function and pauses at the line that called it.
step over: A debugger command that runs the current line, including any function it calls, and pauses at the next line.
string: Text represented as a sequence of characters by Python’s str type.
string concatenation: Combining 2 or more strings to create one string.
string interpolation: Inserting the values of variables or expressions into specified positions in a string.
strong typing: A loosely standardized description of a language that restricts implicit operations between incompatible data types.
structured programming: An approach to organizing programs with clear control-flow structures such as sequence, selection, and iteration.
structured reference: A reference to a named Excel Table’s column or to a field in its current row.
subroutine: A named, reusable group of instructions that another part of an algorithm or program can call.
subtotal: A PivotTable result that summarizes one group within a larger arrangement.
Sum: A PivotTable aggregation that adds values.
syntax: The rules that determine how symbols and statements must be arranged in a programming language.
syntax error: An error reported when source code does not follow the language’s structural rules.
terminal: A text-based interface for running programs by typing commands.
termination: The property that an algorithm eventually reaches a stopping point for every permitted input.
test case: A documented check containing its purpose, starting conditions, input, procedure, and expected result.
test plan: A collection of planned test cases whose purposes, inputs, and expected results are recorded before execution.
text cell: A notebook section containing formatted explanatory text.
text encoding: A rule for representing text characters as bytes, such as UTF-8.
trace: A step-by-step record of one execution of an algorithm for a chosen input.
Transactional data: Records of sales and stock changes.
truth table: A table showing the result of a logical expression for every possible combination of Boolean inputs.
truthy: Describes a value that Python treats as True when it is used as a condition, such as a non-empty string or a number other than zero.
TSV: A flat table stored as text with tab-separated fields.
tuple: An ordered, immutable Python collection, commonly written with parentheses, such as (1, 2, 3).
tuple unpacking: Assigning items from a tuple or another sequence to several names in one statement.
type checking: Checking whether values and operations conform to expected data types.
type conversion: Creating a value of one data type from a value of another data type.
type hint: An annotation that states an expected data type without making Python enforce that type at run time.
underflow: A condition in which a nonzero numeric result is too close to zero for its representation to retain normally.
Unicode: A standard that assigns numbers to characters used by writing systems, symbols, and emoji.
unique-hit policy: A decision-table rule stating that no more than one rule may match a given evaluation.
user-defined function: A function written by a programmer rather than supplied by Python or an imported library.
ValueError: A Python error raised when an operation receives a value of the correct general kind but with unsuitable content.
Values: The PivotTable area that contains measures and their aggregations.
variable: A name used to refer to a value that a program can access.
variable lifetime: The period during program execution in which a variable or its binding exists.
variable shadowing: A situation in which a name in a local scope hides the same name from an outer scope.
verdict: The pass-or-fail result obtained by comparing a test case’s observed result with its expected result.
version control: A system that records changes to files so versions can be compared, shared, and recovered.
virtual environment: A local Python environment created from an installed Python version, with its own installed packages.
virtual machine: A computer defined in software that executes an intermediate instruction set such as bytecode.
watch expression: An expression the debugger evaluates each time the program pauses, so its value can be followed while the program runs.
weak typing: A loosely standardized description of a language that performs more automatic conversions between data types.
workbook: An Excel file.
working directory: The directory a running program uses as the starting point for relative paths.
working tree: The project files available to inspect and edit for a checked-out Git version.
worksheet: One tab within an Excel workbook.
worktree: A Git working tree with its associated checkout metadata. Linked worktrees have separate working files and staging areas while sharing the repository history.