recursal/MDN huggingface dataset:
Compile
=======

**Compiling** is the process of transforming a computer program written in a given language into a set of instructions in another format or language. A **compiler** is a computer program to execute that task.

Typically, a compiler transforms code written in a higher-level language such as C++ or Rust or Java into executable (runnable) code — so-called **binary code** or **machine code**. WebAssembly, for example, is a form of executable binary code that can be compiled from code written in C++, Rust, C#, Go, Swift, and several other languages and that can then be run on any web page, in any browser.

Most compilers perform either ahead-of-time (AOT) compilation or just-in-time (JIT) compilation.

The GNU `gcc` compiler is one well-known example of an AOT compiler. AOT compilers are typically invoked from the command line in a shell environment (from within a terminal or console) or within an IDE.

JIT compilers are typically not invoked directly but are instead built into software runtimes internally, for the purpose of improving performance. For example, all major browsers now use JavaScript engines that have built-in JIT compilers.

Compilers may also translate among higher-level languages — for example, from TypeScript to JavaScript — in which case, they are often sometimes referred to as **transpilers**.

See also
--------

* Compiling from C/C++ to WebAssembly
* Compiling from Rust to WebAssembly
* Wikipedia: Compiler
Type conversion
===============

Type conversion (or typecasting) means transfer of data from one data type to another. *Implicit conversion* happens when the compiler (for compiled languages) or runtime (for script languages like JavaScript) automatically converts data types. The source code can also *explicitly* require a conversion to take place.

For example, given the expression `"foo" + 1`, the Number `1` is implicitly converted into a String and the expression returns `"foo1"`. Given the instruction `Number("0x11")`, the string `"0x11"` is explicitly converted to the number `17`.

See also
--------

* Type conversion (Wikipedia)
* Glossary
    + Type
    + Type coercion
HSTS
====

**HTTP Strict Transport Security** lets a website inform the browser that it should never load the site using HTTP and should automatically convert all attempts to access the site using HTTP to HTTPS requests instead. It consists in one HTTP header, `Strict-Transport-Security`, sent by the server with the resource.

In other words, it tells the browser that changing the protocol from HTTP to HTTPS in a URL works (and is more secure) and asks the browser to do it for every request.

See also
--------

* `Strict-Transport-Security`
* OWASP Article: HTTP Strict Transport Security
* Wikipedia: HTTP Strict Transport Security
Firewall
========

A **firewall** is a system that filters network traffic. It can either let it pass or block it, according to some specified rules. For example, it can block incoming connections aimed at a certain port or outgoing connections to a certain IP address.

Firewalls can be as simple as a single piece of software, or more complex, like a dedicated machine whose only function is to act as a firewall.

See also
--------

* Firewall (computing) on Wikipedia
Page load time
==============

**Page load time** is the time it takes for a page to load, measured from navigation start to the start of the load event.


```js
let time = performance.timing;

let pageloadtime = time.loadEventStart - time.navigationStart;
```


While page load time 'sounds' like the perfect web performance metric, it isn't. Load times can vary greatly between users depending on device capabilities, network conditions, and, to a lesser extent, distance from the server. The development environment, where page load time is measured, is likely an optimal experience, not reflective of your users' reality. In addition, web performance isn't just about when the load event happens. It's also about perceived performance, responsiveness, jank and jitter.

See also
--------

* Navigation and resource timing
* `PerformanceNavigationTiming`
* `PerformanceResourceTiming`,
Glyph
=====

A **glyph** is a term used in typography for the visual representation of one or more characters.

The fonts used by a website contain different sets of glyphs, which represent the characters of the font.

See also
--------

* Glyph on Wikipedia
* Glyph, character and grapheme on Quora
Entity header
=============

**Warning:** The current HTTP/1.1 specification no longer refers to entities, entity headers or entity-body. Some of the fields are now referred to as Representation header fields.

