recursal/MDN huggingface dataset:
HTTP
====

The HyperText Transfer Protocol (**HTTP**) is the underlying network protocol that enables transfer of hypermedia documents on the Web, typically between a browser and a server so that humans can read them. The current version of the HTTP specification is called HTTP/2.

As part of a URI, the "http" within "http://example.com/" is called a "scheme". Resources using the "http" schema are typically transported over unencrypted connections using the HTTP protocol. The "https" scheme (as in "https://developer.mozilla.org") indicates that a resource is transported using the HTTP protocol, but over a secure TLS channel.

HTTP is textual (all communication is done in plain text) and stateless (no communication is aware of previous communications). This property makes it ideal for humans to read documents (websites) on the world wide web. However, HTTP can also be used as a basis for REST web services from server to server or `fetch()` requests within websites to make them more dynamic.

See also
--------

* HTTP on MDN
* HTTP on Wikipedia
Ciphertext
==========

In cryptography, a ciphertext is a scrambled message that conveys information but is not legible unless decrypted with the right cipher and the right secret (usually a key), reproducing the original Plaintext. A ciphertext's security, and therefore the secrecy of the contained information, depends on using a secure cipher and keeping the key secret.

See also
--------

* Ciphertext on Wikipedia
Houdini
=======

Houdini is a set of low level APIs that give developers the power to extend CSS, providing the ability to hook into the styling and layout process of a browser's rendering engine. Houdini gives developers access to the CSS Object Model (CSSOM), enabling developers to write code the browser can parse as CSS.

The benefit of Houdini is that developers can create CSS features without waiting for web standards specifications to define them and without waiting for every browser to fully implement the features.

While many of the features Houdini enables can be created with JavaScript, interacting directly with the CSSOM before JavaScript is enabled provides for faster parse times. Browsers create the CSSOM — including layout, paint, and composite processes — before applying any style updates found in scripts: layout, paint, and composite processes are repeated for updated JavaScript styles to be implemented. Houdini code doesn't wait for that first rendering cycle to be complete. Rather, it is included in that first cycle, creating renderable, understandable styles.

See also
--------

* Houdini APIs
* CSSOM
* CSS Paint API
* CSS Typed OM
Same-origin policy
==================

The **same-origin policy** is a critical security mechanism that restricts how a document or script loaded from one origin can interact with a resource from another origin.

It helps isolate potentially malicious documents, reducing possible attack vectors.

See also
--------

* Same-origin policy
* MDN Web Docs Glossary:
    + CORS
    + origin
Signature
=========

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

Signature (functions)
A **function signature** (or *type* signature, or *method* signature) defines input and output of Function or Method.
Signature (security)
A **signature**, or *digital signature*, is a protocol showing that a message is authentic.
See also
--------

* Signature on Wikipedia
First input delay
=================

**First input delay** (FID) measures the time from when a user first interacts with your site (i.e. when they click a link, tap on a button, or use a custom, JavaScript-powered control) to the time when the browser is actually able to respond to that interaction.

It is the length of time, in milliseconds, between the first user interaction on a web page and the browser's response to that interaction. Scrolling and zooming are not included in this metric.

The time between when content is painted to the page and when all the functionality becomes responsive to human interaction often varies based on the size and complexity of the JavaScript needing to be downloaded, parsed, and executed on the main thread, and on the device speed or lack thereof (think low end mobile devices). The longer the delay, the worse the user experience. Reducing site initialization time and eliminating long tasks can help eliminate first input delays.

See also
--------

* requestIdleCallback
* lazy loading
Replay attack
=============

In web security, a *replay attack* happens when an attacker intercepts a previously-sent message and resends it later to get the same credentials as the original message, potentially with a different payload or instruction.

Replay attacks can be prevented by including a unique, single-use identifier with each message that the receiver can use to verify the authenticity of the transmission. This identifier can take the form of a session token or "number used only once" ("nonce").

See also
--------

* Replay attack on Wikipedia.
Round Trip Time (RTT)
=====================

