GPL - MDN Web Docs Glossary: Definitions of Web-related terms

GPL
===

The (GNU) GPL (General Public License) is a copyleft free software license published by the Free Software Foundation. Users of a GPL-licensed program are granted the freedom to use it, read the source code, modify it and redistribute the changes they made, provided they redistribute the program (modified or unmodified) under the same license.

See also
--------

* FAQ on GNU licenses
* GNU GPL on Wikipedia
* GPL License text


Namespace - MDN Web Docs Glossary: Definitions of Web-related terms

Namespace
=========

Namespace is a context for identifiers, a logical grouping of names used in a program. Within the same context and same scope, an identifier must uniquely identify an entity.

In an operating system, a directory is a namespace. Each file or subdirectory within a directory has a unique name; the same name can be used multiple times across subdirectories.

In HTML, CSS, and XML-based languages, a namespace is the explicitly declared or implied dialect to which an element (or attribute) belongs.

See also
--------

* Namespaces crash course
* CSS namespaces module
* CSS `@namespace`
* `Document.createElementNS()` method
* Namespace on Wikipedia


Entity - MDN Web Docs Glossary: Definitions of Web-related terms

Entity
======

An HTML **entity** is a piece of text ("string") that begins with an ampersand (`&`) and ends with a semicolon (`;`). HTML entities are frequently used to display reserved characters (which would otherwise be interpreted as HTML code), and invisible characters (like non-breaking spaces). You can also use HTML character entities in place of other characters that are difficult to type with a standard keyboard.

**Note:** Many characters have memorable entities. For example, the entity for the copyright symbol (`©`) is `©`. For less memorable characters, such as `—` or `—`, you can use a reference chart or decoder tool.

Reserved characters
-------------------

Some special characters are reserved for use in HTML, meaning that your browser will parse them as HTML code. For example, if you use the less-than (`<`) sign, the browser interprets any text that follows as a tag.

To display these characters as text, replace them with their corresponding character entities, as shown in the following table.

| Character | Entity | Note |
| --- | --- | --- |
| & | `&` | Interpreted as the beginning of an entity or character reference. |
| < | `<` | Interpreted as the beginning of a tag |
| > | `>` | Interpreted as the ending of a tag |
| " | `"` | Interpreted as the beginning and end of an attribute's value. |
|  | ` ` | Interpreted as the non breaking space. |
| – | `–` | Interpreted as the en dash (half the width of an em unit). |
| — | `—` | Interpreted as the em dash (equal to width of an "m" character). |
| © | `©` | Interpreted as the copyright sign. |
| ® | `®` | Interpreted as the registered sign. |
| ™ | `™` | Interpreted as the trademark sign. |
| ≈ | `≈` | Interpreted as almost equal to sign. |
| ≠ | `≠` | Interpreted as not equal to sign. |
| £ | `£` | Interpreted as the pound symbol. |
| € | `€` | Interpreted as the euro symbol. |
| ° | `°` | Interpreted as the degree symbol. |

See also
--------

* Official list of character entities


OOP - MDN Web Docs Glossary: Definitions of Web-related terms

OOP
===

**OOP** (Object-Oriented Programming) is an approach in programming in which data is encapsulated within **objects** and the object itself is operated on, rather than its component parts.

JavaScript is heavily object-oriented. It follows a **prototype**-based model, but it also offers a class syntax to enable typical OOP paradigms.

See also
--------

* Object-oriented programming on Wikipedia
* Introduction to object-oriented JavaScript
* Inheritance and the prototype chain


Boolean - MDN Web Docs Glossary: Definitions of Web-related terms

Boolean
=======

In computer science, a **Boolean** is a logical data type that can have only the values `true` or `false`.

For example, in JavaScript, Boolean conditionals are often used to decide which sections of code to execute (such as in if statements) or repeat (such as in for loops).

Below is some JavaScript pseudocode (it's not truly executable code) demonstrating this concept.

```js
/\* JavaScript if statement \*/
if (boolean conditional) {
  // code to execute if the conditional is true
}

if (boolean conditional) {
  console.log("boolean conditional resolved to true");
} else {
  console.log("boolean conditional resolved to false");
}

/\* JavaScript for loop \*/
for (control variable; boolean conditional; counter) {
  // code to execute repeatedly if the conditional is true
}
```

The Boolean value is named after English mathematician George Boole, who pioneered the field of mathematical logic.

Above is a general introduction. The term **Boolean** can have more specific meanings depending on the context. It may refer to:

Boolean (JavaScript)
A **Boolean** in JavaScript is a Primitive that can be either `true` or `false`.
Boolean attribute (ARIA)
A **boolean attribute** in ARIA is an Enumerated that includes `true` or `false` in the enumerated list.
Boolean attribute (HTML)
A **boolean attribute** in HTML is an attribute that represents `true` or `false` values. If an HTML tag contains a boolean attribute - no matter the value of that attribute - the attribute is set to `true` on that element. If an HTML tag does not contain the attribute, the attribute is set to `false`.
See also
--------

* Boolean on Wikipedia


Grid Column - MDN Web Docs Glossary: Definitions of Web-related terms

Grid Column
===========

A **grid column** is a vertical track in a CSS Grid Layout, and is the space between two vertical grid lines. It is defined by the `grid-template-columns` property or in the shorthand `grid` or `grid-template` properties.

In addition, columns may be created in the *implicit grid* when items are placed outside of columns created in the *explicit grid*. These columns will be auto-sized by default, or can have a size specified with the `grid-auto-columns` property.

When working with alignment in CSS Grid Layout, the axis down which columns run is known as the *block, or column, axis*.

See also
--------

### Property reference

* `grid-template-columns`
* `grid-auto-columns`
* `grid`
* `grid-template`
### Further reading

* CSS Grid Layout Guide: *Basic concepts of grid layout*


Placeholder names - MDN Web Docs Glossary: Definitions of Web-related terms

Placeholder names
=================

Placeholder names are commonly used in cryptography to indicate the participants in a conversation, without resorting to terminology such as "Party A," "eavesdropper," and "malicious attacker."

The most commonly used names are:

* *Alice* and *Bob*, two parties who want to send messages to each other, occasionally joined by *Carol*, a third participant
* *Eve*, a passive attacker who is eavesdropping on Alice and Bob's conversation
* *Mallory*, an active attacker ("man-in-the-middle") who is able to modify their conversation and replay old messages


Computer Programming - MDN Web Docs Glossary: Definitions of Web-related terms

Computer Programming
====================

Computer programming is a process of composing and organizing a collection of instructions. These tell a computer/software program what to do in a language which the computer understands. These instructions come in the form of many different languages such as C++, Java, JavaScript, HTML, Python, Ruby, and Rust.

Using an appropriate language, you can program/create all sorts of software. For example, a program that helps scientists with complex calculations, a database that stores huge amounts of data, a website that allows people to download music, or animation software that allows people to create animated movies.

See also
--------

* Computer programming on Wikipedia
* List of Programming Languages: Wikipedia


Plaintext - MDN Web Docs Glossary: Definitions of Web-related terms

Plaintext
=========

Plaintext refers to information that is being used as an input to an encryption algorithm, or to ciphertext that has been decrypted.

It is frequently used interchangeably with the term *cleartext*, which more loosely refers to any information, such as a text document, image, etc., that has not been encrypted and can be read by a human or computer without additional processing.


Visual Viewport - MDN Web Docs Glossary: Definitions of Web-related terms

Visual Viewport
===============

The portion of the viewport that is currently visible is called the visual viewport. This can be smaller than the layout viewport, such as when the user has pinched-zoomed. The visual viewport is the visual portion of a screen excluding on-screen keyboards, areas outside of a pinch-zoom area, or any other on-screen artifact that doesn't scale with the dimensions of a page.

See also
--------

* Visual Viewport API
* Viewport on Wikipedia
* A tale of two viewports (Quirksmode)
* Viewport in the MDN Glossary
* Layout viewport in the MDN Glossary


Camel case - MDN Web Docs Glossary: Definitions of Web-related terms

Camel case
==========

**Camel case** is a way of writing phrases without spaces, where the first letter of each word is capitalized, except for the first letter of the entire compound word, which may be either upper or lower case. The name comes from the similarity of the capital letters to the humps of a camel's back. It's often stylized as "camelCase" to remind the reader of its appearance.

Camel casing is often used as a variable naming convention. The following variables are in camel case: `console`, `crossOriginIsolated`, `encodeURIComponent`, `ArrayBuffer`, and `HTMLElement`.

Note that if the phrase contains acronyms (such as `URI` and `HTML`), camel casing practices vary. Some prefer to keep all of them capitalized, such as `encodeURIComponent` above. This may sometimes lead to ambiguity with multiple consecutive acronyms, such as `XMLHTTPRequest`. Others prefer to only capitalize the first letter, as `XmlHttpRequest`. The actual global variable, `XMLHttpRequest`, uses a mix of both.

When the first letter of the entire phrase is upper case, it is called *upper camel case* or *Pascal case*. Otherwise, it is called *lower camel case*.

Camel case is the most popular convention in JavaScript, Java, and various other languages.

See also
--------

* Snake case
* Kebab case
* typescript-eslint rule: `naming-convention`


Browser - MDN Web Docs Glossary: Definitions of Web-related terms

Browser
=======

A **Web browser** or **browser** is a program that retrieves and displays pages from the Web, and lets users access further pages through hyperlinks. A browser is the most familiar type of user agent.

See also
--------

* Web browser on Wikipedia
* user agent (Glossary)
* `User-agent` (HTTP Header)
* Download a browser
    + Mozilla Firefox
    + Google Chrome
    + Microsoft Edge
    + Opera Browser


BigInt - MDN Web Docs Glossary: Definitions of Web-related terms

BigInt
======

In JavaScript, **BigInt** is a numeric data type that can represent integers in the arbitrary precision format. In other programming languages different numeric types can exist, for examples: Integers, Floats, Doubles, or Bignums.

See also
--------

* Numeric types on Wikipedia
* The JavaScript type: `BigInt`
* The JavaScript global object `BigInt`


Three js - MDN Web Docs Glossary: Definitions of Web-related terms

Three js
========

three.js is a JavaScript-based WebGL engine that can run GPU-powered games and other graphics-powered apps straight from the browser. The three.js library provides many features and APIs for drawing 3D scenes in your browser.

See also
--------

* Three.js on Wikipedia
* three.js official website


Native - MDN Web Docs Glossary: Definitions of Web-related terms

Native
======

A *native* application has been compiled to run on the hardware/software environment that comprises the targeted architecture.

An example of a native Android app would be a mobile application written in Java using the Android toolchain.

On the other hand, a Web App that runs inside a browser is not native — it is run in the web browser, which sits on top of the native environment, not the native environment itself.

See also
--------

* Native (computing) on Wikipedia


OpenSSL - MDN Web Docs Glossary: Definitions of Web-related terms

OpenSSL
=======

OpenSSL is an open-source implementation of TLS and SSL.

See also
--------

* OpenSSL on Wikipedia
* Official website


CORS-safelisted request header - MDN Web Docs Glossary: Definitions of Web-related terms

CORS-safelisted request header
==============================

A CORS-safelisted request header is one of the following HTTP headers:

* `Accept`,
* `Accept-Language`,
* `Content-Language`,
* `Content-Type`,
* `Range`.

When containing only these headers (and values that meet the additional requirements laid out below), a request doesn't need to send a preflight request in the context of CORS.

You can safelist more headers using the `Access-Control-Allow-Headers` header and also list the above headers there to circumvent the following additional restrictions.

Additional restrictions
-----------------------

CORS-safelisted headers must also fulfill the following requirements in order to be a CORS-safelisted request header:

* `Accept-Language` and `Content-Language` can only have values consisting of `0-9`, `A-Z`, `a-z`, space or `*,-.;=`.
* `Accept` and `Content-Type` can't contain a *CORS-unsafe request header byte*: `0x00-0x1F` (except for `0x09 (HT)`, which is allowed), `"():<>?@[\]{}`, and `0x7F (DEL)`.
* `Content-Type` needs to have a MIME type of its parsed value (ignoring parameters) of either `application/x-www-form-urlencoded`, `multipart/form-data`, or `text/plain`.
* `Range` needs to have a value of a single byte range in the form of `bytes=[0-9]+-[0-9]*`.
 See the `Range` header documentation for more details.
