recursal/MDN huggingface dataset:
NaN
===

NaN (Not a Number) is a numeric data type that means an undefined value or value that cannot be represented, especially results of floating-point calculations.

For example, NaNs can represent infinity, result of division by zero, missing value, or the square root of a negative (which is imaginary, whereas a floating-point number is real).

Practically speaking, if I divide two variables in a JavaScript program, the result may be NaN, which is predefined in JavaScript as "undefined". Hence this division may break the program. Now, if this computation was a small part of a much larger algorithm, it would be really painful to figure out where the error actually occurs. Fortunately, since the result will be NaN and I know my divisor may turn out to be 0, I can set up testing conditions that prevent any such computations in the first place or notify me of where they happen.

See also
--------

* NaN on Wikipedia
* NaN in JavaScript
Enumerated
==========

In computer science, an **enumerated** type is a data type consisting of a limited set of named values.

HTML enumerated attributes
--------------------------

In HTML, enumerated attributes are attributes with a limited, predefined set of text values. For example, the global HTML `dir` attribute has three valid values: `ltr`, `rtl`, and `auto`.

Each enumerated attribute has a default value for when the attribute is present without a value (the value is missing), and a default value for when the attribute is assigned an invalid value. Unlike Boolean HTML attributes — which are always true when the attribute is present whether the value is present, omitted, or invalid — with enumerated HTML attributes, the default for an omitted value may be different from the default for invalid values. For example, the global HTML `contenteditable` attribute has two valid keywords: `true` and `false`. If the attribute is present but no value is set, the value is `true`. If a value is set, but is invalid, such as `contenteditable="contenteditable"`, the value maps to a third state, `inherit`.

ARIA enumerated attributes
--------------------------

ARIA states and properties, being HTML, also have enumerated attributes. If an ARIA attribute includes a both a `true` and `false` value in the enumerated list, it generally treats an omitted attribute as `false` and an invalid value as `true`, while the default value for the empty string or omitted value depends on the attribute.

For example, the `aria-current` attribute accepts a limited list of values that includes `page`, `step`, `location`, `date`, `time`, `true`, and `false`. In this case, if the attribute is not present, is an empty string, is present with no value, or is set to `aria-current="false"` the attribute is false and is not exposed to the user. Any non-empty string value not in the list of enumerated values is treated as if `aria-current="true"` were set.

JavaScript enumerable properties
--------------------------------

In JavaScript, enumerable properties are those properties whose internal enumerable flag is set to true, which is the default for properties created via simple assignment or via a property initializer. Most iteration mechanisms (such as `for...in` loops and `Object.keys`) only visit enumerable keys.

See also
--------

* Boolean
* JavaScript data types and data structures
* enumerated attributes in the HTML Standard
Jank
====

**Jank** refers to sluggishness in a user interface, usually caused by executing long tasks on the main thread, blocking rendering, or expending too much processor power on background processes.
Database
========

A **database** is a storing system that collects organized data, to make some works easier like searching, structure, and extend.

In web development, most databases use the relational database management system (RDBMS) to organize data and programming in SQL. Some databases, however, don't follow the former mechanism to organized data, which called NoSQL.

Some famous server-side RDBMS are *MySQL*(or *MariaDB* which is a fork of it), *SQL Server*, and *Oracle Database*. On the other hand, some famous NoSQL examples are *MongoDB*, *Cassandra*, and *Redis*.

Browsers also have their own database system called IndexedDB.

See also
--------

* Database on Wikipedia
* Glossary
    + IndexedDB
    + SQL
First CPU idle
==============

**First CPU Idle** measures when a page is minimally interactive, or when the window is quiet enough to handle user input. It is a non-standard Google web performance metric. Generally, it occurs when most, but not necessarily all visible UI elements are interactive, and the user interface responds, on average, to most user input within 50ms.

See also
--------

* Metrics which replaced First CPU Idle:
    + Time to interactive
    + Total blocking time
SCTP
====