**Round Trip Time (RTT)** is the length time it takes for a data packet to be sent to a destination plus the time it takes for an acknowledgment of that packet to be received back at the origin. The RTT between a network and server can be determined by using the `ping` command.


```bash
ping example.com
```


This will output something like:
```

PING example.com (216.58.194.174): 56 data bytes
64 bytes from 216.58.194.174: icmp_seq=0 ttl=55 time=25.050 ms
64 bytes from 216.58.194.174: icmp_seq=1 ttl=55 time=23.781 ms
64 bytes from 216.58.194.174: icmp_seq=2 ttl=55 time=24.287 ms
64 bytes from 216.58.194.174: icmp_seq=3 ttl=55 time=34.904 ms
64 bytes from 216.58.194.174: icmp_seq=4 ttl=55 time=26.119 ms
--- google.com ping statistics ---
5 packets transmitted, 5 packets received, 0.0% packet loss
round-trip min/avg/max/stddev = 23.781/26.828/34.904/4.114 ms
```


In the above example, the average round trip time is shown on the final line as 26.8ms.

See also
--------

* Time to First Byte (TTFB)
* Latency
W3C
===

The *World Wide Web Consortium* (W3C) is an international body that maintains Web-related rules and frameworks.

It consists of over 350 member-organizations that jointly develop Web standards, run outreach programs, and maintain an open forum for talking about the Web. The W3C coordinates companies in the industry to make sure they implement the same W3C standards.

Each standard passes through four stages of maturity: Working Draft (WD), Candidate Recommendation (CR), Proposed Recommendation (PR), and W3C Recommendation (REC).

See also
--------

* W3C website
* W3C on Wikipedia
Block
=====

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

Block (CSS)
A **block** on a webpage is an HTML element that appears on a new line, i.e. underneath the preceding element in a horizontal writing mode, and above the following element (commonly known as a *block-level element*). For example, `p` is by default a block-level element, whereas `a` is an *inline element* — you can put several links next to one another in your HTML source and they will sit on the same line as one another in the rendered output.
Block (scripting)
In JavaScript, a block is a collection of related statement enclosed in braces ("{}"). For example, you can put a block of statements after an `Statements/if...else` block, indicating that the interpreter should run the code inside the block if the condition is true, or skip the whole block if the condition is false.
Smoke Test
==========

A smoke test consists of functional or unit tests of critical software functionality. Smoke testing comes before further, in-depth testing.

Smoke testing answers questions like

* "Does the program start up correctly?"
* "Do the main control buttons function?"
* "Can you save a simple blank new test user account?"

If this basic functionality fails, there is no point investing time in more detailed QA work at this stage.

See also
--------

* Smoke testing (software) on Wikipedia
Hypertext
=========

Hypertext is text that contains links to other texts, as opposed to a single linear flow like in a novel.

The term was coined by Ted Nelson around 1965.

See also
--------

* Hypertext on Wikipedia
HTTP header
===========

An **HTTP header** is a field of an HTTP request or response that passes additional context and metadata about the request or response. For example, a request message can use headers to indicate it's preferred media formats, while a response can use header to indicate the media format of the returned body. Headers are case-insensitive, begin at the start of a line and are immediately followed by a `':'` and a header-dependent value. The value finishes at the next CRLF or at the end of the message.

The HTTP and Fetch specifications refer to a number of header categories, including:

* Request header: Headers containing more information about the resource to be fetched or about the client itself.
* Response header: Headers with additional information about the response, like its location or about the server itself (name, version, …).
* Representation header: metadata about the resource in the message body (e.g. encoding, media type, etc.).
* Fetch metadata request header: Headers with metadata about the resource in the message body (e.g. encoding, media type, etc.).

A basic request with one header:


```http
GET /example.html HTTP/1.1
Host: example.com
```


Redirects have mandatory headers (`Location`):


```http
302 Found
Location: /NewPage.html
```


A typical set of headers:


```http
304 Not Modified
Access-Control-Allow-Origin: \*
Age: 2318192
Cache-Control: public, max-age=315360000
Connection: keep-alive
Date: Mon, 18 Jul 2016 16:06:00 GMT
Server: Apache
Vary: Accept-Encoding
Via: 1.1 3dc30c7222755f86e824b93feb8b5b8c.cloudfront.net (CloudFront)
X-Amz-Cf-Id: TOl0FEm6uI4fgLdrKJx0Vao5hpkKGZULYN2TWD2gAWLtr7vlNjTvZw==
X-Backend-Server: developer6.webapp.scl3.mozilla.com
X-Cache: Hit from cloudfront
X-Cache-Info: cached
```


**Note:** Older versions of the specification referred to:

* General header: Headers applying to both requests and responses but with no relation to the data eventually transmitted in the body.
* Entity header: Headers containing more information about the body of the entity, like its content length or its MIME-type (this is a superset of what are now referred to as the Representation metadata headers)

See also
--------

* List of all HTTP headers
* Syntax of headers in the HTTP specification
* Glossary
    + HTTP header
    + Request header
    + Response header
    + Representation header
    + Fetch metadata request header
    + Forbidden header name
    + Forbidden response header name
    + CORS-safelisted request header
    + CORS-safelisted response header
Local variable
==============

A variable whose name is bound to its value only within a local scope.

Example
-------


```js
let global = 5; // A global variable

function fun() {
  let local = 10; // A local variable
}
```

See also
--------

* Local variable on Wikipedia
XHTML
=====

**XHTML** is a term that was historically used to describe HTML documents written to conform with XML syntax rules.

The following example shows an HTML document and corresponding "XHTML" document, and the accompanying HTTP `Content-Type` headers they should be served with.

### HTML document


```html
<!-- Content-Type: text/html -->

<!doctype html>
<html lang="en-US">
  <head>
    <meta charset="utf-8" />
    <title>HTML</title>
  </head>
  <body>
    <p>I am a HTML document</p>
  </body>
</html>
```

### XHTML document


```xml
<!-- Content-Type: application/xhtml+xml -->

<?xml version="1.0" encoding="UTF-8"?>
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US">
  <head>
    <title>XHTML</title>
  </head>
  <body>
    <p>I am a XHTML document</p>
  </body>
</html>
```


In practice, very few "XHTML" documents are served over the web with a `Content-Type: application/xhtml+xml` header. Instead, even though the documents are written to conform to XML syntax rules, they are served with a `Content-Type: text/html` header — so browsers parse those documents using HTML parsers rather than XML parsers.

See also
--------

* HTML
* HTML5
* SVG
* MathML
* XML
API
===

An API (Application Programming Interface) is a set of features and rules that exist inside a software program (the application) enabling interaction with it through software - as opposed to a human user interface. The API can be seen as a simple contract (the interface) between the application offering it and other items, such as third-party software or hardware.

In Web development, an API is generally a set of code features (e.g. methods, properties, events, and URLs) that a developer can use in their apps for interacting with components of a user's web browser, other software/hardware on the user's computer, or third-party websites and services.

For example:

* The getUserMedia API can be used to grab audio and video from a user's webcam, which is then available to the developer, for example, recording video and audio, broadcasting it to another user in a conference call, or capturing image stills from the video.
* The Geolocation API can be used to retrieve location information from services the user has available on their device (e.g. GPS), which can then be used in conjunction with other services, such as the Google Maps APIs, to plot the user's location on a custom map and show them what tourist attractions are in their area.
* The Web Animations API can be used to animate parts of a web page — for example, to programmatically move or rotate images.
See also
--------

* Web API reference
* API on Wikipedia
Compile time
============

The *compile time* is the time from when the program is first loaded until the program is parsed.

See also
--------

* Compile time on Wikipedia
Repo
====

In a revision control system like Git or SVN, a repo (i.e. "repository") is a place that hosts an application's code source, together with various metadata.

See also
--------

* Repository on Wikipedia
Primitive
=========

In JavaScript, a **primitive** (primitive value, primitive data type) is data that is not an object and has no methods or properties. There are 7 primitive data types:

* string
* number
* bigint
* boolean
* undefined
* symbol
* null