* For any header: the value's length can't be greater than 128.
See also
--------

* CORS-safelisted response header
* Forbidden header name
* Request header


Snap positions - MDN Web Docs Glossary: Definitions of Web-related terms

Snap positions
==============

Snap positions are points where the scrollport stops moving after the scrolling operation completes. Setting up snap positions allows to create a scrolling experience of paging through content instead of needing to drag content into view.

Snap positions are set up on a scroll container. See the CSS Scroll Snap properties.


CRLF - MDN Web Docs Glossary: Definitions of Web-related terms

CRLF
====

CR and LF are control characters or bytecode that can be used to mark a line break in a text file.

* CR = **Carriage Return** (`\r`, `0x0D` in hexadecimal, 13 in decimal) — moves the cursor to the beginning of the line without advancing to the next line.
* LF = **Line Feed** (`\n`, `0x0A` in hexadecimal, 10 in decimal) — moves the cursor down to the next line without returning to the beginning of the line.

A CR immediately followed by a LF (CRLF, `\r\n`, or `0x0D0A`) moves the cursor to the beginning of the line and then down to the next line.

See also
--------

* Newline on Wikipedia
* Carriage return on Wikipedia


SCM - MDN Web Docs Glossary: Definitions of Web-related terms

SCM
===

SCM (Source Control Management) is a system for managing source code. Usually it refers to the use of software to handle versioning of source files. A programmer can modify source code files without being afraid of editing out useful stuff, because a SCM keeps track of how the source code has changed and who made the changes.

Some SCM systems include CVS, SVN, GIT.

See also
--------

* Revision control on Wikipedia


SOAP - MDN Web Docs Glossary: Definitions of Web-related terms

SOAP
====

**SOAP** (Simple Object Access Protocol) is a protocol for transmitting data in XML format.

See also
--------

* SOAP on Wikipedia
* Specification


Synthetic monitoring - MDN Web Docs Glossary: Definitions of Web-related terms

Synthetic monitoring
====================

**Synthetic monitoring** involves monitoring the performance of a page in a 'laboratory' environment, typically with automation tooling in an environment that is as consistent as possible.

With a consistent baseline, synthetic monitoring is good for measuring the effects of code changes on performance. However, it doesn't necessarily reflect what users are experiencing.

Synthetic Monitoring involves deploying scripts to simulate the path an end-user might take through a web application, reporting back the performance of the simulator experiences. Examples of popular synthetic monitoring tools include WebPageTest and Lighthouse. The traffic measured is not of your actual users, but rather synthetically generated traffic collecting data on page performance.

Unlike RUM, synthetic monitoring provides a narrow view of performance that doesn't account for user differences, making it useful in getting basic data about an application's performance and spot-checking performance in development environments. Combined with other tools, such as network throttling, can provide excellent insight into potential problem areas.

See also
--------

* Real User Monitoring (RUM)
* Real User Monitoring (RUM) versus Synthetic Monitoring
* Beacon


CSS preprocessor - MDN Web Docs Glossary: Definitions of Web-related terms

CSS preprocessor
================

A **CSS preprocessor** is a program that lets you generate CSS from the preprocessor's own unique syntax.

There are many CSS preprocessors to choose from, however most CSS preprocessors will add some features that don't exist in pure CSS, such as mixin, nesting selector, inheritance selector, and so on. These features make the CSS structure more readable and easier to maintain.

To use a CSS preprocessor, you must install a CSS compiler on your web server; Or use the CSS preprocessor to compile on the development environment, and then upload compiled CSS file to the web server.

See also
--------

* A few of most popular CSS preprocessors:
    + Sass
    + LESS
    + Stylus
    + PostCSS
* MDN Web Docs Glossary
    + CSS


First paint - MDN Web Docs Glossary: Definitions of Web-related terms

First paint
===========

**First Paint** is the time between navigation and when the browser first renders pixels to the screen, rendering anything that is visually different from the default background color of the body. It is the first key moment in page load and will answer the question "Has the browser started to render the page?"

See also
--------

* First contentful paint
* `PerformancePaintTiming`
* Largest Contentful Paint
* First meaningful paint


Syntax error - MDN Web Docs Glossary: Definitions of Web-related terms

Syntax error
============

An exception caused by the incorrect use of a pre-defined syntax. Syntax errors are detected while compiling or parsing source code.

For example, if you leave off a closing brace (`}`) when defining a JavaScript function, you trigger a syntax error. Browser development tools display JavaScript and CSS syntax errors in the console.

See also
--------

* Syntax error on Wikipedia
* `SyntaxError` JavaScript object


Inheritance - MDN Web Docs Glossary: Definitions of Web-related terms

Inheritance
===========

Inheritance is a major feature of object-oriented programming. Data abstraction can be carried up several levels, that is, classes can have superclasses and subclasses.

As an app developer, you can choose which of the superclass's attributes and methods to keep and add your own, making class definition very flexible. Some languages let a class inherit from more than one parent (multiple inheritance).

See also
--------

* Inheritance and the prototype chain


Reporting directive - MDN Web Docs Glossary: Definitions of Web-related terms

Reporting directive
===================

**CSP reporting directives** are used in a `Content-Security-Policy` header and control the reporting process of CSP violations.

See Reporting directives for a complete list.

See also
--------

* Glossary
    + CSP
    + Fetch directive
    + Document directive
    + Navigation directive
* Reference
    + https://www.w3.org/TR/CSP/#directives-reporting
    + `upgrade-insecure-requests`
    + `block-all-mixed-content`
    + `Content-Security-Policy`


Quaternion - MDN Web Docs Glossary: Definitions of Web-related terms

Quaternion
==========

A **quaternion** is the quotient of two 3D vectors and is used in 3D graphics and in accelerometer-based sensors to represent orientation or rotational data.

While mathematical quaternions are more involved than this, the **unit quaternions** (or **rotational quaternions**) used to represent rotation while using WebGL or WebXR, for example, are represented using the same syntax as a 3D point. As such, the type `DOMPoint` (or `DOMPointReadOnly`) is used to store quaternions.

See also
--------

* Quaternions and spatial rotation on Wikipedia
* Quaternion on Wikipedia
* `XRRigidTransform.orientation` in the WebXR Device API reference


Transient activation - MDN Web Docs Glossary: Definitions of Web-related terms

Transient activation
====================

**Transient activation** (or "transient user activation") is a window state that indicates a user has recently pressed a button, moved a mouse, used a menu, or performed some other user interaction.

 This state is sometimes used as a mechanism for ensuring that a web API can only function if triggered by user interaction.
 For example, scripts cannot arbitrarily launch a popup that requires *transient activation* —it must be triggered from a UI element's event handler.

See Features gated by user activation for examples of APIs that require *transient activation*.

See the `UserActivation.isActive` property to programmatically access the current window's transient activation state.

**Note:** Transient activation expires after a timeout (if not renewed by further interaction), and may also be "consumed" by some APIs. See Sticky activation for a user activation that doesn't reset after it has been set initially.

See also
--------

* HTML Living Standard > Transient activation
* Sticky activation
* `UserActivation.isActive`


HTML - MDN Web Docs Glossary: Definitions of Web-related terms

HTML
====

**HTML** (HyperText Markup Language) is a descriptive language that specifies webpage structure.

Brief history
-------------

In 1990, as part of his vision of the Web, Tim Berners-Lee defined the concept of hypertext, which Berners-Lee formalized the following year through a markup mainly based on SGML. The IETF began formally specifying HTML in 1993, and after several drafts released version 2.0 in 1995. In 1994 Berners-Lee founded the W3C to develop the Web. In 1996, the W3C took over the HTML work and published the HTML 3.2 recommendation a year later. HTML 4.0 was released in 1999 and became an ISO standard in 2000.

At that time, the W3C nearly abandoned HTML in favor of XHTML, prompting the founding of an independent group called WHATWG in 2004. Thanks to WHATWG, work on HTML continued: the two organizations released the first draft of HTML5 in 2008 and an official standard in 2014. The term "HTML5" is just a buzzword referring to modern web technologies which are part of the HTML Living Standard.

Concept and syntax
------------------

An HTML document is a plaintext document structured with elements. Elements are surrounded by matching opening and closing tags. Each tag begins and ends with angle brackets (`<>`). There are a few empty or *void* elements that cannot enclose any text, for instance `<img>`.

You can extend HTML tags with attributes, which provide additional information affecting how the browser interprets the element:

![Detail of the structure of an HTML element](/en-US/docs/Glossary/HTML/anatomy-of-an-html-element.png)

An HTML file is normally saved with an `.htm` or `.html` extension, served by a web server, and can be rendered by any Web browser.

See also
--------

* HTML on Wikipedia
* Our HTML tutorial
* The web course on codecademy.com
* The HTML documentation on MDN
* The HTML specification


UX - MDN Web Docs Glossary: Definitions of Web-related terms

UX
==

**UX** is an acronym that stands for User eXperience. It is the study of the interaction between users and a system. Its goal is to make a system easy to interact with from the user's point of view.

The system can be any kind of product or application that an end user is meant to interact with. UX studies undertaken on a web page for example can demonstrate whether it is easy for users to understand the page, navigate to different areas, and complete common tasks, and where such processes could have less friction.

See also
--------

* User experience on Wikipedia


Encapsulation - MDN Web Docs Glossary: Definitions of Web-related terms

Encapsulation
=============

