recursal/MDN huggingface dataset:
Main thread
===========

The **main thread** is where a browser processes user events and paints. By default, the browser uses a single thread to run all the JavaScript in your page, as well as to perform layout, reflows, and garbage collection. This means that long-running JavaScript functions can block the thread, leading to an unresponsive page and a bad user experience.

Unless intentionally using a web worker, such as a service worker, JavaScript runs on the main thread, so it's easy for a script to cause delays in event processing or painting. The less work required of the main thread, the more that thread can respond to user events, paint, and generally be responsive to the user.

See also
--------

* Asynchronous JavaScript
* Web worker API
* Service worker API
* Glossary
    + Thread
Unicode
=======

Unicode is a standard character set that numbers and defines characters from the world's different languages, writing systems, and symbols.

By assigning each character a number, programmers can create character encodings, to let computers store, process, and transmit any combination of languages in the same file or program.

Before Unicode, it was difficult and error-prone to mix languages in the same data. For example, one character set would store Japanese characters, and another would store the Arabic alphabet. If it was not clearly marked which parts of the data were in which character set, other programs and computers would display the text incorrectly, or damage it during processing. If you've ever seen text where characters like curly quotes (“”) were replaced with gibberish like `Ã‚Â£`, then you've seen this problem, known as Mojibake.

The most common Unicode character encoding on the Web is UTF-8. Other encodings exist, like UTF-16 or the obsolete UCS-2, but UTF-8 is recommended.

See also
--------

* Unicode on Wikipedia
* The Unicode Standard: A Technical Introduction
Binding
=======

In programming, a **binding** is an association of an identifier with a value. Not all bindings are variables — for example, function parameters and the binding created by the `catch (e)` block are not "variables" in the strict sense. In addition, some bindings are implicitly created by the language — for example, `this` and `new.target` in JavaScript.

A binding is mutable if it can be re-assigned, and immutable otherwise; this does *not* mean that the value it holds is immutable.

A binding is often associated with a scope. Some languages allow re-creating bindings (also called redeclaring) within the same scope, while others don't; in JavaScript, whether bindings can be redeclared depends on the construct used to create the binding.

See also
--------

* `var`
* `let`
* `const`
* `function`
* `class`
Submit button
=============

A **submit button** is an element in HTML that can be used to submit a `<form>`. The native submit button elements are:

* `<button>` (its default `type` is `"submit"`)
* `<input type="submit">`
* `<input type="image">`

In addition to submitting a form, a submit button can affect the form's behavior and what data is sent.

Overriding the form's behavior
------------------------------

Submit buttons can override the form's submission behavior through various attributes:

* `formaction`: Override the `action` attribute of the form.
* `formenctype`: Override the `enctype` attribute of the form.
* `formmethod`: Override the `method` attribute of the form.
* `formnovalidate`: Override the `novalidate` attribute of the form.
* `formtarget`: Override the `target` attribute of the form.
Form data entries
-----------------

If the submit button is a `<button>` or `<input type="submit">` and has a `name` attribute, the form data set will include an entry for its `name` and `value`.

If the submit button is an `<input type="image">`, the form data set will include entries for the X and Y coordinates that the user clicked on (e.g. `x=100&y=200` or `buttonName.x=123&buttonName.y=234`).

See also
--------

* Basic native form controls
* Sending form data
Raster image
============

A ***raster image*** is an image file defined as a grid of pixels. They're also referred to as *bitmaps*. Common raster image formats on the Web are JPEG, PNG, GIF, and ICO.

Raster image files usually contain one set of dimensions, but the ICO and CUR formats, used for favicons and CSS cursor images, can contain multiple sizes.

See also
--------

* Vector images
Proxy server
============

A **proxy server** is an intermediate program or computer used when navigating through different networks of the Internet. They facilitate access to content on the World Wide Web. A proxy intercepts requests and serves back responses; it may forward the requests, or not (for example in the case of a cache), and it may modify it (for example changing its headers, at the boundary between two networks).