Most of the time, a primitive value is represented directly at the lowest level of the language implementation.

All primitives are *immutable*; that is, they cannot be altered. It is important not to confuse a primitive itself with a variable assigned a primitive value. The variable may be reassigned to a new value, but the existing value can not be changed in the ways that objects, arrays, and functions can be altered. The language does not offer utilities to mutate primitive values.

Primitives have no methods but still behave as if they do. When properties are accessed on primitives, JavaScript *auto-boxes* the value into a wrapper object and accesses the property on that object instead. For example, `"foo".includes("f")` implicitly creates a `String` wrapper object and calls `String.prototype.includes()` on that object. This auto-boxing behavior is not observable in JavaScript code but is a good mental model of various behaviors — for example, why "mutating" primitives does not work (because `str.foo = 1` is not assigning to the property `foo` of `str` itself, but to an ephemeral wrapper object).

See also
--------

* JavaScript data types
* Primitive data type (Wikipedia)
* Glossary
    + JavaScript
    + string
    + number
    + bigint
    + boolean
    + null
    + undefined
    + symbol
Response header
===============

A **response header** is an HTTP header that can be used in an HTTP response and that doesn't relate to the content of the message. Response headers, like `Age`, `Location` or `Server` are used to give a more detailed context of the response.

Not all headers appearing in a response are categorized as *response headers* by the specification. For example, the `Content-Type` header is a representation header indicating the original type of data in the body of the response message (prior to the encoding in the `Content-Encoding` representation header being applied). However, "conversationally" all headers are usually referred to as response headers in a response message.

The following shows a few response and representation headers after a `GET` request.


```http
200 OK
Access-Control-Allow-Origin: \*
Connection: Keep-Alive
Content-Encoding: gzip
Content-Type: text/html; charset=utf-8
Date: Mon, 18 Jul 2016 16:06:00 GMT
Etag: "c561c68d0ba92bbeb8b0f612a9199f722e3a621a"
Keep-Alive: timeout=5, max=997
Last-Modified: Mon, 18 Jul 2016 02:36:04 GMT
Server: Apache
Set-Cookie: mykey=myvalue; expires=Mon, 17-Jul-2017 16:06:00 GMT; Max-Age=31449600; Path=/; secure
Transfer-Encoding: chunked
Vary: Cookie, Accept-Encoding
X-Backend-Server: developer2.webapp.scl3.mozilla.com
X-Cache-Info: not cacheable; meta data too large
X-kuma-revision: 1085259
x-frame-options: DENY
```

See also
--------

* List of all HTTP headers
* Glossary
    + Representation header
    + HTTP header
    + Response header
    + Fetch metadata response header
    + Request header
Stylesheet
==========

A **stylesheet** is a set of CSS rules used to control the layout and design of a webpage or document. *Internal* stylesheets are placed inside a `<style>` element inside the `<head>` of a web document, and *external* stylesheets are placed inside a separate `.css` file, which is applied to a document by referencing the file inside a `<link>` element in the document's head.

External stylesheets are generally preferred because they allow you to control the styling of multiple pages from a single place, rather than having to repeat the CSS across each page.

See also
--------

* CSS first steps
* Stylesheets on Wikipedia
Global object
=============

A global object is an object that always exists in the global scope.

In JavaScript, there's always a global object defined. In a web browser, when scripts create global variables defined with the `var` keyword, they're created as members of the global object. (In Node.js this is not the case.) The global object's interface depends on the execution context in which the script is running. For example:

* In a web browser, any code which the script doesn't specifically start up as a background task has a `Window` as its global object. This is the vast majority of JavaScript code on the Web.
* Code running in a `Worker` has a `WorkerGlobalScope` object as its global object.
* Scripts running under Node.js have an object called `global` as their global object.

The `globalThis` global property allows one to access the global object regardless of the current environment.

`var` statements and function declarations at the top level create properties of the global object. On the other hand, `let` and `const` declarations never create properties of the global object.

The properties of the global object are automatically added to the global scope.

In JavaScript, the global object always holds a reference to itself:


```js
console.log(globalThis === globalThis.globalThis); // true (everywhere)
console.log(window === window.window); // true (in a browser)
console.log(self === self.self); // true (in a browser or a Web Worker)
console.log(frames === frames.frames); // true (in a browser)
console.log(global === global.global); // true (in Node.js)
```

See also
--------

* MDN Web Docs Glossary
    + global scope
    + object
* `Window`
* `WorkerGlobalScope`
* `global`
GPU
===

The GPU (Graphics Processing Unit) is a computer component similar to the CPU (Central Processing Unit). It specializes in the drawing of graphics (both 2D and 3D) on your monitor.
The Khronos Group
=================

**The Khronos Group** is an open, non-profit, member-driven consortium of over 150 industry-leading companies. Their purpose is to create advanced, royalty-free interoperability standards for 3D graphics, augmented and virtual reality, parallel programming, vision acceleration, and machine learning.

The organization maintains standards such as OpenGL and the `WebGL API`.

See also
--------

* The Khronos Group on Wikipedia
* The Khronos Group website
Node.js
=======

Node.js is a cross-platform JavaScript runtime environment that allows developers to build server-side and network applications with JavaScript.

Node Package Manager (npm)
--------------------------

npm is a package manager that is downloaded and bundled alongside Node.js. Its command-line (CLI) client `npm` can be used to download, configure and create packages for use in Node.js projects. Downloaded packages can be imported by ES imports and CommonJS `require()` without including the dependency directory `node_modules/` they are downloaded to, as Node.js resolves packages without a relative or absolute path specified in their import.

Packages hosted on npm are downloaded from the registry at https://registry.npmjs.org/, but the CLI can be configured to use any compatible instance.

See also
--------

* Node.js on Wikipedia
* Node.js website
* API reference documentation
* Guides
* npm Documentation
Scroll chaining
===============

**Scroll chaining** refers to the behavior observed when a user scrolls past the Scroll boundary of a scrollable element, causing scrolling on an ancestor element.

When a user scrolls within a scrollable element such as a `<div>` or `<textarea>` and the scrollport boundary (top, bottom, left or right) of the scrollable element is reached, there may be a "chained effect" in which the scroll action is seamlessly propagated to the parent element. This behavior creates a continuous scrolling experience, both vertically and horizontally.

A **scroll chain** is the order of scrollable elements where the scrolling action passes from one element to another. This happens when an inner element is scrolled to its limit, and the scrolling continues to its parent element, creating a 'chain' of scrolling actions. Chaining typically recurses up the containing block.

See also
--------

* `overscroll-behavior` CSS property
* CSS overflow module
* CSS overscroll behavior module
* CSS scroll snap module
Deserialization
===============

The process whereby a lower-level format (e.g. that has been transferred over a network, or stored in a data store) is translated into a readable object or other data structure.

In JavaScript, for example, you can deserialize a JSON string to an object by calling the function `JSON.parse()`.

See also
--------

* Serialization on Wikipedia
Rsync
=====

Rsync is an open-source file synchronizing tool that provides incremental file transfer. It can be used over insecure and secure transports (like SSH). It is available on most Unix-based systems (such as macOS and Linux) and Windows. There are also GUI-based tools that use rsync, for example, Acrosync.

A basic command looks like this:


```bash
rsync [-options] SOURCE user@x.x.x.x:DESTINATION
```


* `-options` is a dash followed by one or more letters, for example `-v` for verbose error messages, and `-b` to make backups. See the full list of options at the rsync man page. (Search for "Options summary.")
* `SOURCE` is the path to the local file or directory that you want to copy or synchronize
* `user@` is the credentials of the user on the remote server you want to copy files over to.
* `x.x.x.x` is the IP address of the remote server.
* `DESTINATION` is the path to the location you want to copy your directory or files to on the remote server.

You can also make a connection over SSH using the `-e` option as shown:


```bash
rsync [-options] -e "ssh [SSH DETAILS GO HERE]" SOURCE user@x.x.x.x:DESTINATION
```


There are numerous examples on the Internet, including those at the official website, and at the Wikipedia entry for rsync.