Encapsulation is the packing of data and functions into one component (for example, a class) and then controlling access to that component to make a "blackbox" out of the object. Because of this, a user of that class only needs to know its interface (that is, the data and functions exposed outside the class), not the hidden implementation.

See also
--------

* Encapsulation on Wikipedia


Callback function - MDN Web Docs Glossary: Definitions of Web-related terms

Callback function
=================

A **callback function** is a function passed into another function as an argument, which is then invoked inside the outer function to complete some kind of routine or action.

The consumer of a callback-based API writes a function that is passed into the API. The provider of the API (called the *caller*) takes the function and calls back (or executes) the function at some point inside the caller's body. The caller is responsible for passing the right parameters into the callback function. The caller may also expect a particular return value from the callback function, which is used to instruct further behavior of the caller.

There are two ways in which the callback may be called: *synchronous* and *asynchronous*. Synchronous callbacks are called immediately after the invocation of the outer function, with no intervening asynchronous tasks, while asynchronous callbacks are called at some point later, after an asynchronous operation has completed.

Understanding whether the callback is synchronously or asynchronously called is particularly important when analyzing side effects. Consider the following example:

```js
let value = 1;

doSomething(() => {
  value = 2;
});

console.log(value);
```

If `doSomething` calls the callback synchronously, then the last statement would log `2` because `value = 2` is synchronously executed; otherwise, if the callback is asynchronous, the last statement would log `1` because `value = 2` is only executed after the `console.log` statement.

Examples of synchronous callbacks include the callbacks passed to `Array.prototype.map()`, `Array.prototype.forEach()`, etc. Examples of asynchronous callbacks include the callbacks passed to `setTimeout()` and `Promise.prototype.then()`.

The Using promises guide has more information on the timing of asynchronous callbacks.

See also
--------

* Callback on Wikipedia


Parse - MDN Web Docs Glossary: Definitions of Web-related terms

Parse
=====

Parsing means analyzing and converting a program into an internal format that a runtime environment can actually run, for example the JavaScript engine inside browsers.

The browser parses HTML into a DOM tree. HTML parsing involves tokenization and tree construction. HTML tokens include start and end tags, as well as attribute names and values. If the document is well-formed, parsing it is straightforward and faster. The parser parses tokenized input into the document, building up the document tree.

When the HTML parser finds non-blocking resources, such as an image, the browser will request those resources and continue parsing. Parsing can continue when a CSS file is encountered, but `<script>` tags—particularly those without an `async` or `defer` attribute—blocks rendering, and pauses parsing of HTML.

When the browser encounters CSS styles, it parses the text into the CSS Object Model (or CSSOM), a data structure it then uses for styling layouts and painting. The browser then creates a render tree from both these structures to be able to paint the content to the screen. JavaScript is also downloaded, parsed, and then executed.

JavaScript parsing is done during compile time or whenever the parser is invoked, such as during a call to a method.

See also
--------

* Parse on Wikipedia


UTF-8 - MDN Web Docs Glossary: Definitions of Web-related terms

UTF-8
=====

UTF-8 (UCS Transformation Format 8) is the World Wide Web's most common character encoding. Each character is represented by one to four bytes. UTF-8 is backward-compatible with ASCII and can represent any standard Unicode character.

The first 128 UTF-8 characters precisely match the first 128 ASCII characters (numbered 0-127), meaning that existing ASCII text is already valid UTF-8. All other characters use two to four bytes. Each byte has some bits reserved for encoding purposes. Since non-ASCII characters require more than one byte for storage, they run the risk of being corrupted if the bytes are separated and not recombined.

See also
--------

* UTF-8 on Wikipedia
* FAQ about UTF-8 on Unicode website


CSRF - MDN Web Docs Glossary: Definitions of Web-related terms

CSRF
====

**CSRF** (Cross-Site Request Forgery) is an attack that impersonates a trusted user and sends a website unwanted commands.

This can be done, for example, by including malicious parameters in a URL behind a link that purports to go somewhere else:

```html
<img src="https://www.example.com/index.php?action=delete&id=123" />
```

For users who have modification permissions on `https://www.example.com`, the `<img>` element executes action on `https://www.example.com` without their noticing, even if the element is not at `https://www.example.com`.

There are many ways to prevent CSRF, such as implementing RESTful API, adding secure tokens, etc.

See also
--------

* Cross-site request forgery on Wikipedia
* Prevention measures


Statement - MDN Web Docs Glossary: Definitions of Web-related terms

Statement
=========

In a computer programming language, a **statement** is a line of code commanding a task. Every program consists of a sequence of statements.

See also
--------

* Statement (computer science) on Wikipedia
* JavaScript statements and declarations


Web server - MDN Web Docs Glossary: Definitions of Web-related terms

Web server
==========

A web server is a piece of software that often runs on a hardware server offering service to a user, usually referred to as the client. A server, on the other hand, is a piece of hardware that lives in a room full of computers, commonly known as a data center.

See also
--------

* Introduction to servers
* Server (computing) on Wikipedia


Quality values - MDN Web Docs Glossary: Definitions of Web-related terms

Quality values
==============

**Quality values**, or *q-values* and *q-factors*, are used to describe the order of priority of values in a comma-separated list. It is a special syntax allowed in some HTTP headers and in HTML.

The importance of a value is marked by the suffix `';q='` immediately followed by a value between `0` and `1` included, with up to three decimal digits, the highest value denoting the highest priority. When not present, the default value is `1`.

Examples
--------

The following syntax

```http
text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
```

indicates the order of priority:

| Value | Priority |
| --- | --- |
| `text/html` and `application/xhtml+xml` | `1.0` |
| `application/xml` | `0.9` |
| `*/*` | `0.8` |

If there is no priority defined for the first two values, the order in the list is irrelevant. Nevertheless, with the same quality, more specific values have priority over less specific ones:

```http
text/html;q=0.8,text/*;q=0.8,*/*;q=0.8
```

| Value | Priority |
| --- | --- |
| `text/html` | `0.8` (but totally specified) |
| `text/*` | `0.8` (partially specified) |
| `*/*` | `0.8` (not specified) |

Some syntax, like the one of `Accept`, allow additional specifiers like `text/html;level=1`. These increase the specificity of the value. Their use is extremely rare.

More information
----------------

* HTTP headers using q-values in their syntax: `Accept`, `Accept-Encoding`, `Accept-Language`, `TE`, `Want-Digest`.
* Header field definitions.


Progressive web apps - MDN Web Docs Glossary: Definitions of Web-related terms

Progressive web apps
====================

Progressive web applications (PWA) are applications that are built using web platform technologies, but that provide a user experience like that of a platform-specific app.

These kinds of apps enjoy all the best parts of the Web — such as discoverability via search engines, being linkable via URLs, and working across multiple form factors, but are progressively enhanced with modern APIs (such as Service Workers and Push).

These features include being installable, working offline, and being easy to sync with and re-engage the user from the server.

See also
--------

* Progressive web apps on MDN
* Progressive web apps on web.dev


SEO - MDN Web Docs Glossary: Definitions of Web-related terms

SEO
===

**SEO** (Search Engine Optimization) is the process of making a website more visible in search results, also termed improving search rankings.

Search engines crawl the web, following links from page to page, and index the content found. When you search, the search engine displays the indexed content. Crawlers follow rules. If you follow those rules closely when doing SEO for a website, you give the site the best chances of showing up among the first results, increasing traffic and possibly revenue (for e-commerce and ads).

Search engines give some guidelines for SEO, but big search engines keep result ranking as a trade secret. SEO combines official search engine guidelines, empirical knowledge, and theoretical knowledge from science papers or patents.

SEO methods fall into three broad classes:

Technical

Tag the content using semantic HTML. When exploring the website, crawlers should only find the content you want indexed.

Copywriting

Write content using your visitors' vocabulary. Use text as well as images so that crawlers can understand the subject.

Popularity

You get most traffic when other established sites link to your site.

See also
--------

* SEO on Wikipedia
* Google Search Central


JSON type representation - MDN Web Docs Glossary: Definitions of Web-related terms

JSON type representation
========================

JSON is a convenient and widely used format for serializing objects, arrays, numbers, strings, booleans, and null.
 JSON does not support all data types allowed by JavaScript, which means that JavaScript objects that use these incompatible types cannot be directly serialized to JSON.

 The *JSON type representation* of a JSON-incompatible object is an equivalent JavaScript object with properties encoded such that the information *can* be serialized to JSON.
 This typically has the same properties as the original object for compatible data types, while incompatible properties are converted/serialized to compatible types.
 For example, buffer properties in the original object might be base64url-encoded to strings in the JSON-type representation.

 An object that cannot automatically be serialized to JSON using the `JSON.stringify()` method can define an instance method named `toJSON()` that returns the *JSON-type representation* of the original object.
 `JSON.stringify()` will then use `toJSON()` to get the object to stringify, instead of the original object.
 `PublicKeyCredential.toJSON()` and `Performance.toJSON()` are examples of this approach.

 A JSON string serialized in this way can be deserialized back to the *JSON-type representation* object using `JSON.parse()`.
 It is common to provide a converter method, such as `PublicKeyCredential.parseCreationOptionsFromJSON()`, to convert the *JSON-type representation* back to the original object.


Flexbox - MDN Web Docs Glossary: Definitions of Web-related terms

Flexbox
=======

Flexbox is the commonly-used name for the CSS Flexible Box Layout Module, a layout model for displaying items in a single dimension — as a row or as a column.

In the specification, Flexbox is described as a layout model for user interface design. The key feature of Flexbox is the fact that items in a flex layout can grow and shrink. Space can be assigned to the items themselves, or distributed between or around the items.

Flexbox also enables alignment of items on the main or cross axis, thus providing a high level of control over the size and alignment of a group of items.

See also
--------

### Property reference

* `align-content`
* `align-items`
* `align-self`
* `flex`
* `flex-basis`
* `flex-direction`
* `flex-flow`
* `flex-grow`
* `flex-shrink`
* `flex-wrap`
* `justify-content`
* `order`
### Further reading

* *CSS Flexible Box Layout Module Level 1 Specification*
* CSS Flexbox Guide:
    + Basic Concepts of Flexbox
    + Relationship of flexbox to other layout methods
    + Aligning items in a flex container
    + Ordering flex items
    + Controlling Ratios of flex items along the main axis
    + Mastering wrapping of flex items
    + Typical use cases of flexbox


XQuery - MDN Web Docs Glossary: Definitions of Web-related terms

XQuery
======

**XQuery** is a computer language for updating, retrieving, and calculating data in XML databases.

See also
--------

* Official website
* XQuery on Wikipedia


Perceived performance - MDN Web Docs Glossary: Definitions of Web-related terms

Perceived performance
=====================

**Perceived performance** is a measure of how fast, responsive, and reliable a website *feels* to its users. The perception of how well a site is performing can have more impact on the user experience than the actual load and response times.