A proxy can be on the user's local computer, or anywhere between the user's computer and a destination server on the Internet. In general there are two main types of proxy servers:

* A **forward proxy** that handles requests from and to anywhere on the Internet.
* A **reverse proxy** taking requests from the Internet and forwarding them to servers in an internal network.
See also
--------

* Proxy servers and tunneling
* Proxy server on Wikipedia
RTCP (RTP Control Protocol)
===========================

The **RTP Control Protocol** (**RTCP**) is a partner to the RTP protocol. RTCP is used to provide control and statistical information about an RTP media streaming session.

This lets control and statistics packets be separated logically and functionally from the media streaming while using the underlying packet delivery layer to transmit the RTCP signals as well as the RTP and media contents.

RTCP periodically transmits control packets to all of an RTP session's participants, using the same mechanism that is being used to transmit the data packets. That underlying protocol handles the multiplexing of the data and control packets and may use separate network ports for each type of packet.

See also
--------

* Introduction to the Real-time Transport Protocol
* RTP Control Protocol
* RFC 3550, section 6: RFC 3550 Section 6
Polymorphism
============

Polymorphism is the presentation of one interface for multiple data types.

For example, integers, floats, and doubles are implicitly polymorphic: regardless of their different types, they can all be added, subtracted, multiplied, and so on.

In the case of OOP, by making the class responsible for its code as well as its own data, polymorphism can be achieved in that each class has its own function that (once called) behaves properly for any object.

See also
--------

* Polymorphism on Wikipedia
XSLT
====

*eXtensible Stylesheet Language Transformations* (**XSLT**) is a declarative language used to convert XML documents into other XML documents, HTML, PDF, plain text, and so on.

XSLT has its own processor that accepts XML input, or any format convertible to an XQuery and XPath Data Model. The XSLT processor produces a new document based on the XML document and an XSLT stylesheet, making no changes to the original files in the process.

See also
--------

* XSLT on Wikipedia
* XSLT documentation on MDN
Object
======

In JavaScript, objects can be seen as a collection of properties. With the object literal syntax, a limited set of properties are initialized; then properties can be added and removed. Property values can be values of any type, including other objects, which enables building complex data structures. Properties are identified using *key* values. A *key* value is either a String value or a Symbol value.

There are two types of object properties: The *data* property and the *accessor* property.

**Note:** It's important to recognize it's accessor *property* — not accessor *method*. We can give a JavaScript object class-*like* accessors by using a function as a value — but that doesn't make the object a class.

See also
--------

* Detailed explanation of JavaScript objects in the JavaScript data types and data structures article
* `Object` in the JavaScript reference
ATAG
====

ATAG (Authoring Tool Accessibility Guidelines) is a W3C recommendation for building accessible-authoring tools that produce accessible contents.

See also
--------

* ATAG as part of the Web Accessibility Initiative on WikiPedia
* Authoring Tool Accessibility Guidelines (ATAG) Overview
* The ATAG 2.0 recommendation
Event
=====

Events are assets generated by DOM elements, which can be manipulated by a JavaScript code.

See also
--------

* Event documentation on MDN
* Official website
* DOM Events on Wikipedia
Tree shaking
============

**Tree shaking** is a term commonly used within a JavaScript context to describe the removal of dead code.

It relies on the import and export statements to detect if code modules are exported and imported for use between JavaScript files.

In modern JavaScript applications, we use module bundlers (e.g., webpack or Rollup) to automatically remove dead code when bundling multiple JavaScript files into single files. This is important for preparing code that is production ready, for example with clean structures and minimal file size.

See also
--------

* "Benefits of dead code elimination during bundling" in Axel Rauschmayer's book: "Exploring JS: Modules"
* Tree shaking implementation with webpack
SISD
====

SISD is short for **Single Instruction/Single Data** which is one classification of computer architectures. In SISD architecture, a single processor executes a single instruction and operates on a single data point in memory.