An entity header is an HTTP header that describes the payload of an HTTP message (i.e. metadata about the message body). Entity headers include: `Content-Length`, `Content-Language`, `Content-Encoding`, `Content-Type`, `Expires`, etc. Entity headers may be present in both HTTP request and response messages.

In the following example, `Content-Length` is an entity header, while `Host` and `User-Agent` are requests headers:


```http
POST /myform.html HTTP/1.1
Host: developer.mozilla.org
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.9; rv:50.0) Gecko/20100101 Firefox/50.0
Content-Length: 128
```

See also
--------

* Representation header
Grid Tracks
===========

A **grid track** is the space between two adjacent grid lines. They are defined in the *explicit grid* by using the `grid-template-columns` and `grid-template-rows` properties or the shorthand `grid` or `grid-template` properties. Tracks are also created in the *implicit grid* by positioning a grid item outside of the tracks created in the explicit grid.

The image below shows the first row track on a grid.

![Diagram showing a grid track.](/en-US/docs/Glossary/Grid_Tracks/1_grid_track.png)

Track sizing in the explicit grid
---------------------------------

When defining grid tracks using `grid-template-columns` and `grid-template-rows` you may use any length unit, and also the flex unit, `fr` which indicates a portion of the available space in the grid container.

Example
-------

The example below demonstrates a grid with three column tracks, one of 200 pixels, the second of 1fr, the third of 3fr. Once the 200 pixels has been subtracted from the space available in the grid container, the remaining space is divided by 4. One part is given to column 2, 3 parts to column 3.
```

\* {
  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: 200px 1fr 3fr;
}
```



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

Track sizing in the implicit grid
---------------------------------

Tracks created in the implicit grid are auto-sized by default, however you can define a size for these tracks using the `grid-auto-rows` and `grid-auto-columns` properties.

See also
--------

* Basic concepts of grid layout
* Definition of Grid Tracks in the CSS Grid Layout specification
* Property reference
    + `grid-template-columns`
    + `grid-template-rows`
    + `grid`
    + `grid-template`
CMS
===

A CMS (Content Management System) is software that allows users to publish, organize, change, or remove various kinds of content, not only text but also embedded images, video, audio, and interactive code.

See also
--------

* Content management system on Wikipedia
WindowProxy
===========

A **`WindowProxy`** object is a wrapper for a `Window` object. A `WindowProxy` object exists in every browsing context. All operations performed on a `WindowProxy` object will also be applied to the underlying `Window` object it currently wraps. Therefore, interacting with a `WindowProxy` object is almost identical to directly interacting with a `Window` object. When a browsing context is navigated, the `Window` object its `WindowProxy` wraps is changed.

See also
--------

* HTML specification: WindowProxy section
* Stack Overflow question: WindowProxy and Window objects?
XML
===

eXtensible Markup Language (XML) is a generic markup language specified by the W3C. The information technology (IT) industry uses many languages based on XML as data-description languages.

XML tags resemble HTML tags, but XML is much more flexible because it lets users define their own tags. In this way XML acts like a meta-language—that is, it can be used to define other languages, such as RSS. Moreover, HTML is a presentation language, whereas XML is a data-description language. This means that XML has far broader applications than just the Web. For example, Web services can use XML to exchange requests and responses.

See also
--------

* XML introduction
HTTP/2
======

**HTTP/2** is a major revision of the HTTP network protocol.

The primary goals for HTTP/2 are to reduce latency by enabling full request and response multiplexing, minimize protocol overhead via efficient compression of HTTP header fields, and add support for request prioritization and server push.

HTTP/2 does not modify the application semantics of HTTP in any way. All the core concepts found in HTTP 1.1, such as HTTP methods, status codes, URIs, and header fields, remain in place. Instead, HTTP/2 modifies how the data is formatted (framed) and transported between the client and server, both of which manage the entire process, and hides application complexity within the new framing layer. As a result, all existing applications can be delivered without modification.

See also
--------

* HTTP on MDN
* HTTP/2 on Wikipedia
* Glossary
    + HTTP
    + Latency