See also
--------

* Perceived performance


Gamut - MDN Web Docs Glossary: Definitions of Web-related terms

Gamut
=====

A color **gamut** is a subset of colors, usually representing the colors that a display or a printing device can represent.

No display or printer can represent the whole range of colors that a human eye can perceive. The device *gamut* represents the set that it supports.

Traditionally, in web development, the only gamut used was *sRGB* (Standard Red-Green-Blue), where each color is described using three bytes, one for each primary color. However, "wide-color" monitors and professional printers support a wider range of colors, that can't be represented using this gamut.

Since 2021, browsers have started to provide functionality for other gamuts, like *P3*, widely used in the movie industry, and *rec2020*.

Developers can define different sets of colors for devices supporting larger gamuts using the `color-gamut` media feature. They can describe colors outside the RGB gamut using specific CSS functions like `lch()` for the LCH cylindrical coordinate system, or `lab()` for the Lab coordinate system.

See also
--------

* *Gamut* on *Wikipedia*.


ASCII - MDN Web Docs Glossary: Definitions of Web-related terms

ASCII
=====

**ASCII** (*American Standard Code for Information Interchange*) is a character encoding standard of 128 7-bit used by computers for converting letters, numbers, punctuation, and control codes into digital form.

The first 33 ASCII code points are non-printing control codes including the carriage return, line feed, tab, and several obsolete non-printable codes stemming from its origin of representing telegraph codes. The other 95 are printable characters, including digits (0-9), lowercase (a-z) and uppercase (A-Z) letters, and punctuation symbols.

Many computer systems instead use Unicode, which has millions of code points, but the first 128 of these are the same as the ASCII set. UTF-8 superseded ASCII on the Web in 2007.

See also
--------

* ASCII on Wikipedia


XMLHttpRequest (XHR) - MDN Web Docs Glossary: Definitions of Web-related terms

XMLHttpRequest (XHR)
====================

`XMLHttpRequest` (XHR) is a JavaScript API to create HTTP requests. Its methods provide the ability to send network requests between the browser and a server.

The Fetch API is the modern replacement for XMLHttpRequest.

See also
--------

* The XMLHttpRequest API documentation.


Web standards - MDN Web Docs Glossary: Definitions of Web-related terms

Web standards
=============

Web standards are rules established by international standards bodies and defining how the Web works (and sometimes controlling the Internet as well).

Several standards bodies are responsible for defining different aspects of the Web, and all the standards must coordinate to keep the Web maximally usable and accessible. Web standards also must evolve to improve the current status and adapt to new circumstances.

This non-exhaustive list gives you an idea of which standards websites and network systems must conform to:

* **IETF** (Internet Engineering Task Force): Internet standards (STD), which among other things govern set-up and use of URIs, HTTP, and MIME
* **W3C**: specifications for markup language (e.g., HTML), style definitions (i.e., CSS), DOM, accessibility
* **IANA** (Internet Assigned Numbers Authority): name and number registries
* **Ecma Intl.:** scripting standards, most prominently for JavaScript
* **ISO** (International Organization for Standardization): standards governing a diverse array of aspects, including character encodings, website management, and user-interface design
See also
--------

* Web standards on Wikipedia


DOM (Document Object Model) - MDN Web Docs Glossary: Definitions of Web-related terms

DOM (Document Object Model)
===========================

The **DOM** (Document Object Model) is an API that represents and interacts with any HTML or XML-based markup language document. The DOM is a document model loaded in the browser and representing the document as a node tree, or **DOM tree**, where each node represents part of the document (e.g. an element, text string, or comment).

The DOM is one of the most-used APIs on the Web because it allows code running in a browser to access and interact with every node in the document. Nodes can be created, moved, and changed. Event listeners can be added to nodes and triggered on the occurrence of a given event.

See also
--------

* The DOM documentation on MDN
* The DOM Standard
* Document Object Model on Wikipedia


Specification - MDN Web Docs Glossary: Definitions of Web-related terms

Specification
=============

A **specification** is a document that lays out in detail what functionality or attributes a product must include before delivery. In the context of describing the Web, the term "specification" (often shortened to "spec") generally means a document describing a language, technology, or API which makes up the complete set of open Web technologies.

See also
--------

* Specification on Wikipedia


Dynamic typing - MDN Web Docs Glossary: Definitions of Web-related terms

Dynamic typing
==============

**Dynamically-typed languages** are those (like JavaScript) where the interpreter assigns variables a type at runtime based on the variable's value at the time.

See also
--------

* JavaScript data types and data structures
* Type system on Wikipedia


Doctype - MDN Web Docs Glossary: Definitions of Web-related terms

Doctype
=======

In HTML, the doctype is the required "`<!DOCTYPE html>`" preamble found at the top of all documents. Its sole purpose is to prevent a browser from switching into so-called "quirks mode" when rendering a document; that is, the "`<!DOCTYPE html>`" doctype ensures that the browser makes a best-effort attempt at following the relevant specifications, rather than using a different rendering mode that is incompatible with some specifications.

See also
--------

* Definition of the DOCTYPE in the HTML specification
* Quirks Mode and Standards Mode
* Document.doctype, a JavaScript method that returns the doctype


PHP - MDN Web Docs Glossary: Definitions of Web-related terms

PHP
===

PHP (a recursive initialism for PHP: Hypertext Preprocessor) is an open-source server-side scripting language that can be embedded into HTML to build web applications and dynamic websites.

Examples
--------

### Basic syntax

```php
// start of PHP code
<?php
 // PHP code goes here
?>
// end of PHP code
```

### Printing data on screen

```php
<?php
 echo "Hello World!";
?>
```

### PHP variables

```php
<?php
 // variables
 $nome='Danilo';
 $sobrenome='Santos';
 $pais='Brasil';
 $email='danilocarsan@gmail.com';

 // printing the variables
 echo $nome;
 echo $sobrenome;
 echo $pais;
 echo $email;
?>
```

See also
--------

* Official website
* PHP on Wikipedia
* PHP programming on Wikibooks
* MDN Web Docs Glossary
    + Java
    + JavaScript
    + Python
    + Ruby


Trident - MDN Web Docs Glossary: Definitions of Web-related terms

Trident
=======

Trident (or MSHTML) was a layout engine that powered Internet Explorer. A Trident fork called *EdgeHTML* replaced Trident in Internet Explorer's successor, Edge.

See also
--------

* Trident layout engine on Wikipedia


SMTP - MDN Web Docs Glossary: Definitions of Web-related terms

SMTP
====

**SMTP** (Simple Mail Transfer Protocol) is a protocol used to send a new email. Like POP and NNTP, it is a state machine-driven protocol.