See also SIMD for a parallel architecture that allows one same operation to be performed on multiple data points.

See also
--------

* SISD on Wikipedia
Dominator
=========

In graph theory, node A dominates node B if every path from the root node to B passes through A.

This concept is important for garbage collection because it means that B is only reachable through A. So if the garbage collector found A to be unreachable and eligible for reclaiming, than B would also be unreachable and eligible for reclaiming. So objects that A dominates contribute to the retained size of A: that is, the total amount of memory that could be freed if A itself were freed.

See also
--------

* Dominator on Wikipedia
* Dominators
* Garbage collection
Script-supporting element
=========================

In an HTML document, **script-supporting elements** are those elements that don't directly contribute to the appearance or layout of the page; instead, they're either scripts or contain information that's only used by scripts.

These elements may be important, but do not affect the displayed page unless the page's scripts explicitly cause them to do so.

There are only two script-supporting elements: `<script>` and `<template>`.

See also
--------

Script-supporting elements
Largest contentful paint
========================

The **Largest Contentful Paint** (LCP) performance metric provides the render time of the largest image or text block visible within the viewport, recorded from when the page first begins to load.

The following elements are considered when determining the LCP:

* `<img>` elements.
* `<image>` elements inside an SVG.
* The poster images of `<video>` elements.
* Elements with a `background-image`.
* Groups of text nodes, such as `<p>`.
See also
--------

* `LargestContentfulPaint`
* First contentful paint
* First paint
Repaint
=======

**Repaint** happens when a browser redraws a web page to show the visual updates resulting from a UI change, such as after an update on an interactive site. This usually follows reflowing, which is when the browser recalculates the position and geometry of certain parts of a web page.

See also
--------

* Reflow
* Understanding Reflow and Repaint in the browser on dev.to (2020)
Gecko
=====

**Gecko** is the layout engine developed by the Mozilla Project and used in many apps/devices, including Firefox and Firefox OS.

Web browsers need software called a layout engine to interpret HTML, CSS, JavaScript, and embedded content (like images) and draw everything to your screen. Besides this, Gecko makes sure associated APIs work well on every operating system Gecko supports, and that appropriate APIs are exposed only to relevant support targets. This means that Gecko includes, among other things, a networking stack, graphics stack, layout engine, a JavaScript virtual machine, and porting layers.

Since all Firefox OS apps are Web apps, Firefox OS uses Gecko as its app runtime as well.

See also
--------

* Gecko on Wikipedia
Descriptor (CSS)
================

A **CSS descriptor** defines the characteristics of an at-rule. At-rules may have one or multiple descriptors. Each descriptor has:

* A name
* A value, which holds the component values
* An "!important" flag, which in its default state is unset
Shim
====

A **shim** is a piece of code used to correct the behavior of code that already exists, usually by adding new API that works around the problem. This differs from a polyfill, which implements a new API that is not supported by the stock browser as shipped.

See also
--------

* Shim on Wikipedia
Null
====

In computer science, a **`null`** value represents a reference that points, generally intentionally, to a nonexistent or invalid object or address. The meaning of a null reference varies among language implementations.

In JavaScript, `null` is marked as one of the primitive values, because its behavior is seemingly primitive. However, when using the `typeof` operator, it returns `"object"`.


```js
console.log(typeof null); // "object"
```


This is considered a bug, but one which cannot be fixed because it will break too many scripts.

See also
--------

* JavaScript data types
* The JavaScript global object: `null`
* Null pointer on Wikipedia
* **Glossary**
    + JavaScript
    + string
    + number
    + bigint
    + boolean
    + null
    + undefined
    + symbol
Cryptanalysis
=============

**Cryptanalysis** is the branch of cryptography that studies how to break codes and cryptosystems. Cryptanalysis creates techniques to break ciphers, in particular by methods more efficient than a brute-force search. In addition to traditional methods like frequency analysis and index of coincidence, cryptanalysis includes more recent methods, like linear cryptanalysis or differential cryptanalysis, that can break more advanced ciphers.