**SCTP** (Stream Control Transmission Protocol) is an IETF standard for a transport protocol which enables the reliable, in-order transmission of messages while offering congestion control, multi-homing, and other features to improve reliability and stability of the connection. It's used for sending traditional telephone calls over the Internet, but is also used for WebRTC data.

See also
--------

* RFC 4960: Stream Control Transmission Protocol
* Stream Control Transmission Protocol on Wikipedia
Page prediction
===============

**Page Prediction** is a browser feature or script which, when enabled, tells the browser to download resources the user is likely to visit before the user requests the content. Page prediction improves performance by enabling almost instant loading of predicted content. However, page prediction may also download content a user does not seek.

Some web applications include a prediction feature completing search text and address bar URLs based on browsing history and related searches. For example, as the user types in the address bar, the browser might send the current text in the address bar to the search engine before the user submits the request.

Although browser page prediction and prediction services enable faster page loads, they consume additional bandwidth. Also, pre-loaded websites and embedded content can set and read their cookies as if they were visited even if they weren't.

See also
--------

* prerender
* prefetch
SMPTE (Society of Motion Picture and Television Engineers)
==========================================================

The **Society of Motion Picture and Television Engineers** (**SMPTE**) is the professional association of engineers and scientists that develop and define standards and technologies used to create, broadcast, store, and present entertainment media.

For example, SMPTE defines the standards used for digital cinema used by modern digital movie theaters.
CDN
===

A **CDN** (Content Delivery Network) is a group of servers spread out over many locations. These servers store duplicate copies of data so that servers can fulfill data requests based on which servers are closest to the respective end-users. CDNs make for fast service less affected by high traffic.

CDNs are used widely for delivering stylesheets and JavaScript files (static assets) of libraries like Bootstrap, jQuery etc. Using CDN for those library files is preferable for a number of reasons:

* Serving libraries' static assets over CDN lowers the request burden on an organization's own servers.
* Most CDNs have servers all over the globe, so CDN servers may be geographically nearer to your users than your own servers. Geographical distance affects latency proportionally.
* CDNs are already configured with proper cache settings. Using a CDN saves further configuration for static assets on your own servers.
CORS-safelisted response header
===============================

A *CORS-safelisted response header* is an HTTP header in a CORS response that it is considered *safe* to expose to client scripts. Only safelisted response headers are made available to web pages.

By default, the safelist includes the following response headers:

* `Cache-Control`
* `Content-Language`
* `Content-Length`
* `Content-Type`
* `Expires`
* `Last-Modified`
* `Pragma`

Additional headers can be added to the safelist using `Access-Control-Expose-Headers`.

**Note:** `Content-Length` was not part of the original set of safelisted response headers [ref]

Examples
--------

### Extending the safelist

You can extend the list of CORS-safelisted response headers by using the `Access-Control-Expose-Headers` header:


```http
Access-Control-Expose-Headers: X-Custom-Header, Content-Encoding
```

See also
--------

* HTTP
* HTTP headers
* `Access-Control-Expose-Headers`
* Glossary
    + CORS
    + CORS-safelisted request header
    + Forbidden header name
    + Request header
DTLS (Datagram Transport Layer Security)
========================================

**Datagram Transport Layer Security** (**DTLS**) is a protocol used to secure datagram-based communications. It's based on the stream-focused Transport Layer Security (TLS), providing a similar level of security. As a datagram protocol, DTLS doesn't guarantee the order of message delivery, or even that messages will be delivered at all. However, DTLS gains the benefits of datagram protocols, too; in particular, the lower overhead and reduced latency.

These features are especially useful for one of the most common areas in which DTLS comes into play: WebRTC. All of the WebRTC related protocols are required to encrypt their communications using DTLS; this includes SCTP, SRTP, and STUN.

See also
--------

* Datagram Transport Layer Security on Wikipedia
* Specifications:
    + RFC 9147: The Datagram Transport Layer Security (DTLS) Protocol Version 1.3
    + RFC 6347: Datagram Transport Layer Security Version 1.2