The protocol is relatively straightforward. Primary complications include supporting various authentication mechanisms (GSSAPI, CRAM-MD5, NTLM, MSN, AUTH LOGIN, AUTH PLAIN, etc.), handling error responses, and falling back when authentication mechanisms fail (e.g., the server claims to support a mechanism, but doesn't).

See also
--------

* SMTP (Wikipedia)
* Glossary
    + NNTP
    + POP
    + protocol
    + state machine


Falsy - MDN Web Docs Glossary: Definitions of Web-related terms

Falsy
=====

A **falsy** (sometimes written **falsey**) value is a value that is considered false when encountered in a Boolean context.

JavaScript uses type conversion to coerce any value to a Boolean in contexts that require it, such as conditionals and loops.

The following table provides a complete list of JavaScript falsy values:

| Value | Type | Description |
| --- | --- | --- |
| null | Null | The keyword `null` — the absence of any value. |
| undefined | Undefined | `undefined` — the primitive value. |
| `false` | Boolean | The keyword `false`. |
| NaN | Number | `NaN` — not a number. |
| `0` | Number | The `Number` zero, also including `0.0`, `0x0`, etc. |
| `-0` | Number | The `Number` negative zero, also including `-0.0`, `-0x0`, etc. |
| `0n` | BigInt | The `BigInt` zero, also including `0x0n`, etc. Note that there is no `BigInt` negative zero — the negation of `0n` is `0n`. |
| `""` | String | Empty string value, also including `''` and ````. |
| `document.all` | Object | The only falsy object in JavaScript is the built-in `document.all`. |

The values `null` and `undefined` are also nullish.

Examples
--------

Examples of *falsy* values in JavaScript (which are coerced to false in Boolean contexts, and thus *bypass* the `if` block):

```js
if (false) {
  // Not reachable
}

if (null) {
  // Not reachable
}

if (undefined) {
  // Not reachable
}

if (0) {
  // Not reachable
}

if (-0) {
  // Not reachable
}

if (0n) {
  // Not reachable
}

if (NaN) {
  // Not reachable
}

if ("") {
  // Not reachable
}
```

### The logical AND operator, &&

If the first object is falsy, it returns that object:

```js
console.log(false && "dog");
// ↪ false

console.log(0 && "dog");
// ↪ 0
```

See also
--------

* Truthy
* Coercion
* Boolean
* Boolean coercion


Buffer - MDN Web Docs Glossary: Definitions of Web-related terms

Buffer
======

A buffer is a storage in physical memory used to temporarily store data while it is being transferred from one place to another.

See also
--------

* Data buffer on Wikipedia


REST - MDN Web Docs Glossary: Definitions of Web-related terms

REST
====

**REST** (Representational State Transfer) refers to a group of software architecture design constraints that bring about efficient, reliable and scalable distributed systems.

The basic idea of REST is that a resource, e.g. a document, is transferred via well-recognized, language-agnostic, and reliably standardized client/server interactions. Services are deemed RESTful when they adhere to these constraints.

HTTP APIs in general are sometimes colloquially referred to as RESTful APIs, RESTful services, or REST services, although they don't necessarily adhere to all REST constraints. Beginners can assume a REST API means an HTTP service that can be called using standard web libraries and tools.

See also
--------

* restapitutorial.com
* restcookbook.com
* REST on Wikipedia
* REST Architecture


Decryption - MDN Web Docs Glossary: Definitions of Web-related terms

Decryption
==========

In cryptography, **decryption** is the conversion of ciphertext into Plaintext.

Decryption is a cryptographic primitive: it transforms a ciphertext message into plaintext using a cryptographic algorithm called a cipher. Like encryption, decryption in modern ciphers is performed using a specific algorithm and a secret, called the key. Since the algorithm is often public, the key must stay secret if the encryption stays secure.

![The decryption primitive.](/en-US/docs/Glossary/Decryption/decryption.png)

Decryption is the reverse of encryption and if the key stays secret, decryption without knowing the specific secret, decryption is mathematically hard to perform. How hard depends on the security of the cryptographic algorithm chosen and evolves with the progress of cryptanalysis.

See also
--------

* Encryption and Decryption


Java - MDN Web Docs Glossary: Definitions of Web-related terms

Java
====

Java is a compiled, object-oriented, highly portable programming language.

Java is statically typed and features a similar syntax to C. It comes with a large library of readily usable functions, the Java Software Development Kit (SDK).

Programs are compiled only once ahead of time into a proprietary byte code and package format that runs inside the Java Virtual Machine (JVM). The JVM is available across many platforms, which allows Java programs to run almost everywhere without the need to be compiled or packaged again. This makes it a preferred language in many large enterprises with heterogeneous landscapes, but may be perceived "heavy".

See also
--------

* Java on Wikipedia


Blink - MDN Web Docs Glossary: Definitions of Web-related terms

Blink
=====

Blink is an open-source browser layout engine developed by Google as part of Chromium (and therefore part of Chrome as well). Specifically, Blink began as a fork of the WebCore library in WebKit, which handles layout, rendering, and DOM, but now stands on its own as a separate rendering engine.

See also
--------

* Blink project home page
* Blink on Wikipedia
* FAQ on Blink
* Glossary
    + Google Chrome
    + Gecko
    + Trident
    + WebKit
    + Rendering engine


Middleware - MDN Web Docs Glossary: Definitions of Web-related terms

Middleware
==========

Middleware is a (loosely defined) term for any software or service that enables the parts of a system to communicate and manage data. It is the software that handles communication between components and input/output, so developers can focus on the specific purpose of their application.

In server-side web application frameworks, the term is often more specifically used to refer to pre-built software components that can be added to the framework's request/response processing pipeline, to handle tasks such as database access.

See also
--------

* Middleware\_(distributed\_applications) on Wikipedia
* Middleware on Wikipedia


Idempotent - MDN Web Docs Glossary: Definitions of Web-related terms

Idempotent
==========

An HTTP method is **idempotent** if the intended effect on the server of making a single request is the same as the effect of making several identical requests.

This does not necessarily mean that the request does not have *any* unique side effects: for example, the server may log every request with the time it was received. Idempotency only applies to effects intended by the client: for example, a POST request intends to send data to the server, or a DELETE request intends to delete a resource on the server.

All safe methods are idempotent, as well as `PUT` and `DELETE`. The `POST` method is not idempotent.

To be idempotent, only the state of the server is considered. The response returned by each request may differ: for example, the first call of a `DELETE` will likely return a `200`, while successive ones will likely return a `404`. Another implication of `DELETE` being idempotent is that developers should not implement RESTful APIs with a *delete last entry* functionality using the `DELETE` method.

Note that the idempotence of a method is not guaranteed by the server and some applications may incorrectly break the idempotence constraint.

`GET /pageX HTTP/1.1` is idempotent, because it is a safe (read-only) method. Successive calls may return different data to the client, if the data on the server was updated in the meantime.

`POST /add_row HTTP/1.1` is not idempotent; if it is called several times, it adds several rows:

```http
POST /add\_row HTTP/1.1
POST /add\_row HTTP/1.1   -> Adds a 2nd row
POST /add\_row HTTP/1.1   -> Adds a 3rd row
```

`DELETE /idX/delete HTTP/1.1` is idempotent, even if the returned status code may change between requests:

```http
DELETE /idX/delete HTTP/1.1   -> Returns 200 if idX exists
DELETE /idX/delete HTTP/1.1   -> Returns 404 as it just got deleted
DELETE /idX/delete HTTP/1.1   -> Returns 404
```

See also
--------

* Definition of idempotent in the HTTP specification.
* Description of common idempotent methods: `GET`, `HEAD`, `PUT`, `DELETE`, `OPTIONS`, `TRACE`
* Description of common non-idempotent methods: `POST`, `PATCH`, `CONNECT`


Tag - MDN Web Docs Glossary: Definitions of Web-related terms

Tag
===

In HTML, a **tag** is used for creating an element.

The name of an HTML element is the name that appears at the beginning of the element's start tag and at the end of the element's end tag (if the element has an end tag). For example, the `p` in the `<p>` start tag and `</p>` end tag is the name of the HTML paragraph element. Note that an element name in an end tag is preceded by a slash character: `</p>`, and that for void elements, the end tag is neither required nor allowed.

See also
--------

* HTML element on Wikipedia
* HTML elements syntax on WHATWG
* Introduction to HTML


Array - MDN Web Docs Glossary: Definitions of Web-related terms

Array
=====

An *array* is an ordered collection of data (either primitive or object depending upon the language). Arrays are used to store multiple values under a single variable name. A regular variable, on the other hand, can store only one value.

Each item in an array has a number attached to it, called a numeric index, that allows you to access it. In JavaScript, arrays start at index zero and can be manipulated with various methods.

Arrays in JavaScript look like this:

```js
// Arrays in JavaScript can hold different types of data
const myArray = [1, 2, 3, 4];
const barbieDollNamesArray = ["Barbie", "Ken", "Midge", "Allan", "Skipper"];

// Array indexes starts at 0.
console.log(myArray[0]); // output: 1
console.log(barbieDollNamesArray[2]); // output: "Midge"
```

See also
--------

* JavaScript `Array` on MDN


ITU - MDN Web Docs Glossary: Definitions of Web-related terms

ITU
===

The International Telecommunication Union (ITU) is the organization authorized by the United Nations to establish standards and rules for telecommunication, including telegraph, radio, telephony and the internet.

From defining rules for ensuring transmissions get to where they need to go to and creating the "SOS" alert signal used in Morse code, the ITU has long played a key role in how we use technology to exchange information and ideas.

In the Internet Age, the ITU's role of establishing standards for video and audio data formats used for streaming, teleconferencing, and other purposes. For example, the ITU and the Moving Picture Experts Group (MPEG) worked together to develop and publish, as well as to maintain, the various MPEG specifications, such as MPEG-2 (ITU H.262), AVC (ITU H.264), and HEVC (ITU H.265).

See also
--------

* ITU website
* ITU history portal


Class - MDN Web Docs Glossary: Definitions of Web-related terms

Class
=====

In object-oriented programming, a *class* defines an object's characteristics. Class is a template definition of an object's properties and methods, the "blueprint" from which other more specific instances of the object are drawn.

See also
--------

* Classes in JavaScript
* Inheritance and the prototype chain
* Class-based programming on Wikipedia
* Object-oriented programming on Wikipedia


Table Grid Box - MDN Web Docs Glossary: Definitions of Web-related terms

Table Grid Box
==============

The **Table Grid Box** is a block level box which contains all of the table internal boxes, excluding the caption. The box which includes the caption is referred to as the Table Wrapper Box.


Stringifier - MDN Web Docs Glossary: Definitions of Web-related terms

Stringifier
===========

An object's stringifier is any attribute or method that is defined to provide a textual representation of the object for use in situations where a string is expected.

See also
--------

* Stringifiers in Information contained in a WebIDL file


UUID - MDN Web Docs Glossary: Definitions of Web-related terms

UUID
====

A **Universally Unique Identifier** (**UUID**) is a label used to uniquely identify a resource among all other resources of that type.

 Computer systems generate UUIDs locally using very large random numbers.
 In theory the IDs may not be globally unique, but the probability of duplicates is vanishingly small.
 If systems really need absolutely unique IDs then these might be allocated by a central authority.

 UUIDs are 128-bit values that are canonically represented as a 36-character string in the format `123e4567-e89b-12d3-a456-426614174000` (5 hex strings separated by hyphens).
 There are a number of versions that differ slightly in the way they are calculated; for example, the inclusion of temporal information.

The formal definition can be found in: RFC4122: A Universally Unique IDentifier (UUID) URN Namespace.

See also
--------

* UUID on Wikipedia
* `Crypto.randomUUID()`


Hyperlink - MDN Web Docs Glossary: Definitions of Web-related terms

Hyperlink
=========

Hyperlinks connect webpages or data items to one another. In HTML, `<a>` elements define hyperlinks from a spot on a webpage (like a text string or image) to another spot on some other webpage (or even on the same page).

See also
--------

* Hyperlink on Wikipedia
* The Hyperlink guide on MDN
* Links in HTML Documents - W3C
* HTML a - hyperlink - W3C
* `<a>` on MDN
* `<link>` on MDN


Truthy - MDN Web Docs Glossary: Definitions of Web-related terms

Truthy
======

In JavaScript, a **truthy** value is a value that is considered `true` when encountered in a Boolean context. All values are truthy unless they are defined as falsy. That is, all values are *truthy* except `false`, `0`, `-0`, `0n`, `""`, `null`, `undefined`, `NaN`, and `document.all`.

JavaScript uses type coercion in Boolean contexts.

Examples of *truthy* values in JavaScript (which will be coerced to `true` in boolean contexts, and thus execute the `if` block):

```js
if (true)
if ({})
if ([])
if (42)
if ("0")
if ("false")
if (new Date())
if (-42)
if (12n)
if (3.14)
if (-3.14)
if (Infinity)
if (-Infinity)
```

### The logical AND operator, &&

If the first operand is truthy, the logical AND operator returns the second operand:

```js
true && "dog"
// returns "dog"

[] && "dog"
// returns "dog"
```

See also
--------

* Falsy
* Type coercion
* Boolean
* Boolean coercion


WAI - MDN Web Docs Glossary: Definitions of Web-related terms

WAI
===

WAI or Web Accessibility Initiative is an effort by the World Wide Web Consortium (W3C) to improve accessibility for people with various challenges, who may need a nonstandard browser or devices.

See also
--------

* WAI website
* Web Accessibility Initiative on Wikipedia


Opera Browser - MDN Web Docs Glossary: Definitions of Web-related terms

Opera Browser
=============

**Opera** is the fifth most used web browser, publicly released in 1996 and initially running on Windows only. Opera uses Blink as its layout engine since 2013 (before that, Presto). Opera also exists in mobile and tablet versions.

See also
--------

* Opera Browser on Wikipedia
* Opera browser website


XInclude - MDN Web Docs Glossary: Definitions of Web-related terms

XInclude
========

XInclude is a W3C Recommendation defining inclusion tags that enable documents to include other documents or parts of other documents. Content can be included from other XML files or from text files.

The XInclude mechanism is not supported natively by any major browsers.

See also
--------

* XInclude standard
* `XPath`


Real User Monitoring (RUM) - MDN Web Docs Glossary: Definitions of Web-related terms

Real User Monitoring (RUM)
==========================

**Real User Monitoring** or RUM measures the performance of a page from real users' machines. Generally, a third party script injects a script on each page to measure and report page load data for every request made. This technique monitors an application's actual user interactions. In RUM, the third party script collects performance metrics from the real users' browsers. RUM helps identify how an application is being used, including the geographic distribution of users and the impact of that distribution on the end user experience.

See also
--------

* Real User Monitoring (RUM) versus Synthetic Monitoring
* Synthetic Monitoring
* Beacon


First-class Function - MDN Web Docs Glossary: Definitions of Web-related terms

First-class Function
====================

A programming language is said to have **First-class functions** when functions in that language are treated like any other variable. For example, in such a language, a function can be passed as an argument to other functions, can be returned by another function and can be assigned as a value to a variable.

Examples
--------

### Assigning a function to a variable

```js
const foo = () => {
  console.log("foobar");
};
foo(); // Invoke it using the variable
// foobar
```

We assigned an *Anonymous Function* in a Variable, then we used that variable to invoke the function by adding parentheses `()` at the end.

**Note:** Even if your function was named, you can use the variable name to invoke it. Naming it will be helpful when debugging your code. *But it won't affect the way we invoke it.*

### Passing a function as an argument

```js
function sayHello() {
  return "Hello, ";
}
function greeting(helloMessage, name) {
  console.log(helloMessage() + name);
}
// Pass `sayHello` as an argument to `greeting` function
greeting(sayHello, "JavaScript!");
// Hello, JavaScript!
```

We are passing our `sayHello()` function as an argument to the `greeting()` function, this explains how we are treating the function as a value.

**Note:** The function that we pass as an argument to another function is called a *callback function*. *`sayHello()` is a callback function.*

### Returning a function

```js
function sayHello() {
  return () => {
    console.log("Hello!");
  };
}
```

In this example, we are returning a function from another function - *We can return a function because functions in JavaScript are treated as values.*

**Note:** A function that returns a function or takes other functions as arguments is called a *higher-order function*.

See also
--------

* First-class functions on Wikipedia
* MDN Web Docs Glossary
    + Callback function
    + Function
    + Variable


Fallback alignment - MDN Web Docs Glossary: Definitions of Web-related terms

Fallback alignment
==================

In CSS Box Alignment, a fallback alignment is specified in order to deal with cases where the requested alignment cannot be fulfilled. For example, if you specify `justify-content: space-between` there must be more than one alignment subject. If there is not, the fallback alignment is used. This is specified per alignment method, as detailed below.

First baseline

`start`

Last baseline

`safe end`

Baseline

`start`

Space-between

`flex-start` (start)

Space-around

`center`

Space-evenly

`center`

Stretch

`flex-start` (start)

See also
--------

* CSS Box Alignment


Cryptographic hash function - MDN Web Docs Glossary: Definitions of Web-related terms

Cryptographic hash function
===========================

A cryptographic hash function, also sometimes called a *digest function*, is a cryptographic primitive transforming a message of arbitrary size into a message of fixed size, called a digest. Cryptographic hash functions are used for authentication, digital signatures, and message authentication codes.

To be used for cryptography, a hash function must have these qualities:

* quick to compute (because they are generated frequently)
* not invertible (each digest could come from a very large number of messages, and only brute-force can generate a message that leads to a given digest)
* tamper-resistant (any change to a message leads to a different digest)
* collision-resistant (it should be impossible to find two different messages that produce the same digest)

Cryptographic hash functions such as MD5 and SHA-1 are considered broken, as attacks have been found that significantly reduce their collision resistance.

See also
--------

* Cryptographic hash function on Wikipedia
* MDN Web Docs Glossary
    + Symmetric-key cryptography


Literal - MDN Web Docs Glossary: Definitions of Web-related terms

Literal
=======

**Literals** represent values in JavaScript. These are fixed values—not variables—that you *literally* provide in your script.

* Array literals
* Boolean literals
* Floating-point literals
* Numeric literals
* Object literals
* RegExp literals
* String literals
Examples
--------

### String literals

A string literal is zero or more characters enclosed in double (`"`) or single quotation marks (`'`). A string must be delimited by quotation marks of the same type (that is, either both single quotation marks, or both double quotation marks).

The following are examples of string literals:

```js
"foo";
"bar";
"1234";
"one line \n new line";
"Joyo's cat";
```

### Object literals

An object literal is a list of zero or more pairs of property names and associated values of an object, enclosed in curly braces (`{}`).

The following is an example of an object literal. The first element of the `car` object defines a property, `myCar`, and assigns to it a new string, "`Toyota`"; the second element, the `getCar` property, is immediately assigned the result of invoking the function `carTypes('Honda')`; the third element, the `special` property, uses an existing variable (`sales`).

```js
const sales = "BMW";

function carTypes(name) {
  return name === "Honda" ? name : `Sorry, we don't sell ${name}.`;
}