See also
--------

* Cryptanalysis on Wikipedia
Python
======

**Python** is a high level general-purpose programming language. It uses a multi-paradigm approach, meaning it supports procedural, object-oriented, and some functional programming constructs.

It was created by Guido van Rossum as a successor to another language (called ABC) between 1985 and 1990, and is currently used on a large array of domains like web development, desktop applications, data science, DevOps, and automation/productivity.

Python is developed under an OSI-approved open source license, making it freely usable and distributable, even for commercial use. Python's license is administered by the Python Software Foundation.

See also
--------

* Python on Wikipedia
* Official Python docs tutorials
* Tutorials Point Python tutorial
* AlphaCodingSkills Python Tutorial
* Django Web Framework (Python) on MDN
* Glossary
    + Java
    + JavaScript
    + PHP
    + Python
    + Ruby
Pseudocode
==========

Pseudocode refers to code-like syntax that is generally used to indicate to humans how some code syntax works, or illustrate the design of an item of code architecture. It **won't** work if you try to run it as code.

See also
--------

* Pseudocode on Wikipedia.
JSON
====

*JavaScript Object Notation* (**JSON**) is a data-interchange format. Although not a strict subset, JSON closely resembles a subset of JavaScript syntax. Though many programming languages support JSON, it is especially useful for JavaScript-based apps, including websites and browser extensions.