WebSockets
==========

*WebSocket* is a protocol that allows for a persistent TCP connection between server and client so they can exchange data at any time.

Any client or server application can use WebSocket, but principally web browsers and web servers. Through WebSocket, servers can pass data to a client without prior client request, allowing for dynamic content updates.

See also
--------

* Websocket on Wikipedia
* WebSocket reference on MDN
* Writing WebSocket client applications
* Writing WebSocket servers
Origin
======

Web content's **origin** is defined by the *scheme* (protocol), *hostname* (domain), and *port* of the URL used to access it. Two objects have the same origin only when the scheme, hostname, and port all match.

Some operations are restricted to same-origin content, and this restriction can be lifted using CORS.

Examples
--------

These are same origin because they have the same scheme (`http`) and hostname (`example.com`), and the different file path does not matter:

* `http://example.com/app1/index.html`
* `http://example.com/app2/index.html`

These are same origin because a server delivers HTTP content through port 80 by default:

* `http://example.com:80`
* `http://example.com`

These are not same origin because they use different schemes:

* `http://example.com/app1`
* `https://example.com/app2`

These are not same origin because they use different hostnames:

* `http://example.com`
* `http://www.example.com`
* `http://myapp.example.com`

These are not same origin because they use different ports:

* `http://example.com`
* `http://example.com:8080`
See also
--------

* Same-origin policy
* Site
* HTML specification: origin
Code unit
=========

A **code unit** is the basic component used by a character encoding system (such as UTF-8 or UTF-16). A character encoding system uses one or more code units to encode a Unicode code point.

In UTF-16 (the encoding system used for JavaScript strings) code units are 16-bit values. This means that operations such as indexing into a string or getting the length of a string operate on these 16-bit units. These units do not always map 1-1 onto what we might consider characters.

For example, characters with diacritics such as accents can sometimes be represented using two Unicode code points:


```js
const myString = "\u006E\u0303";
console.log(myString); // ñ
console.log(myString.length); // 2
```


Also, since not all of the code points defined by Unicode fit into 16 bits, many Unicode code points are encoded as a pair of UTF-16 code units, which is called a *surrogate pair*:


```js
const face = "🥵";
console.log(face.length); // 2
```


The `codePointAt()` method of the JavaScript `String` object enables you to retrieve the Unicode code point from its encoded form:


```js
const face = "🥵";
console.log(face.codePointAt(0)); // 129397
```

See also
--------

* Unicode encoding FAQ
Latency
=======

**Latency** is the network time it takes for a requested resource to reach its destination. Low latency is good, meaning there is little or no delay. High latency is bad, meaning it takes a long time for the requested resource to reach its destination.

Latency can be a factor in any kind of data flow, but is most commonly discussed in terms of network latency (the time it takes for a packet of data to travel from source to destination) and media codec latency (the time it takes for the source data to be encoded or decoded and reach the consumer of the resulting data).

See also
--------

* Understanding Latency
ISO
===

**ISO** (International Organization for Standardization) is a global association that develops uniform criteria coordinating the companies in each major industry.

See also
--------

* Official website
WebRTC
======

**WebRTC** (*Web Real-Time Communication*) is an API that can be used by video-chat, voice-calling, and P2P-file-sharing Web apps.

WebRTC consists mainly of these parts:

`getUserMedia()`

Grants access to a device's camera and/or microphone, and can plug in their signals to a RTC connection.

`RTCPeerConnection`

An interface to configure video chat or voice calls.

`RTCDataChannel`

Provides a method to set up a peer-to-peer data pathway between browsers.

See also
--------

* WebRTC on Wikipedia
* WebRTC API on MDN
* Browser support for WebRTC
IRC
===

**IRC** (*Internet Relay Chat*) is a worldwide chat system requiring an Internet connection and an IRC client, which sends and receives messages via the IRC server.