const car = {
  myCar: "Toyota",
  getCar: carTypes("Honda"),
  special: sales,
};

console.log(car.myCar); // Toyota
console.log(car.getCar); // Honda
console.log(car.special); // BMW
```

See also
--------

* Literal on Wikipedia


Random Number Generator - MDN Web Docs Glossary: Definitions of Web-related terms

Random Number Generator
=======================

A **PRNG** (pseudorandom number generator) is an algorithm that outputs numbers in a complex, seemingly unpredictable pattern. Truly random numbers (say, from a radioactive source) are utterly unpredictable, whereas all algorithms are predictable, and a PRNG returns the same numbers when passed the same starting parameters or *seed*.

PRNGs can be used for a variety of applications, such as games.

A cryptographically secure PRNG is a PRNG with certain extra properties making it suitable for use in cryptography. These include:

* that it's computationally unfeasible for an attacker (without knowledge of the seed) to predict its output
* that if an attacker can work out its current state, this should not enable the attacker to work out previously emitted numbers.

Most PRNGs are not cryptographically secure.

See also
--------

* Pseudorandom number generator on Wikipedia
* `Math.random()`, a built-in JavaScript PRNG function. Note that this is not a cryptographically secure PRNG.
* `Crypto.getRandomValues()`: this is intended to provide cryptographically secure numbers.


Grid Axis - MDN Web Docs Glossary: Definitions of Web-related terms

Grid Axis
=========

CSS Grid Layout is a two-dimensional layout method enabling the laying out of content in *rows* and *columns*. Therefore in any grid we have two axes. The *block or column axis*, and the *inline or row axis*.

It is along these axes that items can be aligned and justified using the properties defined in the Box Alignment specification.

In CSS the *block or column axis* is the axis used when laying out blocks of text. If you have two paragraphs and are working in a right to left, top to bottom language they lay out one below the other, on the block axis.

![Diagram showing the block axis in CSS Grid Layout.](/en-US/docs/Glossary/Grid_Axis/7_block_axis.png)

The *inline or row axis* runs across the Block Axis and is the direction along which regular text flows. These are our rows in CSS Grid Layout.

![Diagram showing the inline axis in CSS Grid Layout.](/en-US/docs/Glossary/Grid_Axis/7_inline_axis.png)

The physical direction of these axes can change according to the writing mode of the document.

See also
--------

* CSS Grid Layout Guide: *Basic concepts of grid layout*
* CSS Grid Layout Guide: *Box alignment in Grid Layout*
* CSS Grid Layout Guide: *Grids, logical values and writing modes*


Selector (CSS) - MDN Web Docs Glossary: Definitions of Web-related terms

Selector (CSS)
==============

A **CSS selector** is the part of a CSS rule that describes what elements in a document the rule will match. The matching elements will have the rule's specified style applied to them.

Example
-------

Consider this CSS:

```css
p {
  color: green;
}

div.warning {
  width: 100%;
  border: 2px solid yellow;
  color: white;
  background-color: darkred;
  padding: 0.8em 0.8em 0.6em;
}

#customized {
  font:
    16px Lucida Grande,
    Arial,
    Helvetica,
    sans-serif;
}
```

The selectors here are `"p"` (which applies the color green to the text inside any `<p>` element), `"div.warning"` (which makes any `<div>` element with the class `"warning"` look like a warning box), and `"#customized"`, which sets the base font of the element with the ID `"customized"` to 16-pixel tall Lucida Grande or one of a few fallback fonts.

We can then apply this CSS to some HTML, such as:

```html
<p>This is happy text.</p>

<div class="warning">
  Be careful! There are wizards present, and they are quick to anger!
</div>

<div id="customized">
  <p>This is happy text.</p>

  <div class="warning">
    Be careful! There are wizards present, and they are quick to anger!
  </div>
</div>
```

The resulting page content is styled like this:

See also
--------

* Learn more about CSS selectors in our introduction to CSS.
* Basic selectors
    + Type selectors `elementname`
    + Class selectors `.classname`
    + ID selectors `#idname`
    + Universal selectors `* ns|* *|*`
    + Attribute selectors `[attr=value]`
    + State selectors `a:active, a:visited`
* Grouping selectors
    + Selector list `A, B`
* Combinators
    + Next-sibling selectors `A + B`
    + Subsequent-sibling selectors `A ~ B`
    + Child selectors `A > B`
    + Descendant selectors `A B`
* Pseudo
    + Pseudo classes `:`
    + Pseudo elements `::`


Mobile First - MDN Web Docs Glossary: Definitions of Web-related terms

Mobile First
============

**Mobile first**, a form of progressive enhancement, is a web-development and web-design approach that focuses on prioritizing design and development for mobile screen sizes over design and development for desktop screen sizes. The rationale behind the mobile-first approach is to provide users with good user experiences at all screen sizes—by starting with creating a user experience that works well on small screens, and then building on top of that to further enrich the user experience as the screen size increases. The mobile-first approach contrasts with the older approach of designing for desktop screen sizes first, and then only later adding some support for small screen sizes.


Character set - MDN Web Docs Glossary: Definitions of Web-related terms

Character set
=============

A **character set** is an encoding system to let computers know how to recognize Character, including letters, numbers, punctuation marks, and whitespace.

In earlier times, countries developed their own character sets due to their different languages used, such as Kanji JIS codes (e.g. Shift-JIS, EUC-JP, etc.) for Japanese, Big5 for traditional Chinese, and KOI8-R for Russian. However, Unicode gradually became most acceptable character set for its universal language support.

If a character set is used incorrectly (For example, Unicode for an article encoded in Big5), you may see nothing but broken characters, which are called Mojibake.

See also
--------

* Character encoding (Wikipedia)
* Mojibake (Wikipedia)
* Glossary
    + Character
    + Unicode


Main Axis - MDN Web Docs Glossary: Definitions of Web-related terms

Main Axis
=========

The main axis in flexbox is defined by the direction set by the `flex-direction` property. There are four possible values for `flex-direction`. These are:

* `row`
* `row-reverse`
* `column`
* `column-reverse`

Should you choose `row` or `row-reverse` then your main axis will run along the row in the inline direction.

![In this image the flex-direction is row which forms the main axis](/en-US/docs/Glossary/Main_Axis/basics1.png)

Choose `column` or `column-reverse` and your main axis will run top to bottom of the page in the block direction.

![Three flex items taking up the full width of the container, displayed one below the other in code order. Flex-direction is set to column. The main axis is vertical i.e. from top to bottom](/en-US/docs/Glossary/Main_Axis/basics2.png)

On the main axis you can control the sizing of flex items by adding any available space to the items themselves, by way of `flex` properties on the items. Or, you can control the space between and around items by using the `justify-content` property.

