# Glossary

September 2018: This material is under very active development, and should all be considered the "brainstorming" phase of a rational lesson design process. We would appreciate your help: please email us, file an issue in our GitHub repository, or submit a pull request. (We would particularly appreciate descriptions of common errors and how to fix them.) Everyone whose work is incorporated will be acknowledged; please note that all contributors are required to abide by our Code of Conduct.

aggregation function: a function that combines many values into one, such as sum or max.

anonymous function: a function that is defined without giving it a name, such as a callback defined where it is used. Anonymous functions are sometimes called lambda functions because the Greek letter lambda is used for them in mathematics.

argument: see parameter.

array: a collection of values stored in a particular ordered and indexed numerically. Arrays are written as comma-separated values in square brackets, such as ['a', 'b', 'c']. The term list is often used synonymously.

ASCII: a widely-used set of numeric codes for representing characters from the Latin alphabet and common puncutation symbols, now superseded by Unicode.

assertion: a statement that something is true at a certain point in a program. Assertions are often used to define tests, but are also used in production code to check that software is behaving as it should.

attribute: a named property attached to an HTML element.

backward-compatible: able to work consistently with older systems.

callback function: a function A that is passed to another function B for B to call at a later time. Callback functions are used to implement delayed actions, such as what to do when data arrives in response to a network request.

Cascading Style Sheets (CSS): a way to describe how HTML should be rendered.

catch: to take responsibility for handling an exception. Catch is the counterpart of throw.

child class: a new class that extends an existing class (called the parent class).

child node: a node in a tree that is below some other node (which is call the child node’s parent).

class: a programming structure that defines the properties and behavior of a family of related objects. Classes can inherit from other classes to specify or change behavior incrementally.

client: a program such as a browser that sends requests to a server and does something with the response. It is sometimes helpful to think of clients as sorcerors petitioning ancient gods for favors. Sometimes.

client-side page generation: to create an HTML page within a client using data provided by a server. See also server-side page generation.

closure: a set of variables defined in the same scope whose existence has been preserved after that scope has ended. Closures are one of the trickiest ideas in programming.

constant: a variable whose value cannot be changed. Note that the value itself might be changed: for example, after the statement const v = ['a', 'b'], the name v will always refer to the same array, but the array’s contents can be changed.

destructuring: a form of assignment that unpacks a data structure in one step, such as [a, b] = [1, 2] or {left, right} = {left: 1, right: 2}.

document: an entire HTML page.

Document Object Model (DOM): a standard way to represent HTML in memory. The elements and attributes of the page, along with its text, are stored as nodes organized in a tree.

dotted notation: a common way to refer to the parts of structures in programming languages. whole.part means “the thing called part belonging to whole”.

element: FIXME (HTML)

event handler: a callback function that does something in response to a particular interaction with a browser, such as a key being pressed or a link being clicked.

event object: an object that the system passes to an event handler that contains information about the event, such as which key was pressed.

exception: an object that stores information about an error or other unusual event in a program. One part of a program will create and throw an exception to signal that something unexpected has happened; another part will catch it.

extend: to create a new class from an existing class. We say that the new class inherits from the old one.

falsy: a horrible neologism meaning “equivalent to false”. See also the equally horrible truthy.

fat arrow function: a JavaScript function defined using the syntax (...parameters...) => {...body...}. Fat arrow functions treat the special value this in a less inconsistent way than their older equivalents.

field: a named part of a record in a relational database. Fields are typically shown as columns in a table.

functional programming: a style of programming in which data is transformed through successive application of functions, rather than by using control structures such as loops. Functional programming in JavaScript relies heavily on callbacks and higher-order functions.

global variable: a variable defined outside any particular function, which is therefore visible to all functions. See also local variable.

heterogeneous: having mixed type. For example, an array is said to be heterogeneous if it contains a mix of numbers, character strings, and values of other types. See also homogeneous.

higher-order function: a function that operates on other functions. For example, the higher-order function forEach executes a given function once on each value in an array. Higher-order functions are heavily used in functional programming.

homogeneous: having a single type. For example, an array is said to be homogeneous if it contains only numbers or only character strings, but not a mix of the two.

HTTP: the HyperText Transfer Protocol used to exchange information between browsers and websites, and more generally between other clients and servers. HTTP is a stateless protocol in which communication consists of requests and responses.

HTTP request: a precisely-formatted block of text sent from a client (such as a browser) to a server that specifies what resource is being requested, what data formats the client will accept, and so on.

HTTP response: a precisely-formatted block of text sent from a server back to a client in reply to a request.

HTTP status code: a numerical code that indicates what happened when an HTTP request was processed, such as 200 (OK), 404 (not found), or 500 (internal server error).

in-memory database: a database that is stored in memory rather than in permanent storage. In-memory databases are often used for testing.

inherit: to acquire properties and methods from a parent class. See also extend.

JSON: a way to represent data by combining basic values like numbers and character strings in arrays and name/value structures. The acronym stands for “JavaScript Object Notation”; unlike better-defined standards like XML, it is unencumbered by a syntax for comments or ways to define schemas.

library: see module.

list: see array.

local variable: a variable defined inside a function which is only visible within that function. See also global variable and closure.

logging: FIXME

member variable: see property.

memory diagram: a picture showing the variables a program contains and the data they refer to.

method: a function attached to an object, typically called using dotted notation. In JavaScript and many other languages, a special variable called this is provided to methods to refer to the particular object for which the method is being called.