Designed in the late 1980s by Jarrko Oikarinen, IRC uses TCP and is an open protocol. The IRC server broadcasts messages to everyone connected to one of many IRC channels (each with their own ID).
Constant
========

A constant is a value that the programmer cannot change, for example numbers (1, 2, 42). With variables, on the other hand, the programmer can assign a new value to a variable name already in use.

Like variables, some constants are bound to identifiers. For example, the identifier `pi` could be bound to the value 3.14… .

See also
--------

* Constant on Wikipedia
Payload body
============

The HTTP message **payload body** is the *information* ("payload") part of the data that is sent in the HTTP Message Body (if any), prior to `transfer encoding` being applied. If transfer encoding is not used, the *payload body* and *message body* are the same!

For example, in this response the message body contains only the payload body: "Mozilla Developer Network":


```http
HTTP/1.1 200 OK
Content-Type: text/plain

Mozilla Developer Network
```


By contrast, the below response uses *transfer encoding* to encode the payload body into chunks. The payload body (information) sent is still "Mozilla Developer Network", but the message body includes additional data to separate the chunks:


```http
HTTP/1.1 200 OK
Content-Type: text/plain
Transfer-Encoding: chunked

7\r\n
Mozilla\r\n
9\r\n
Developer\r\n
7\r\n
Network\r\n
0\r\n
\r\n
```


For more information see RFC 7230, section 3.3: Message Body and RFC 7230, section 3.3.1: Transfer-Encoding.
Hoisting
========

JavaScript **Hoisting** refers to the process whereby the interpreter appears to move the *declaration* of functions, variables, classes, or imports to the top of their scope, prior to execution of the code.

*Hoisting* is not a term normatively defined in the ECMAScript specification. The spec does define a group of declarations as *HoistableDeclaration*, but this only includes `function`, `function*`, `async function`, and `async function*` declarations. Hoisting is often considered a feature of `var` declarations as well, although in a different way. In colloquial terms, any of the following behaviors may be regarded as hoisting:

1. Being able to use a variable's value in its scope before the line it is declared. ("Value hoisting")
2. Being able to reference a variable in its scope before the line it is declared, without throwing a `ReferenceError`, but the value is always `undefined`. ("Declaration hoisting")
3. The declaration of the variable causes behavior changes in its scope before the line in which it is declared.
4. The side effects of a declaration are produced before evaluating the rest of the code that contains it.

The four function declarations above are hoisted with type 1 behavior; `var` declaration is hoisted with type 2 behavior; `let`, `const`, and `class` declarations (also collectively called *lexical declarations*) are hoisted with type 3 behavior; `import` declarations are hoisted with type 1 and type 4 behavior.

Some prefer to see `let`, `const`, and `class` as non-hoisting, because the temporal dead zone strictly forbids any use of the variable before its declaration. This dissent is fine, since hoisting is not a universally-agreed term. However, the temporal dead zone can cause other observable changes in its scope, which suggests there's some form of hoisting:


```js
const x = 1;
{
  console.log(x); // ReferenceError
  const x = 2;
}
```