See also
--------

### Property reference

* `flex-basis`
* `flex-direction`
* `flex-grow`
* `flex-shrink`
* `justify-content`
* `flex`
### Further reading

* CSS Flexbox Guide:
    + Basic Concepts of Flexbox
    + Aligning items in a flex container
    + Controlling Ratios of flex items along the main axis


Resource Timing - MDN Web Docs Glossary: Definitions of Web-related terms

Resource Timing
===============

Diagnosing performance issues requires performance data at the granularity of the resource. The Resource Timing API is a JavaScript API that is able to capture timing information for each individual resource that is fetched when a page is loaded.

See also
--------

* Using the resource timing API
* Server Timing


SLD - MDN Web Docs Glossary: Definitions of Web-related terms

SLD
===

An SLD (Second Level Domain) is the part of the domain name that is located right before a *Top Level Domain* (TLD). For example, in `mozilla.org` the SLD is `mozilla` and the TLD is `org`.

See Second Level Domain for more information.


Domain sharding - MDN Web Docs Glossary: Definitions of Web-related terms

Domain sharding
===============

Browsers limit the number of active connections for each domain. To enable concurrent downloads of assets exceeding that limit, **domain sharding** splits content across multiple subdomains. When multiple domains are used to serve multiple assets, browsers are able to download more resources simultaneously, resulting in a faster page load time and improved user experience.

The problem with domain sharding, in terms of performance, is the cost of extra DNS lookups for each domain and the overhead of establishing each TCP connection.

The initial response from an HTTP request is generally an HTML file listing other resources such as JavaScript, CSS, images and other media files that need to be downloaded. As browsers limit the number of active connections per domain, serving all the required resources from a single domain could be slow as assets need to be downloaded sequentially. With domain sharding, the required downloads are served from more than one domain, enabling the browser to simultaneously download needed resources. Multiple domains, however, is an anti-pattern, as DNS lookups slow initial load times.

HTTP2 supports unlimited concurrent requests making domain sharding an obsolete requirement when HTTP/2 is enabled.

See also
--------

* TLS
* DNS
* HTTP/2


SIMD - MDN Web Docs Glossary: Definitions of Web-related terms

SIMD
====

SIMD (pronounced "sim-dee") is short for **Single Instruction/Multiple Data** which is one classification of computer architectures. SIMD allows one same operation to be performed on multiple data points resulting in data level parallelism and thus performance gains — for example, for 3D graphics and video processing, physics simulations or cryptography, and other domains.

See also SISD for a sequential architecture with no parallelism in either the instructions or the data sets.

See also
--------

* SIMD on Wikipedia
* Glossary
    + SIMD
    + SISD


Alpha (alpha channel) - MDN Web Docs Glossary: Definitions of Web-related terms

Alpha (alpha channel)
=====================

The **alpha channel** specifies to opacity of a (`<color>`). Colors are represented in digital form as a collection of numbers, each representing the strength or intensity level of a given component of the color. Each of these components is called a **channel**. In a typical image file, the color channels describe how much red, green, and blue are used to make up the final color. To represent a color through which the background can be seen to some extent, a fourth channel is added to the color: the alpha channel.

For example, the color `#8921F2` (also described as `rgb(137 33 242)` or `hsl(270 89% 54)`) is a nice shade of purple. Below you see a small box of that color in the top-left corner and a box of the *same* color but with an alpha channel set at 50% (or 0.5) opacity, `#8921F280`, where `80` is the hexadecimal equivalent of 50%. This color is also described as `rgb(137 33 242 / 50%)` or `hsl(270 89% 54 / 50%)`. The two boxes are drawn on top of a paragraph of text.

![Image showing the effect of an alpha channel on a color.](/en-US/docs/Glossary/Alpha/alpha-channel-example.png)

As you can see, the color without an alpha channel completely blocks the background text, while the box with the alpha channel leaves it visible through the purple background color.

See also
--------

* CSS colors
* CSS values and units introduction
* Image file type and format guide
* Alpha compositing on Wikipedia
* RGBA color model on Wikipedia
* Channel (digital image) on Wikipedia


Code splitting - MDN Web Docs Glossary: Definitions of Web-related terms

Code splitting
==============

**Code splitting** is the practice of splitting the code a web application depends on — including its own code and any third-party dependencies — into separate bundles that can be loaded independently of each other.
 This allows an application to load only the code it actually needs at a given point in time, and load other bundles on demand.
 This approach is used to improve application performance, especially on initial load.

Code splitting is a feature supported by bundlers like Webpack and Browserify which can create multiple bundles that can be dynamically loaded at runtime.

See also
--------

* Bundling
* Lazy loading
* HTTP/2
* Tree shaking


OpenGL - MDN Web Docs Glossary: Definitions of Web-related terms

OpenGL
======

**OpenGL** (**Open Graphics Library**) is a cross-language, multi-platform application programming interface (API) for rendering 2D and 3D vector graphics. The API is typically used to interact with a graphics processing unit (GPU), to achieve hardware-accelerated rendering.

See also
--------

* OpenGL on Wikipedia
* OpenGL


Locale - MDN Web Docs Glossary: Definitions of Web-related terms

Locale
======

**Locale** is a set of language- or country-based preferences for a user interface.

A program draws its locale settings from the language of the host system. Among other things, locales represent paper format, currency, date format, and numbers according to the protocols in the given region.

See also
--------

* Locale on Wikipedia


Parser - MDN Web Docs Glossary: Definitions of Web-related terms

Parser
======

A **parser** is the module of a compiler or interpreter that parses a source code file.

More generally, it's a piece of software that parses text and transforms its content to another representation.

See also
--------

* Parser on Wikipedia


Scroll container - MDN Web Docs Glossary: Definitions of Web-related terms

Scroll container
================

A **scroll container** is an element box in which content can be scrolled, whether or not scroll bars are present. A user agent adds scroll bars to an element box to make it a scroll container when the CSS `overflow` property is set to `scroll` or when `overflow` is set to `auto` *and* the content overflows the container.

When the content of an element box overflows its bounding box, users can use scroll bars to scroll through the clipped content that is otherwise hidden from view.

A scroll container includes a scrollport and scroll bars.

Scrollport
----------

The scrollport is the visible part of a scroll container and coincides with the padding box of the scroll container. The scroll bars are used to move content in and out of the scrollport so that the content can be viewed.


JavaScript - MDN Web Docs Glossary: Definitions of Web-related terms

JavaScript
==========

JavaScript (or "JS") is a programming language used most often for dynamic client-side scripts on webpages, but it is also often used on the server-side, using a runtime such as Node.js.

JavaScript **should not** be confused with the Java programming language. Although *"Java"* and *"JavaScript"* are trademarks (or registered trademarks) of Oracle in the U.S. and other countries, the two programming languages are significantly different in their syntax, semantics, and use cases.

JavaScript is primarily used in the browser, enabling developers to manipulate webpage content through the DOM, retrieve content from servers using the `fetch()` API, store complex data using IndexedDB, draw graphics with canvas, interact with the device running the browser through various APIs, and more. JavaScript is one of the world's most commonly-used languages, owing to the recent growth and performance improvement of APIs available in browsers.

Origins and History
-------------------

Conceived as a server-side language by Brendan Eich (then employed by the Netscape Corporation), JavaScript soon came to Netscape Navigator 2.0 in September 1995. JavaScript enjoyed immediate success and Internet Explorer 3.0 introduced JavaScript support under the name JScript in August 1996.

In November 1996, Netscape began working with Ecma International to make JavaScript an industry standard. Since then, the standardized JavaScript is called ECMAScript and specified under ECMA-262, whose latest (fourteenth, ES2023) edition is available as of June 2023.

Recently, JavaScript's popularity has expanded even further through the successful Node.js platform—the most popular cross-platform JavaScript runtime environment outside the browser. Node.js - built using Chrome's V8 JavaScript Engine - allows developers to use JavaScript as a scripting language to automate things on a computer and build fully functional HTTP and WebSockets servers.

See also
--------

* JavaScript on Wikipedia
* The JavaScript Guide on MDN
* The "javascripting" workshop on NodeSchool
* The JavaScript course on codecademy.com
* The latest ECMAScript standard
* The JavaScript reference on MDN
* The *Eloquent JavaScript* book


Loop - MDN Web Docs Glossary: Definitions of Web-related terms

Loop
====

A **loop** is a sequence of instructions that is repeated until a certain condition is met. An example would be the process of getting an item of data and changing it, and then making sure some condition is checked — such as if a counter has reached a prescribed number.

Loops are one way to execute a statement for a variable number of times. The same effect can be achieved with recursion, especially in languages where all data is immutable, making it impossible to update a counter variable.

See also
--------

* Control flow on Wikipedia
* Loops and iteration guide


Delta - MDN Web Docs Glossary: Definitions of Web-related terms

Delta
=====

The term **delta** refers to the difference between two values or states.

The name originates from the Greek letter Δ (delta), which is equivalent to the letter *D* in the Roman alphabet. *Delta* refers to the use of the letter Δ as a shorthand for *difference*.

The term *delta* is commonly used when communicating changes in speed, position, or acceleration of a physical or virtual object. It's also used when describing changes in the volume or frequency of sound waves.

For example, when describing how far an object on the screen moves left-to-right, one might use the term *delta x* or *Δx*.

Likewise, given the new value of *X* and its old value, you might compute the delta like this:

```js
let deltaX = newX - oldX;
```

More commonly, you receive the delta and use it to update a saved previous condition:

```js
let newX = oldX + deltaX;
```

See also
--------