* Related specification
    + RFC 5763: Framework for Establishing a Secure Real-time Transport Protocol (SRTP) Security Context Using DTLS
    + RFC 5764: DTLS Extension to Establish Keys for the Secure Real-time Transport Protocol (SRTP)
    + RFC 6083: DTLS for Stream Control Transmission Protocol (SCTP)
    + RFC 8261: Datagram Transport Layer Security (DTLS) Encapsulation of SCTP Packets
    + RFC 7350: Datagram Transport Layer Security (DTLS) as Transport for Session Traversal Utilities for NAT (STUN)
    + RFC 7925: TLS / DTLS Profiles for the Internet of Things
Value
=====

In the context of data or an object **wrapper** around that data, the value is the **primitive value** that the object wrapper contains. In the context of a **variable** or **property**, the value can be either a primitive or an **object reference**.

In the context of CSS property values, there are specified, computed, and actual values. The final value for every CSS property applied to every element and pseudo-element is the result of a four-step calculation: the value is determined through specification (the "specified value", then resolved into a value that is used for inheritance (the "computed value"), then converted into an absolute value if necessary (the "used value"), and finally transformed according to the limitations of the local environment (the "actual value").

For CSS data types, see CSS values and units.

See also
--------

* Primitive wrapper class on Wikipedia
Shadow tree
===========

A **shadow tree** is a hidden set of DOM nodes whose topmost node is a **shadow root**. The shadow root is the topmost node of a **shadow DOM** and not part of the regular document's DOM tree.

The shadow root is attached to another node tree through a specific DOM node referred to as its **host**. This host may be part of another shadow tree or part of the regular DOM tree. The node tree of a shadow root's host is sometimes referred to as the **light tree**.

The hidden DOM nodes of a shadow tree are generally not affected by anything applied outside the shadow tree, and vice versa. The **shadow boundary**, where the shadow DOM ends and the regular DOM begins, can be traversed, but only very intentionally:

* Scripting shadow tree nodes from outside requires the use of a special Shadow DOM API to be accessed.
* Styling a shadow tree from outside can be achieved via CSS scoping and CSS shadow parts.
See also
--------

* Using shadow DOM
* `Element.shadowRoot` and `Element.attachShadow()`
* `ShadowRoot`
* `<slot>`
* Accessibility tree
Accessibility tree
==================

The **accessibility tree** contains accessibility-related information for most HTML elements.

Browsers convert markup into an internal representation called the *DOM tree*. The DOM tree contains objects representing all the markup's elements, attributes, and text nodes. Browsers then create an accessibility tree based on the DOM tree, which is used by platform-specific Accessibility APIs to provide a representation that can be understood by assistive technologies, such as screen readers.

There are four properties in an accessibility tree object:

**name**

How can we refer to this thing? For instance, a link with the text "Read more" will have "Read more" as its name (find more on how names are computed in the Accessible Name and Description Computation spec).

**description**

How do we describe this thing, if we want to provide more description beyond the name? The description of a table could explain what kind of information the table contains.

**role**

What kind of thing is it? For example, is it a button, a nav bar, or a list of items?

**state**

Does it have a state? Examples include checked or unchecked checkbox states and collapsed or expanded states for the `<summary>` element.

Additionally, the accessibility tree often contains information on what can be done with an element: a link can be *followed*, a text input can be *typed into*, etc.

While still in draft form within the Web Incubator Community Group as of April 2022, the **Accessibility Object Model (AOM)** intends to incubate APIs that make it easier to express accessibility semantics and potentially allow read access to the computed accessibility tree.

See also
--------

* Glossary
    + Accessibility
    + ARIA
Information architecture
========================

Information architecture, as applied to web design and development, is the practice of organizing the information / content / functionality of a website so that it presents the best user experience it can, with information and services being easily usable and findable.

See also
--------

* Information architecture on Wikipedia
Type coercion
=============

Type coercion is the automatic or implicit conversion of values from one data type to another (such as strings to numbers). *Type conversion* is similar to *type coercion* because they both convert values from one data type to another with one key difference — *type coercion* is implicit whereas *type conversion* can be either implicit *or* explicit.

Examples
--------


```js
const value1 = "5";
const value2 = 9;
let sum = value1 + value2;

console.log(sum);
```


In the above example, JavaScript has *coerced* the `9` from a number into a string and then concatenated the two values together, resulting in a string of `59`. JavaScript had a choice between a string or a number and decided to use a string.

The compiler could have coerced the `5` into a number and returned a sum of `14`, but it did not. To return this result, you'd have to explicitly convert the `5` to a number using the `Number()` method:


```js
sum = Number(value1) + value2;
```

See also
--------

* Type conversion (Wikipedia)
* Glossary
    + Type
    + Type conversion
Brotli
======

**Brotli** is a general-purpose lossless compression algorithm.

It compresses data using a combination of a modern variant of the LZ77 algorithm, Huffman coding, and second-order context modeling, providing a compression ratio comparable to the best currently available general-purpose compression methods. Brotli provides better compression ratios than gzip and deflate speeds are comparable, but brotli compressing is a slower process than Gzip compression, so gzip may be a better option for the compression of non-cacheable content.

Brotli is compatible with most modern browsers, but you may want to consider a fallback.

See also
--------

* brotli.org
* Brotli GitHub repository
* Brotli on Wikipedia
* Brotli on Caniuse
DSL
===

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

DSL (Digital Subscriber Line)
**DSL (Digital Subscriber Line)** is a type of broadband internet connection that sends wired data transmissions over telephone lines.
DSL (Domain-Specific Language)
A **Domain-Specific Language (DSL)** is a type of computer language of limited scope, designed to address a particular problem within an application domain.
See also
--------

* DSL on Wikipedia
Immutable
=========

An immutable value is one whose content cannot be changed without creating an entirely new value.

 In JavaScript, primitive values are immutable — once a primitive value is created, it cannot be changed, although the variable that holds it may be reassigned another value.
 By contrast, objects and arrays are mutable by default — their properties and elements can be changed without reassigning a new value.

It can be beneficial to use immutable objects for several reasons:

* To improve performance (no planning for the object's future changes)
* To reduce memory use (make object references instead of cloning the whole object)
* Thread-safety (multiple threads can reference the same object without interfering with one other)
* Lower developer mental burden (the object's state won't change and its behavior is always consistent)

Note that you can easily prove mutability: an object is mutable as long as it offers one way to change its properties. On the other hand, *immutability* is hard to prove if there are no language semantics to secure it — it is a matter of developer contract. For example, `Object.freeze()` is a language-level method to make an object immutable in JavaScript.

See also
--------

* Immutable on Wikipedia
* Mutable
IMAP
====

IMAP (Internet Message Access Protocol) is a protocol used to retrieve and store emails. More recent than POP, IMAP allows folders and rules on the server.

Unlike POP3, IMAP allows multiple simultaneous connections to one mailbox. Clients accessing a mailbox can receive information about state changes made from other clients. IMAP also provides a mode for clients to stay connected and receive information on demand.

Mark Crispin initially developed IMAP in 1986 as *Interim Mail Access Protocol*. IMAP4 revision 1 is the current version, defined by RFC 3501.

See also
--------

* RFC 3501
* POP
* IMAP on Wikipedia
DTMF (Dual-Tone Multi-Frequency signaling)
==========================================

**Dual-Tone Multi-Frequency** (**DTMF**) signaling is a system by which audible tones are used to represent buttons being pressed on a keypad. Frequently referred to in the United States as "touch tone" (after the Touch-Tone trademark used when the transition from pulse dialing to DTMF began), DTMF makes it possible to signal the digits 0-9 as well as the letters "A" through "D" and the symbols "#" and "\*". Few telephone keypads include the letters, which are typically used for control signaling by the telephone network.

Computers may make use of DTMF when dialing a modem, or when sending commands to a menu system for teleconferencing or other purposes.

See also
--------

* Dual-tone multi-frequency signaling on Wikipedia
* Pulse dialing on Wikipedia
HPKP
====

**HTTP Public Key Pinning** (**HPKP**) is an obsolete security feature that tells a web client to associate a specific cryptographic public key with a certain web server to decrease the risk of MITM attacks with forged certificates.

See also
--------

* RFC 7469
* Wikipedia: HTTP Public Key Pinning
TURN
====

**TURN** (Traversal Using Relays around NAT) is a protocol enabling a computer to receive and send data from behind a Network Address Translator (NAT) or firewall. TURN is used by WebRTC to allow any two devices on the Internet to enter a peer-to-peer connection.

See also
--------

* TURN on Wikipedia
* WebRTC protocols
* Specification
* Specification update for IPv6
Engine
======

The JavaScript engine is an interpreter that parses and executes a JavaScript program.

See also
--------

* JavaScript engine on Wikipedia
Lossy compression
=================

**Lossy compression**, or irreversible compression, is a data-compression method that uses inexact approximations and partial-data discarding to represent content. In simpler terms: lossy compression causes data from the initial file to be lost, possibly causing degradation in quality. The process of such compression is irreversible; once lossy compression of the content has been performed, the content cannot be restored to its original state. Therefore, content that has undergone lossy compression should generally not be further edited.

Lossy compression is widely used in image formats.

![Lossy compression image](/en-US/docs/Glossary/Lossy_compression/2019-11-18.png)

Although there is no obvious difference quality between the two images above, the size of the second image has been significantly reduced, using lossy compression.

See also
--------

* Lossless compression
ARPA
====

**.arpa** (address and routing parameter area) is a top-level domain in the Domain Name System (DNS) used for Internet infrastructure purposes, especially reverse DNS lookup (i.e., find the domain name for a given IP address).

The name comes from **ARPA**, currently known as DARPA, the Defense Advanced Research Projects Agency. DARPA is credited with developing precursors to the Internet (ARPANET), GPS, artificial intelligence, and virtual reality.

TLD was designed at DARPA during a time when it was called ARPA, hence the `.arpa` domain name.

The most prominent `.arpa` domains include `addr.arpa` and `ip6.arpa`, which provide namespaces for reverse DNS lookup of IPv4 and IPv6 addresses respectively.

See also
--------

* ARPANET
* Official website
* .arpa on Wikipedia
WebKit
======

*WebKit* is a framework that displays properly-formatted webpages based on their markup. Apple Safari depends on WebKit, and so do many mobile browsers (since WebKit is highly portable and customizable).

WebKit began life as a fork of KDE's KHTML and KJS libraries, but many individuals and companies have since contributed (including KDE, Apple, Google, and Nokia).

WebKit is an Apple trademark, and the framework is distributed under a BSD-form license. However, two important components fall under the LGPL: the **WebCore** rendering library and the **JavaScriptCore** engine.

See also
--------

* WebKit on Wikipedia
* WebKit CSS extensions
LGPL
====

LGPL (GNU Lesser General Public License) is a free software license published by the Free Software Foundation. The LGPL provides a more permissive alternative for the strictly copyleft GPL. While any derivative work using a GPL-licensed program must be released under the same terms (free to use, share, study, and modify), the LGPL only requires the LGPL-licensed component of the derivative program to continue using the LGPL, not the whole program. LGPL is usually used to license shared components such as libraries (`.dll`, `.so`, `.jar`, etc.).

See also
--------

* GNU LGPL on Wikipedia
* LGPL License text on gnu.org
RSS
===

**RSS** (Really Simple Syndication) refers to several XML document formats designed for publishing site updates. When you subscribe to a website's RSS feed, the website sends information and updates to your RSS reader in an RSS document called a *feed*, so you don't need to check all your favorite websites manually.

See also
--------

* RSS on Wikipedia
* Latest specification