If the `const x = 2` declaration is not hoisted at all (as in, it only comes into effect when it's executed), then the `console.log(x)` statement should be able to read the `x` value from the upper scope. However, because the `const` declaration still "taints" the entire scope it's defined in, the `console.log(x)` statement reads the `x` from the `const x = 2` declaration instead, which is not yet initialized, and throws a `ReferenceError`. Still, it may be more useful to characterize lexical declarations as non-hoisting, because from a utilitarian perspective, the hoisting of these declarations doesn't bring any meaningful features.

Note that the following is not a form of hoisting:


```js
{
  var x = 1;
}
console.log(x); // 1
```


There's no "access before declaration" here; it's simply because `var` declarations are not scoped to blocks.

For more information on hoisting, see:

* `var`/`let`/`const` hoisting — Grammar and types guide
* `function` hoisting — Functions guide
* `class` hoisting — Classes guide
* `import` hoisting — JavaScript modules
See also
--------

* `var` statement — MDN
* `let` statement — MDN
* `const` statement — MDN
* `function` statement — MDN
CIA
===

CIA (Confidentiality, Integrity, Availability) (also called the CIA triad or AIC triad) is a model that guides an organization's policies for information security.

See also
--------

* CIA on Wikipedia
Input method editor
===================

An Input Method Editor (IME) is a program that provides a specialized user interface for text input. Input method editors are used in many situations:

* To enter Chinese, Japanese, or Korean text using a Latin keyboard.
* To enter Latin text using a numeric keypad.
* To enter text on a touch screen using handwriting recognition.
See also
--------

* Input method
* Internationalization (I18N)
Snake case
==========

**Snake case** is a way of writing phrases without spaces, where spaces are replaced with underscores `_`, and the words are typically all lower case. It's often stylized as "snake\_case" to remind the reader of its appearance.

Snake casing is often used as a variable naming convention. The following names are in snake case: `left_shift`, `bitwise_invert`, `matrix_transpose`.

Note that snake case never contains upper case letters. Sometimes, constants are written in all-uppercase, such as JavaScript's `Number.MAX_SAFE_INTEGER`. This is not typically considered as snake case. Instead, it is sometimes called *screaming snake case*.

Snake case is the most popular convention in Python, Rust, and various other languages.

See also
--------

* Camel case
* Kebab case
* typescript-eslint rule: `naming-convention`
Firefox OS
==========

Firefox OS is a discontinued open source mobile operating system developed by Mozilla. See Firefox OS for more details.

Firefox OS was also often called Boot2Gecko before the project had an official name.
CORS
====

**CORS** (Cross-Origin Resource Sharing) is a system, consisting of transmitting HTTP headers, that determines whether browsers block frontend JavaScript code from accessing responses for cross-origin requests.

The same-origin security policy forbids cross-origin access to resources. But CORS gives web servers the ability to say they want to opt into allowing cross-origin access to their resources.

CORS headers
------------

`Access-Control-Allow-Origin`

Indicates whether the response can be shared.

`Access-Control-Allow-Credentials`

Indicates whether or not the response to the request can be exposed when the credentials flag is true.

`Access-Control-Allow-Headers`

Used in response to a preflight request to indicate which HTTP headers can be used when making the actual request.

`Access-Control-Allow-Methods`

Specifies the method or methods allowed when accessing the resource in response to a preflight request.

`Access-Control-Expose-Headers`

Indicates which headers can be exposed as part of the response by listing their names.

`Access-Control-Max-Age`

Indicates how long the results of a preflight request can be cached.

`Access-Control-Request-Headers`

Used when issuing a preflight request to let the server know which HTTP headers will be used when the actual request is made.

`Access-Control-Request-Method`

Used when issuing a preflight request to let the server know which HTTP method will be used when the actual request is made.

`Origin`

Indicates where a fetch originates from.

`Timing-Allow-Origin`

Specifies origins that are allowed to see values of attributes retrieved via features of the Resource Timing API, which would otherwise be reported as zero due to cross-origin restrictions.

See also
--------

* Cross-Origin Resource Sharing (CORS) on MDN
* Cross-origin resource sharing on Wikipedia
* Fetch specification
ICANN
=====

**ICANN** (Internet Corporation for Assigned Names and Numbers) is an international nonprofit that maintains the domain name system and the record of IP addresses.

See also
--------

* Official website
* ICANN on Wikipedia
Keyword
=======

A **keyword** is a word or phrase that describes content. Online keywords are used as queries for search engines or as words identifying content on websites.

When you use a search engine, you use keywords to specify what you are looking for, and the search engine returns relevant webpages. For more accurate results, try more specific keywords, such as "Blue Mustang GTO" instead of "Mustang". Webpages also use keywords in a meta tag (in the `<head>` section) to describe page content, so search engines can better identify and organize webpages.

See also
--------

* Keyword on Wikipedia