module: a set of variables, functions, and/or classes grouped together for easier management (typically but not always in a single file). Modules are sometimes also called libraries.

node: an in-memory representation of an element in an HTML page. See also DOM.

NoSQL database: any database that doesn’t use the relational model. The awkward name comes from the fact that such databases don’t use SQL as a query language.

object: a clump of variables and/or methods grouped together in a program. In most languages, objects can only be created as instances of classes, but JavaScript calls anything created using {...} an object. Do not seek to walk in the footsteps of the sages; seek rather what they sought.

observer-observable: a widely-used programming pattern in which some objects are notified and take action when other objects change state or take action.

override: to replace a definition of a [method] in a parent-class with a new definition in a child class.

query parameter: a placeholder in an SQL query that must be filled in with an actual value in order for the query to run.

package manager: a program that does its best to keep track of the bits and bobs of software installed on a computer. The most widely used package manager for JavaScript is called NPM; it does its best, but really, without proper discipline on the part of programmers, it’s like Boromir trying hold back the orcs or a kindergarten teacher trying to keep everyone’s shirt clean during finger-painting.

parameter: a variable whose value is passed into a function when the function is called. Some writers distinguish parameters (the variables) from arguments (the values passed in), but others use the terms in the opposite sense. It’s all very confusing.

parent class: an existing class that has been extended to create a new class. (The new class is called the child class.)

parent node: the node in a tree that is above some other node. Every node has a parent except the [root]{#root-node}.

polymorphism: literally, “having many forms”. The term refers to the way in which objects whose methods have the same names and parameters can be used interchangeably.

production code: software that is delivered to an end user. The term is used to distinguish such code from test code, deployment infrastructure, and everything else that programmers write along the way.

promise: a way to handle delayed computations in JavaScript. Promises were supposed to make programmers’ lives simpler.

prototype: an idiosyncratic mechanism used in the original definition of JavaScript for sharing properties between objects that we unfortunately still have to cope with.

property: a variable associated with an object. The term is used to distinguish an object’s passive data from its executable methods. Properties are sometimes called member variables.

raise: see throw.

read-evaluate-print loop (REPL): an interactive program that reads a command typed in by a user, executes it, prints the result, and then waits patiently for the next command. REPLs are often used to explore new ideas or for debugging.

record: a set of related values. In a relational database, a record is typically shown as a single row in a table. See also field.

regular expression: a pattern for matching text.

relational database: a database that organizes information into tables, each of which has a fixed set of named fields (shown as columns) and a variable number of records (shown as rows). See also SQL.

responsive design: an approach to building web pages and other applications that resizes and reorganizes things smoothly for different sizes of screens.

RGB: a way to represent colors as triples of red, green, and blue intensities, each of which ranges from 0 to 255. RGB is often augmented in modern systems to create RGBA, where the fourth component is the pixel’s transparency.

root: the only node in a tree that doesn’t have a parent.

Scalable Vector Graphics: a standard way to represent line-based graphics using XML-style notation. SVG images resize much more cleanly than pixel-based images, and most browsers can draw them directly.

schema: a specification of the “shape” of data, such as the fields making up a database table or the ways in which structures can be nested in JSON.

scope: the portion of a program within which a definition can be seen and used. See global-variable, local-variable, and (if you are brave) closure.

selector: a way to identify elements within an HTML document. The selector h2#contents, for example, means “the h2 element with the ID contents”.

server: a program that waits for requests from clients and sends them data in response. It is sometimes helpful to think of servers as harassed parents trying to babysit a room full of unruly children.

server-side page generation: to create an HTML page on a server. That HTML is then delivered as-is to a browser for display. See also client-side page generation.

SQL: the language used for writing queries for relational databases. The term was originally an acronym for Structured Query Language.

stateful: to retain information from one operation to the next.

stateless: to not retain information from one operation to the next.

string: a block of text in a program. The term is short for “character string”.

table: a set of uniformly-formatted records in a relational database. Tables are usually drawn with rows (each of which represents one record) and columns (each of which represents a field).

tag: a short textual label identifying a kind of element in an HTML page. Commonly-used tags include p (for a paragraph) and h1 (for a level-1 heading).

template: a document with some placeholders that can be filled in with specific values. Templates are often used to create personalized email messages and web pages, though their efficacy is predicated upon relentless commercialization and devaluation of modern society’s sense of what constitutes “personal”.

throw: to signal that something unexpecte or unusual has happened in a program by creating an exception and handing it to the error-handling system, which then tries to find a point in the program that will catch it. (Some languages call this raising an exception.)

transport (logging): FIXME

tree: a data structure containing strictly-nested nodes. Every node except the root-node must have exactly one parent node, but each node may have zero or more children.

truthy: a truly horrible neologism meaning “not equivalent to false”. See also falsy, but only if you are able to set aside your respect for the English language.

Unicode: a standard that defines numeric codes for many thousands of characters and symbols. Unicode does not define how those numbers are stored; that is done by standards like UTF-8.

UTF-8: a way to store the numeric codes representing Unicode characters in memory that is backward-compatible with the older ASCII standard.

variable: a name in a program that has some data associated with it. A variable’s value can be changed after definition. See also constant.

XML: a set of rules for defining HTML-like tags and using them to format documents (typically data). XML achieved license plate popularity in the early 2000s, but its complexity led many programmers to adopt JSON instead.