JSON can represent numbers, booleans, strings, `null`, arrays (ordered sequences of values), and objects (string-value mappings) made up of these values (or of other arrays and objects). JSON does not natively represent more complex data types like functions, regular expressions, dates, and so on. (Date objects by default serialize to a string containing the date in ISO format, so the information isn't completely lost.) If you need JSON to represent additional data types, transform values as they are serialized or before they are deserialized.

See also
--------

* JSON on Wikipedia
* JSON on MDN
MathML
======

**MathML** (an XML application) is an open standard for representing mathematical expressions in webpages. In 1998 the W3C first recommended MathML for representing mathematical expressions in the browser. MathML has other applications also including scientific content and voice synthesis.

See also
--------

* MathML on Wikipedia
* MathML
* Authoring MathML
* What is MathML
Safe
====

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

Safe (HTTP Methods)
An HTTP method is **safe** if it doesn't alter the state of the server. In other words, a method is safe if it leads to a read-only operation. Several common HTTP methods are safe: `GET`, `HEAD`, or `OPTIONS`. All safe methods are also idempotent, but not all idempotent methods are safe. For example, `PUT` and `DELETE` are both idempotent but unsafe.
Closure
=======

The binding which defines the **scope** of execution. In JavaScript, **functions** create a closure context.

See also
--------

* Closure on Wikipedia
* Closure on MDN
Progressive Enhancement
=======================

**Progressive enhancement** is a design philosophy that provides a baseline of essential content and functionality to as many users as possible, while delivering the best possible experience only to users of the most modern browsers that can run all the required code.

The word *progressive* in *progressive enhancement* means creating a design that achieves a simpler-but-still-usable experience for users of older browsers and devices with limited capabilities, while at the same time being a design that **progresses the user experience up** to a more-compelling, fully-featured experience for users of newer browsers and devices with richer capabilities.

Feature detection is generally used to determine whether browsers can handle more modern functionality, while polyfills are often used to add missing features with JavaScript.

Special notice should be taken of accessibility. Acceptable alternatives should be provided where possible.

Progressive enhancement is a useful technique that allows web developers to focus on developing the best possible websites while making those websites work on multiple unknown user agents. Graceful degradation is related but is not the same thing and is often seen as going in the opposite direction to progressive enhancement. In reality both approaches are valid and can often complement one another.

See also
--------

* Progressive enhancement at Wikipedia
* What is Progressive Enhancement, and why it matters at freeCodeCamp (2018)
* Progressive Enhancement at QuirksMode (2021)
* The Power of Progressive Enhancement at Piccalilli (2018)
Scope
=====

The **scope** is the current context of execution in which values and expressions are "visible" or can be referenced. If a variable or expression is not in the current scope, it will not be available for use. Scopes can also be layered in a hierarchy, so that child scopes have access to parent scopes, but not vice versa.

JavaScript has the following kinds of scopes:

* Global scope: The default scope for all code running in script mode.
* Module scope: The scope for code running in module mode.
* Function scope: The scope created with a function.

In addition, variables declared with `let` or `const` can belong to an additional scope:

* Block scope: The scope created with a pair of curly braces (a block).

A function creates a scope, so that (for example) a variable defined exclusively within the function cannot be accessed from outside the function or within other functions. For instance, the following is invalid:


```js
function exampleFunction() {
  const x = "declared inside function"; // x can only be used in exampleFunction
  console.log("Inside function");
  console.log(x);
}

console.log(x); // Causes error
```


However, the following code is valid due to the variable being declared outside the function, making it global:


```js
const x = "declared outside function";

exampleFunction();

function exampleFunction() {
  console.log("Inside function");
  console.log(x);
}

console.log("Outside function");
console.log(x);
```


Blocks only scope `let` and `const` declarations, but not `var` declarations.


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



```js
{
  const x = 1;
}
console.log(x); // ReferenceError: x is not defined
```

See also
--------

* Scope (computer science) on Wikipedia
HTTPS RR
========

**HTTPS RR** (***HTTPS Resource Records***) are a type of DNS record that delivers configuration information and parameters for how to access a service via HTTPS.

 An *HTTPS RR* can be used to optimize the process of connecting to a service using HTTPS.
 Further, the presence of an *HTTPS RR* signals that all useful HTTP resources on the origin are reachable over HTTPS, which in turn means that a browser can safely upgrade connections to the domain from HTTP to HTTPS.

### See also

* Service binding and parameter specification via the DNS (DNS SVCB and HTTPS RRs) (Draft IETF specification: draft-ietf-dnsop-svcb-https-00)
* Strict Transport Security vs. HTTPS Resource Records: the showdown (Emily M. Stark blog)
* TLS
MitM
====

A **manipulator-in-the-middle attack** (MitM) intercepts a communication between two systems. For example, a Wi-Fi router can be compromised.

Comparing this to physical mail: If you're writing letters to each other, the mail carrier can intercept each letter you mail. They open it, read it, eventually modify it, and then repackage the letter and only then send it to whom you intended to sent the letter for. The original recipient would then mail you a letter back, and the mail carrier would again open the letter, read it, eventually modify it, repackage it, and give it to you. You wouldn't know there's a manipulator in the middle in your communication channel – the mail carrier is invisible to you and to your recipient.

In physical mail and in online communication, MITM attacks are tough to defend. A few tips:

* Don't just ignore certificate warnings. You could be connecting to a phishing server or an imposter server.
* Sensitive sites without HTTPS encryption on public Wi-Fi networks aren't trustworthy.
* Check for HTTPS in your address bar and ensure encryption is in-place before logging in.
See also
--------

* OWASP: Manipulator-in-the-middle attack
* PortSwigger: Latest manipulator-in-the-middle attacks news
* Wikipedia: Man-in-the-middle attack
NAT
===

**NAT** (Network Address Translation) is a technique for letting multiple computers share an IP address. NAT assigns unique addresses to each computer on the local network and adjusts incoming/outgoing network traffic to send data to the right place.

See also
--------

* WebRTC protocols
* Network address translation on Wikipedia
WebVTT
======

WebVTT (Web Video Text Tracks) is a W3C specification for a file format marking up text track resources in combination with the HTML `<track>` element.

WebVTT files provide metadata that is time-aligned with audio or video content like captions or subtitles for video content, text video descriptions, chapters for content navigation, and more.

See also
--------

* WebVTT on Wikipedia
* WebVTT on MDN
* Specification