* Mouse wheel events (`WheelEvent` offer the amount the wheel moved since the last event in its `deltaX`, `deltaY`, and `deltaZ` properties, for example.


Codec - MDN Web Docs Glossary: Definitions of Web-related terms

Codec
=====

A **codec** (a blend word derived from "**co**der-**dec**oder") is a program, algorithm, or device that encodes or decodes a data stream. A given codec knows how to handle a specific encoding or compression technology.

See also
--------

* Codec on Wikipedia
* Web video codec guide
* Web audio codec guide
* Guide to media types and formats on the web


RTF - MDN Web Docs Glossary: Definitions of Web-related terms

RTF
===

RTF (Rich Text Format) is a plain-text-based file format with support for formatting instructions (like bold or italic).

Three programmers in the Microsoft Word team created RTF in the 1980s, and Microsoft continued to develop the format until 2008. However, many word-processing programs can still read and write RTF.

See also
--------

* Rich Text Format on Wikipedia
* specification v1.9.1 from Microsoft


WebAssembly - MDN Web Docs Glossary: Definitions of Web-related terms

WebAssembly
===========

**WebAssembly** (abbr. *Wasm*) is an open binary programming format that can be run in modern web browsers in order to gain performance and/or provide new features for web pages.

See also
--------

* WebAssembly on Wikipedia
* Official website
* WebAssembly on MDN


ECMA - MDN Web Docs Glossary: Definitions of Web-related terms

ECMA
====

**Ecma International** (formally *European Computer Manufacturers Association*) is a non-profit organization that develops standards in computer hardware, communications, and programming languages.

On the web it is famous for being the organization which maintain the ECMA-262 specification (aka. ECMAScript) which is the core specification for the JavaScript language.

See also
--------

* Ecma International on Wikipedia
* The Ecma International website


Clickjacking - MDN Web Docs Glossary: Definitions of Web-related terms

Clickjacking
============

Clickjacking is an interface-based attack that tricks website users into unwittingly clicking on malicious links. In clickjacking, the attackers embed their malicious links into buttons or legitimate pages in a website. In an infected Site, whenever a user clicks on a legitimate link, the attacker gets the confidential information of that user, which ultimately compromises the user's privacy on the Internet.

Clickjacking can be prevented by implementing a Content Security Policy (frame-ancestors) and implementing Set-Cookie attributes.

See also
--------

* Web security: clickjacking protection
* Clickjacking on Wikipedia
* Clickjacking on OWASP


Base64 - MDN Web Docs Glossary: Definitions of Web-related terms

Base64
======

**Base64** is a group of similar binary-to-text encoding schemes that represent binary data in an ASCII string format by translating it into a radix-64 representation. The term *Base64* originates from a specific MIME content transfer encoding.

When the term "Base64" is used on its own to refer to a specific algorithm, it typically refers to the version of Base64 outlined in RFC 4648, section 4, which uses the following alphabet to represent the radix-64 digits, alongside `=` as a padding character:
```

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
```

A common variant is "Base64 URL safe", which omits the padding and replaces `+/` with `-_` to avoid characters that might cause problems in URL path segments or query parameters.

Base64 encoding schemes are commonly used to encode binary data for storage or transfer over media that can only deal with ASCII text (or some superset of ASCII that still falls short of accepting arbitrary binary data). This ensures that the data remains intact without modification during transport. Common applications of Base64 include:

* Email via MIME
* Storing complex data in XML
* Encoding binary data so it can be included in a `data:` URL
Encoded size increase
---------------------

Each Base64 digit represents 6 bits of data. So, three 8-bit bytes of the input string/binary file (3×8 bits = 24 bits) can be represented by four 6-bit Base64 digits (4×6 = 24 bits).

This means that the Base64 version of a string or file is typically roughly a third larger than its source (the exact size increase depends on various factors, such as the absolute length of the string, its length modulo 3, and whether padding characters are used).

JavaScript support
------------------

Browsers natively provide two JavaScript functions for decoding and encoding Base64 strings:

* `btoa`: creates a Base64-encoded ASCII string from a string of binary data ("btoa" should be read as "binary to ASCII").
* `atob`: decodes a Base64-encoded string ("atob" should be read as "ASCII to binary").

**Note:** Base64 is a binary encoding rather than a text encoding, but `btoa` and `atob` were added to the web platform before it supported binary data types. As a result, the two functions use strings to represent binary data, with the code point of each character representing the value of each byte. This has led to a common misconception that `btoa` can be used to encode arbitrary text data — for example, creating a Base64 `data:` URL of a text or HTML document.

However, the byte-to-code-point correspondence only reliably holds true for code points up to `0x7f`. Furthermore, code points over `0xff` will cause `btoa` to throw an error due to exceeding the maximum value for 1 byte. The next section details how to work around this limitation when encoding arbitrary Unicode text.

The "Unicode Problem"
---------------------

Since `btoa` interprets the code points of its input string as byte values, calling `btoa` on a string will cause a "Character Out Of Range" exception if a character's code point exceeds `0xff`. For use cases where you need to encode arbitrary Unicode text, it is necessary to first convert the string to its constituent bytes in UTF-8, and then encode the bytes.

The simplest solution is to use `TextEncoder` and `TextDecoder` to convert between UTF-8 and single-byte representations of the string:

```js
function base64ToBytes(base64) {
  const binString = atob(base64);
  return Uint8Array.from(binString, (m) => m.codePointAt(0));
}

function bytesToBase64(bytes) {
  const binString = String.fromCodePoint(...bytes);
  return btoa(binString);
}

// Usage
bytesToBase64(new TextEncoder().encode("a Ā 𐀀 文 🦄")); // "YSDEgCDwkICAIOaWhyDwn6aE"
new TextDecoder().decode(base64ToBytes("YSDEgCDwkICAIOaWhyDwn6aE")); // "a Ā 𐀀 文 🦄"
```

Converting arbitrary binary data
--------------------------------

The `bytesToBase64` and `base64ToBytes` functions in the previous section can be used directly to convert between Base64 strings and `Uint8Array`s.

Alternatively, asynchronous conversion between base64 data URLs is possible natively within the web platform via the `FileReader` and `fetch` APIs:

```js
async function bytesToBase64DataUrl(bytes, type = "application/octet-stream") {
  return await new Promise((resolve, reject) => {
    const reader = Object.assign(new FileReader(), {
      onload: () => resolve(reader.result),
      onerror: () => reject(reader.error),
    });
    reader.readAsDataURL(new File([bytes], "", { type }));
  });
}

async function dataUrlToBytes(dataUrl) {
  const res = await fetch(dataUrl);
  return new Uint8Array(await res.arrayBuffer());
}

// Usage
await bytesToBase64DataUrl(new Uint8Array([0, 1, 2])); // "data:application/octet-stream;base64,AAEC"
await dataUrlToBytes("data:application/octet-stream;base64,AAEC"); // Uint8Array [0, 1, 2]
```


Grid Cell - MDN Web Docs Glossary: Definitions of Web-related terms

Grid Cell
=========

In a CSS Grid Layout, a **grid cell** is the smallest unit you can have on your CSS grid. It is the space between four intersecting grid lines and conceptually much like a table cell.

![Diagram showing an individual cell on the grid.](/en-US/docs/Glossary/Grid_Cell/1_grid_cell.png)

If you do not place items using one of the grid placement methods, direct children of the grid container will be placed one into each individual grid cell by the auto-placement algorithm. Additional row or column tracks will be created to create enough cells to hold all items.

Example
-------

In the example we have created a three column track grid. The five items are placed into grid cells working along an initial row of three grid cells, then creating a new row for the remaining two.
```

\* {
  box-sizing: border-box;
}

.wrapper {
  border: 2px solid #f76707;
  border-radius: 5px;
  background-color: #fff4e6;
}

.wrapper > div {
  border: 2px solid #ffa94d;
  border-radius: 5px;
  background-color: #ffd8a8;
  padding: 1em;
  color: #d9480f;
}
```

```css
.wrapper {
  display: grid;
  grid-template-columns: repeat(3, 1fr);
  grid-auto-rows: 100px;
}
```

```html
<div class="wrapper">
  <div>One</div>
  <div>Two</div>
  <div>Three</div>
  <div>Four</div>
  <div>Five</div>
</div>
```

See also
--------

### Property reference

* `grid-template-columns`
* `grid-template-rows`
* `grid-auto-rows`
* `grid-auto-columns`
### Further reading

* CSS Grid Layout Guide: *Basic concepts of grid layout*
* Definition of Grid Cells in the CSS Grid Layout specification


Exception - MDN Web Docs Glossary: Definitions of Web-related terms

Exception
=========

An **exception** is a condition that interrupts normal code execution. In JavaScript syntax errors are a very common source of exceptions.

See also
--------

* Exception handling on Wikipedia


Node - MDN Web Docs Glossary: Definitions of Web-related terms

Node
====

The term **node** can have several meanings depending on the context. It may refer to:

Node (DOM)
In the context of the DOM, a **node** is a single point in the node tree. Various things that are nodes are the document itself, elements, text, and comments.
Node (networking)
In networking, a **node** is a connection point in the network. In physical networks, a node is usually a device, like a computer or a router.

Another use of the word is when talking about Node.js


Privileged - MDN Web Docs Glossary: Definitions of Web-related terms

Privileged
==========

Users are said to be **privileged** when they are granted additional rights to a system, or given ultimate access to content in a higher priority level when compared to normal users.

See also
--------

* Privilege (computing) on Wikipedia


HTTP/3 - MDN Web Docs Glossary: Definitions of Web-related terms

HTTP/3
======

**HTTP/3** is the upcoming major revision of the HTTP network protocol, succeeding HTTP/2.

The major point of HTTP/3 is that it uses a new UDP protocol named QUIC, instead of TCP.

See also
--------

* HTTP on MDN
* HTTP/3 on Wikipedia
* Glossary
    + HTTP
    + HTTP 2
    + Latency


Usenet - MDN Web Docs Glossary: Definitions of Web-related terms

Usenet
======

Usenet is an internet discussion system where each post is duplicated on many servers. The equivalent of Internet forums in its day, Usenet functioned like a bulletin board system.

See also
--------

* Usenet on Wikipedia


VoIP - MDN Web Docs Glossary: Definitions of Web-related terms

VoIP
====

VoIP (Voice over Internet Protocol) is a technology used to transmit voice messages over IP (Internet Protocol) networks. Common VoIP packages include Skype, MSN Messenger, Yahoo and many more. Everything transferred through VoIP is digital. It is also known as IP telephony, or broadband telephony. The main reason for using VoIP technology is because of cost.

VoIP allows you to make a call directly from a computer, a special VoIP phone, or a traditional phone connected to a special adapter. A high speed internet connection is required for VoIP. Usually, telephone calls over the Internet do not incur further charges beyond what the user is paying for Internet access, much in the same way that the user doesn't pay for sending individual emails over the Internet.

See also
--------

* VoIP on Wikipedia


ALPN - MDN Web Docs Glossary: Definitions of Web-related terms

ALPN
====

**Application-Layer Protocol Negotiation** (**ALPN**) is a TLS extension (defined in RFC 7301) for identifying what application-layer protocol is negotiating the encrypted connection, without requiring additional round trips to do so.

| Protocol | Identification sequence |
| --- | --- |
| HTTP/1.1 | `0x68 0x74 0x74 0x70 0x2F 0x31 0x2E 0x31` ("http/1.1") |
| HTTP/2 | `0x68 0x32` ("h2") |
| HTTP/2 over cleartext TCP | `0x68 0x32 0x63` ("h2c") |
| HTTP/3 | `0x68 0x33` ("h3") |

See also
--------

* Performance resource timing `nextHopProtocol` property
* PerformanceObserver API
* IANA registered ALPN identifiers


CalDAV - MDN Web Docs Glossary: Definitions of Web-related terms

CalDAV
======

CalDAV (Calendaring extensions to WebDAV) is a protocol standardized by the IETF and used to remotely access calendar data from a server.

See also
--------

* CalDAV on Wikipedia
* RFC 4791: Calendaring extensions to WebDAV (CalDAV)
* RFC 6638: Scheduling Extensions to CalDAV