Datasets:

recursal

/

MDN

like 0

Follow

recursal 8

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

IDL === An **IDL** (*Interface Description Language*) is a generic language used to specified objects' interfaces apart from any specific programming language. Content versus IDL attributes ----------------------------- In HTML, most attributes have two faces: the **content attribute** and the **IDL attribute**. The content attribute is the attribute as you set it from the content (the HTML code) and you can set it or get it via `element.setAttribute()` or `element.getAttribute()`. The content attribute is always a string even when the expected value should be an integer. For example, to set an `<input>` element's `maxlength` to 42 using the content attribute, you have to call `setAttribute("maxlength", "42")` on that element. The IDL attribute is also known as a JavaScript property. These are the attributes you can read or set using JavaScript properties like `element.foo`. The IDL attribute is always going to use (but might transform) the underlying content attribute to return a value when you get it and is going to save something in the content attribute when you set it. In other words, the IDL attributes, in essence, reflect the content attributes. Most of the time, IDL attributes will return their values as they are really used. For example, the default `type` for `<input>` elements is "text", so if you set `input.type="foobar"`, the `<input>` element will be of type text (in the appearance and the behavior) but the "type" content attribute's value will be "foobar". However, the `type` IDL attribute will return the string "text". IDL attributes are not always strings; for example, `input.maxlength` is a number (a signed long). When using IDL attributes, you read or set values of the desired type, so `input.maxlength` is always going to return a number and when you set `input.maxlength`, it wants a number. If you pass another type, it is automatically converted to a number as specified by the standard JavaScript rules for type conversion. IDL attributes can reflect other types such as unsigned long, URLs, booleans, etc. Unfortunately, there are no clear rules and the way IDL attributes behave in conjunction with their corresponding content attributes depends on the attribute. Most of the time, it will follow the rules laid out in the specification, but sometimes it doesn't. HTML specifications try to make this as developer-friendly as possible, but for various reasons (mostly historical), some attributes behave oddly (`select.size`, for example) and you should read the specifications to understand how exactly they behave. See also -------- * IDL on Wikipedia * HTML attribute reference * Interface Definition Language

Request header - MDN Web Docs Glossary: Definitions of Web-related terms

Request header ============== A **request header** is an HTTP header that can be used in an HTTP request to provide information about the request context, so that the server can tailor the response. For example, the `Accept-*` headers indicate the allowed and preferred formats of the response. Other headers can be used to supply authentication credentials (e.g. `Authorization`), to control caching, or to get information about the user agent or referrer, etc. Not all headers that can appear in a request are referred to as *request headers* by the specification. For example, the `Content-Type` header is referred to as a representation header. In addition, CORS defines a subset of request headers as simple headers, request headers that are always considered authorized and are not explicitly listed in responses to preflight requests. The HTTP message below shows a few request headers after a `GET` request: ```http GET /home.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 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,\*/\*;q=0.8 Accept-Language: en-US,en;q=0.5 Accept-Encoding: gzip, deflate, br Referer: https://developer.mozilla.org/testpage.html Connection: keep-alive Upgrade-Insecure-Requests: 1 If-Modified-Since: Mon, 18 Jul 2016 02:36:04 GMT If-None-Match: "c561c68d0ba92bbeb8b0fff2a9199f722e3a621a" Cache-Control: max-age=0 ``` See also -------- * List of all HTTP headers * RFC 9110, section 6.3: Header Fields

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

PDF === **PDF** (Portable Document Format) is a file format used to share documentation without depending on any particular software implementation, hardware platform, or operating system. PDF provides a digital image of a printed document, and keeps the same appearance when printed. See also -------- * PDF on Wikipedia

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

WebIDL ====== **WebIDL** is the interface description language used to describe the data types, interfaces, methods, properties, and other components which make up a Web application programming interface (API). It uses a somewhat stylized syntax which is independent of any specific programming language, so that the underlying code which is used to build each API can be written in whatever language is most appropriate, while still being possible to map the API's components to JavaScript-compatible constructs. WebIDL is used in nearly every API specification for the Web, and due to its standard format and syntax, the programmers who create Web browsers can more easily ensure that their browsers are compatible with one another, regardless of how they choose to write the code to implement the API. See also -------- * Specification * Information contained in a WebIDL file * Gecko WebIDL bindings * WebIDL

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

Property ======== The term **property** can have several meanings depending on the context. It may refer to: Property (CSS) A **CSS property** is a characteristic (like color) whose associated value defines one aspect of how the browser should display the element. Property (JavaScript) A **JavaScript property** is a member of an object that associates a key with a value. A JavaScript object is a data structure that stores a collection of properties.

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

Endianness ========== **Endian** and **endianness** (or "byte-order") describe how computers organize the bytes that make up numbers. Each memory storage location has an index or address. Every byte can store an 8-bit number (i.e. between `0x00` and `0xff`), so you must reserve more than one byte to store a larger number. By far the most common *ordering* of multiple bytes in one number is the **little-endian**, which is used on all Intel processors. Little-endian means storing bytes in order of least-to-most-significant (where the least significant byte takes the first or lowest address), comparable to a common European way of writing dates (e.g., 31 December 2050). Naturally, **big-endian** is the opposite order, comparable to an ISO date (2050-12-31). Big-endian is also often called "network byte order", because Internet standards usually require data to be stored big-endian, starting at the standard UNIX socket level and going all the way up to standardized Web binary data structures. Also, older Mac computers using 68000-series and PowerPC microprocessors formerly used big-endian. Examples with the number `0x12345678` (i.e. 305 419 896 in decimal): * *little-endian*: `0x78 0x56 0x34 0x12` * *big-endian*: `0x12 0x34 0x56 0x78` * *mixed-endian* (historic and very rare): `0x34 0x12 0x78 0x56` The typed arrays guide provides an example that converts any number to its binary representation under the given endianness. See also -------- * `ArrayBuffer` * `DataView` * Typed Arrays * Endianness (Wikipedia) * Data structure (Glossary)

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

Function ======== A **function** is a code snippet that can be called by other code or by itself, or a variable that refers to the function. When a function is called, arguments are passed to the function as input, and the function can optionally return a value. A function in JavaScript is also an object. A function name is an identifier included as part of a function declaration or function expression. The function name's scope depends on whether the function name is a declaration or expression. ### Different types of functions An **anonymous function** is a function without a function name. Only function expressions can be anonymous, function declarations must have a name: ```js // Anonymous function created as a function expression (function () {}); // Anonymous function created as an arrow function () => {}; ``` The following terms are not used in the ECMAScript language specification, they're jargon used to refer to different types of functions. A **named function** is a function with a function name: ```js // Function declaration function foo() {} // Named function expression (function bar() {}); // Arrow function const baz = () => {}; ``` An **inner function** is a function inside another function (`square` in this case). An **outer function** is a function containing a function (`addSquares` in this case): ```js function addSquares(a, b) { function square(x) { return x \* x; } return square(a) + square(b); } // Arrow function const addSquares2 = (a, b) => { const square = (x) => x \* x; return square(a) + square(b); }; ``` A **recursive function** is a function that calls itself. See recursion. ```js function loop(x) { if (x >= 10) return; loop(x + 1); } // Arrow function const loop2 = (x) => { if (x >= 10) return; loop(x + 1); }; ``` An **Immediately Invoked Function Expression** (IIFE) is a function that is called directly after the function is loaded into the browser's compiler. The way to identify an IIFE is by locating the extra left and right parenthesis at the end of the function's definition. Function expressions, named or anonymous, can be called immediately. ```js (function foo() { console.log("Hello Foo"); })(); (function food() { console.log("Hello Food"); })(); (() => console.log("hello world"))(); ``` Declared functions can't be called immediately this way, because IIFEs must be function *expressions*. ```js function foo() { console.log('Hello Foo'); }(); ``` If you'd like to know more about IIFEs, check out the following page on Wikipedia: Immediately Invoked Function Expression See also -------- * Functions * Arrow Functions

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

Number ====== In JavaScript, **Number** is a numeric data type in the double-precision 64-bit floating point format (IEEE 754). In other programming languages different numeric types exist; for example, Integers, Floats, Doubles, or Bignums. See also -------- * Numeric types on Wikipedia * The JavaScript type: `Number` * The JavaScript global object `Number` * Glossary: + JavaScript + Primitive

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

Wrapper ======= In programming languages such as JavaScript, a wrapper is a function that is intended to call one or more other functions, sometimes purely for convenience, and sometimes adapting them to do a slightly different task in the process. For example, SDK Libraries for AWS are examples of wrappers. See also -------- * Wrapper function (Wikipedia) * MDN Web Docs Glossary + API + Class + Function

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

Minification ============ **Minification** is the process of removing unnecessary or redundant data without affecting how a resource is processed by the browser. Minification can include the removal of code comments, white space, and unused code, as well as the shortening of variable and function names. Minification is used to improve web performance by reducing file size. It is generally an automated step that occurs at build time. As minification makes code less legible to humans, developer tools have 'prettification' features that can add white space back into the code to make it a bit more legible.

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

Syntax ====== Syntax specifies the required combination and sequence of characters making up correctly structured code. Syntax generally includes grammar and the rules that apply to writing it, such as indentation requirements in Python. Syntax varies from language to language (e.g., syntax is different in HTML and JavaScript). Although languages can share few similarities in terms of their syntaxes for example "operand operator operand" rule in JavaScript and Python. This does not mean the two languages share similarities with syntax. Syntax applies both to programming languages (commands to the computer) and markup languages (document structure information) alike. Syntax only governs ordering and structure; the instructions must also be *meaningful*, which is the province of semantics. Code must have correct syntax in order to compile correctly, otherwise a syntax error occurs. Even small errors, like a missing parenthesis, can stop source code from compiling successfully. Frameworks are said to have a "clean" syntax if they produce simple, readable, concise results. If a codebase uses "a lot of syntax", it requires more characters to achieve the same functionality. See also -------- * Syntax (programming languages) on Wikipedia

Accessible name - MDN Web Docs Glossary: Definitions of Web-related terms

Accessible name =============== An **accessible name** is the name of a user interface element; it is the text associated with an HTML element that provides users of assistive technology with a label for the element. Accessible names convey the purpose or intent of the element. This helps users understand what the element is for and how they can interact with it. In general, accessible names for elements should be unique to a page. This helps users distinguish an element from other elements and helps users identify the element they want to interact with. Depending on the element and the HTML markup, the value of the accessible name may be derived from visible (e.g., the text within `<figcaption>`) or invisible (e.g., the `aria-label` attribute set on an element) content, or a combination of both. How an element's accessible name is determined is based on the accessible name calculation, which is different for different elements. It is best to use visible text as the accessible names. Many elements, including `<a>`, `<td>` and `<button>`, get their name from their contents. For example, given `<a href="foo.html">Bar</a>`, the accessible name is "Bar." Other elements get their accessible name from the content of associated elements. For some parent elements, like `<fieldset>`, `<table>`, and `<figure>`, if those elements contain a descendant `<fieldset>`, `<caption>`, or `<figcaption>`, respectively, the association is automatic. For some other elements, like `<textarea>` and `<input>`, the accessible name also comes from an associated element, the `<label>` element, but that association has to explicitly set with a `for` attribute value on the `<label>` that matches the form control's `id`. With some elements, like `<img>`, the accessible name comes from its attributes, in this case, the `alt` attribute value. Given `<img src="grape.jpg" alt="banana"/>`, the image's accessible name is "banana." To create an association between visible content and an element or multiple text nodes and an element, the `aria-labeledby` attribute can be used. If there is no visible text to associate with a UI element needing an accessible name, the `aria-label` attribute can be used. Names should not be added to elements marking up inline text, like `<code>`, `<del>`, and `<mark>`. Many elements, such as sections of textual content, don't need an accessible name. All controls should have an accessible name. All images that convey information and aren't purely presentational do too. Assistive technologies will provide the user with the accessibility name property, which is the accessible name along with the element's role. While many elements don't need an accessible name, some content roles can benefit from having an accessible name. For example, a `tabpanel` is a section of content that appears after a user activates the associated element with a `tab` role. This role can be set on an element with no needed name, like the `<div>` element. The `tab` is the control and must have an accessible name. The `tabpanel` is the child (content section) of the `tab`. Adding `aria-labelledby` to the `tabpanel` is a best practice. See also -------- * ARIA roles * ARIA attribute * Accessibility * Learn accessibility

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

Digest ====== A **digest** is a small value generated by a hash function from a whole message. Ideally, a digest is quick to calculate, irreversible, and unpredictable, and therefore indicates whether someone has tampered with a given message. A digest can be used to perform several tasks: * in non-cryptographic applications (e.g., the index of hash tables, or a fingerprint used to detect duplicate data or to uniquely identify files) * verify message integrity (a tampered message will have a different hash) * store passwords so that they can't be retrieved, but can still be checked (To do this securely, you also need to salt the password.) * generate pseudo-random numbers * generate keys It is critical to choose the proper hash function for your use case to avoid collisions and predictability. See also -------- * See Cryptographic hash function * Hash function on Wikipedia

Render-blocking - MDN Web Docs Glossary: Definitions of Web-related terms

Render-blocking =============== **Render-blocking** refers to any part of the process of loading a website when it blocks the rendering of the user interface. Render-blocking is bad for web performance because it increases the length of time until users can interact with the site — for example viewing content or interacting with controls. The most common causes of render-blocking are initially-loaded CSS or JavaScript files. See also -------- * CSS performance optimization * JavaScript performance optimization * What Are Render-Blocking Resources & How to Fix Render Blocking Issues on Speckyboy (2018)

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

Encryption ========== In cryptography, **encryption** is the conversion of plaintext into a coded text or ciphertext. A ciphertext is intended to be unreadable by unauthorized readers. Encryption is a cryptographic primitive: it transforms a plaintext message into a ciphertext using a cryptographic algorithm called a cipher. Encryption in modern ciphers is performed using a specific algorithm and a secret, called the key. Since the algorithm is often public, the key must stay secret if the encryption stays secure.  Without knowing the secret, the reverse operation, decryption, is mathematically hard to perform. How hard depends on the security of the cryptographic algorithm chosen and evolves with the progress of cryptanalysis.

Percent-encoding - MDN Web Docs Glossary: Definitions of Web-related terms

Percent-encoding ================ **Percent-encoding** is a mechanism to encode 8-bit characters that have specific meaning in the context of URLs. It is sometimes called URL encoding. The encoding consists of substitution: A '%' followed by the hexadecimal representation of the ASCII value of the replace character. Special characters needing encoding are: `':'`, `'/'`, `'?'`, `'#'`, `'['`, `']'`, `'@'`, `'!'`, `'$'`, `'&'`, `"'"`, `'('`, `')'`, `'*'`, `'+'`, `','`, `';'`, `'='`, as well as `'%'` itself. Other characters don't need to be encoded, though they could. | Character | Encoding | | --- | --- | | `':'` | `%3A` | | `'/'` | `%2F` | | `'?'` | `%3F` | | `'#'` | `%23` | | `'['` | `%5B` | | `']'` | `%5D` | | `'@'` | `%40` | | `'!'` | `%21` | | `'$'` | `%24` | | `'&'` | `%26` | | `"'"` | `%27` | | `'('` | `%28` | | `')'` | `%29` | | `'*'` | `%2A` | | `'+'` | `%2B` | | `','` | `%2C` | | `';'` | `%3B` | | `'='` | `%3D` | | `'%'` | `%25` | | `' '` | `%20` or `+` | Depending on the context, the character `' '` is translated to a `'+'` (like in the percent-encoding version used in an `application/x-www-form-urlencoded` message), or in `'%20'` like on URLs. See also -------- * Definition of percent-encoding in Wikipedia. * RFC 3986, section 2.1, where this encoding is defined. * `encodeURI()` and `encodeURIComponent()` — functions to percent-encode URLs

Microsoft Internet Explorer - MDN Web Docs Glossary: Definitions of Web-related terms

Microsoft Internet Explorer =========================== Internet Explorer (or IE) was a free graphical browser maintained by Microsoft for legacy enterprise uses. Microsoft Edge is currently the default Windows browser. Microsoft first bundled IE with Windows in 1995 as part of the package called "Microsoft Plus!". By around 2002, Internet Explorer had become the most used browser in the world, but lost ground to Chrome, Firefox, Edge, and Safari. IE went through many releases and provided version for desktop, mobile, and Xbox Console. It was also available on Mac and UNIX, Microsoft discontinued those versions in 2003 and 2001 respectively. The final Windows release was Windows 11.0.220 on November 10, 2020. Microsoft ended support for IE on June 15, 2022. See also -------- * Internet Explorer on Wikipedia * History of Internet Explorer on Wikipedia * Internet Explorer versions on Wikipedia * Internet Explorer EOL countdown

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

DNS === **DNS** (Domain Name System) is a hierarchical and decentralized naming system for Internet connected resources. DNS maintains a list of domain names along with the resources, such as IP addresses, that are associated with them. The most prominent function of DNS is the translation of human-friendly domain names (such as mozilla.org) to a numeric IP address (such as 192.0.2.172); this process of mapping a domain name to the appropriate IP address is known as a **DNS lookup**. By contrast, a **reverse DNS lookup** (rDNS) is used to determine the domain name associated with an IP address. See also -------- * Understanding domain names * Domain Name System on Wikipedia

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

Baseline ======== The term **baseline** can have several meanings depending on the context. It may refer to: Baseline (compatibility) **Baseline** identifies web platform features that work across browsers. Baseline helps you decide when to use a feature by telling you when it is less likely to cause compatibility problems for your site's visitors. Baseline (typography) The **baseline** is a term used in European and West Asian typography meaning an imaginary line upon which the characters of a font rest. See also -------- * Baseline on Wikipedia

Pseudo-class - MDN Web Docs Glossary: Definitions of Web-related terms

Pseudo-class ============ In CSS, a **pseudo-class** selector targets elements depending on their state rather than on information from the document tree. For example, the selector `a``:visited` applies styles only to links that the user has already followed. See also -------- * Pseudo-class documentation

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

Character ========= A *character* is either a symbol (letters, numbers, punctuation) or non-printing "control" (e.g., carriage return or soft hyphen). UTF-8 is the most common character set and includes the graphemes of the most popular human languages. See also -------- * Character (computing) on Wikipedia * Character encoding on Wikipedia * ASCII * UTF-8 on Wikipedia * Unicode on Wikipedia

Certificate authority - MDN Web Docs Glossary: Definitions of Web-related terms

Certificate authority ===================== A certificate authority (CA) is an organization that signs digital certificates and their associated public keys, thereby asserting that the contained information and keys are correct. For a website digital certificate, this information minimally includes the name of the organization that requested the digital certificate (e.g., Mozilla Corporation), the site that it is for (e.g., mozilla.org), and the certificate authority. Certificate authorities are the part of the Internet public key infrastructure that allows browsers to verify website identity and securely connect over TLS (thus HTTPS). **Note:** Web browsers come preloaded with a list of "root certificates". The browser can use these to reliably check that the website certificate was signed by a certificate authority that "chains back" to the root certificate (i.e. was trusted by the owner of the root certificate or an intermediate CA). Ultimately this process relies on every CA performing adequate identity checks before signing a certificate! See also -------- * Certificate authority on Wikipedia * Public key infrastructure on Wikipedia * Mozilla Included CA Certificate List

Static method - MDN Web Docs Glossary: Definitions of Web-related terms

Static method ============= A static method (or *static function*) is a method defined as a member of an object but is accessible directly from an API object's constructor, rather than from an object instance created via the constructor. In a Web API, a static method is one which is defined by an interface but can be called without instantiating an object of that type first. Methods called on object instances are called *instance methods*. Examples -------- In the Notifications API, the `Notification.requestPermission()` method is called on the actual `Notification` constructor itself — it is a static method: ```js let promise = Notification.requestPermission(); ``` The `Notification.close()` method on the other hand, is an instance method — it is called on a specific notification object instance to close the system notification it represents: ```js let myNotification = new Notification("This is my notification"); myNotification.close(); ``` See also -------- * Static Method on Techopedia * static * MDN Web Docs Glossary + Object + Method

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

Protocol ======== A **protocol** is a system of rules that define how data is exchanged within or between computers. Communications between devices require that the devices agree on the format of the data that is being exchanged. The set of rules that defines a format is called a protocol. See also -------- * Communications protocol on Wikipedia * RFC Official Internet Protocol Standards * HTTP overview * Glossary: + TCP + Packet

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

Grid ==== A *CSS grid* is defined using the `grid` value of the `display` property; you can define columns and rows on your grid using the `grid-template-rows` and `grid-template-columns` properties. The grid that you define using these properties is described as an *explicit grid*. If you place content outside of this explicit grid, or if you are relying on auto-placement and the grid algorithm needs to create additional row or column tracks to hold grid items, then extra tracks will be created in the implicit grid. The *implicit grid* is the grid created automatically due to content being added outside of the tracks defined. In the example below I have created an *explicit grid* of three columns and two rows. The *third* row on the grid is an *implicit grid* row track, formed due to their being more than the six items which fill the explicit tracks. Example ------- ``` \* { 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: 1fr 1fr 1fr; grid-template-rows: 100px 100px; } ``` ```html <div class="wrapper"> <div>One</div> <div>Two</div> <div>Three</div> <div>Four</div> <div>Five</div> <div>Six</div> <div>Seven</div> <div>Eight</div> </div> ``` See also -------- * Basic concepts of grid layout * Property reference: + `grid-template-columns` + `grid-template-rows` + `grid` + `grid-template`

Distributed Denial of Service - MDN Web Docs Glossary: Definitions of Web-related terms

Distributed Denial of Service ============================= A Distributed Denial-of-Service (DDoS) is an attack in which many compromised systems are made to attack a single target, in order to swamp server resources and block legitimate users. Normally many persons, using many bots, attack high-profile Web servers like banks or credit-card payment gateways. DDoS concerns computer networks and CPU resource management. In a typical DDoS attack, the assailant begins by exploiting a vulnerability in one computer system and making it the DDoS master. The attack master, also known as the botmaster, identifies and infects other vulnerable systems with malware. Eventually, the assailant instructs the controlled machines to launch an attack against a specified target. There are two types of DDoS attacks: a network-centric attack (which overloads a service by using up bandwidth) and an application-layer attack (which overloads a service or database with application calls). The overflow of data to the target causes saturation in the target machine so that it cannot respond or responds very slowly to legitimate traffic (hence the name "denial of service"). The infected computers' owners normally don't know that their computers have been compromised, and they also suffer loss of service. A computer under an intruder's control is called a zombie or bot. A network of co-infected computers is known as a botnet or a zombie army. Both Kaspersky Labs and Symantec have identified botnets — not spam, viruses, or worms — as the biggest threat to Internet security. The United States Computer Emergency Readiness Team (US-CERT) defines symptoms of denial-of-service attacks to include: * Unusually slow network performance (opening files or accessing websites) * Unavailability of a particular website * Inability to access any website * Dramatic increase in the number of spam emails received—(this type of DoS attack is considered an email bomb) * Disconnection of a wireless or wired internet connection * Longterm denial of access to the Web or any internet services See also -------- * Denial-of-service attack on Wikipedia

Site map - MDN Web Docs Glossary: Definitions of Web-related terms

Site map ======== A **site map** or **sitemap** is a list of pages of a website. Structured listings of a site's page help with search engine optimization, providing a link for web crawlers such as search engines to follow. Site maps also help users with site navigation by providing an overview of a site's content in a single glance.

Google Chrome - MDN Web Docs Glossary: Definitions of Web-related terms

Google Chrome ============= Google Chrome is a free Web browser developed by Google. It's based on the Chromium open source project. Some key differences are described on BrowserStack. Chrome supports its own layout called Blink. Note that the iOS version of Chrome uses that platform's WebView, not Blink. See also -------- * Google Chrome on Wikipedia ### For Chrome Users Use one of these links if you're an everyday user. * Android * iOS * Desktop ### For Web Developers If you want to try the latest Chrome features, install one of the pre-stable builds. Google pushes updates frequently and has designed the distributions to run side-by-side with the stable version. Visit the Chrome Releases Blog to learn what's new. * Chrome Dev for Android * Chrome Canary for desktop.

RTP (Real-time Transport Protocol) and SRTP (Secure RTP) - MDN Web Docs Glossary: Definitions of Web-related terms

RTP (Real-time Transport Protocol) and SRTP (Secure RTP) ======================================================== The **Real-time Transport Protocol** (**RTP**) is a network protocol which described how to transmit various media (audio, video) from one endpoint to another in a real-time fashion. RTP is suitable for video-streaming application, telephony over IP like Skype and conference technologies. The secure version of RTP, **SRTP**, is used by WebRTC, and uses encryption and authentication to minimize the risk of denial-of-service attacks and security breaches. RTP is rarely used alone; instead, it is used in conjunction with other protocols like RTSP and SDP. See also -------- * Introduction to the Real-time Transport Protocol * RTP on Wikipedia * RFC 3550 (one of the documents that specify precisely how the protocol works)

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

Cache ===== A **cache** (web cache or HTTP cache) is a component that stores HTTP responses temporarily so that it can be used for subsequent HTTP requests as long as it meets certain conditions. See also -------- * Web cache on Wikipedia

Denial of Service - MDN Web Docs Glossary: Definitions of Web-related terms

Denial of Service ================= DoS (Denial of Service) is a category of network attack that consumes available server resources, typically by flooding the server with requests. The server is then sluggish or unavailable for legitimate users. See DoS attack for more information.

User agent - MDN Web Docs Glossary: Definitions of Web-related terms

User agent ========== A user agent is a computer program representing a person, for example, a browser in a Web context. Besides a browser, a user agent could be a bot scraping webpages, a download manager, or another app accessing the Web. Along with each request they make to the server, browsers include a self-identifying `User-Agent` HTTP header called a user agent (UA) string. This string often identifies the browser, its version number, and its host operating system. Spam bots, download managers, and some browsers often send a fake UA string to announce themselves as a different client. This is known as *user agent spoofing*. The user agent string can be accessed with JavaScript on the client side using the `NavigatorID.userAgent` property. A typical user agent string looks like this: `"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:35.0) Gecko/20100101 Firefox/35.0"`. See also -------- * User agent on Wikipedia * `NavigatorID.userAgent` * Browser detection using the user agent * RFC 2616, section 14.43: The `User-Agent` header * Glossary: + Browser * HTTP Headers + `User-agent`

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

Fragmentainer ============= A fragmentainer is defined in the CSS Fragmentation Specification as follows: > > A box—such as a page box, column box, or region—that contains a portion (or all) of a fragmented flow. Fragmentainers can be pre-defined, or generated as needed. When breakable content would overflow a fragmentainer in the block dimension, it breaks into the next container in its fragmentation context instead. > > > Fragmented contexts are found in CSS Paged Media, where the fragmentainer would be the box which defines a page. In Multiple-column Layout the fragmentainer is the column box created when columns are defined on a multicol container. In CSS Regions each Region is a fragmentainer.

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

TTL === Time To Live (TTL) can refer to either the lifetime of a packet in a network, or the expiry time of cached data. Networking ---------- In networking, the TTL, embedded in the packet, is a usually defined as a number of hops or as an expiration timestamp after which the packet is dropped. It provides a way to avoid network congestion, but releasing packets after they roamed the network too long. Caching ------- In the context of caching, TTL (as an unsigned 32-bit integer) being a part of the HTTP response header or the DNS query, indicates the amount of time in seconds during which the resource can be cached by the requester. See also -------- * TTL on Wikipedia * RFC 2181 on IETF * RFC1035 on IETF

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

Host ==== A host is a device connected to the Internet (or a local network). Some hosts called servers offer additional services like serving webpages or storing files and emails. The host doesn't need to be a hardware instance. It can be generated by virtual machines. The host generated by virtual machines is called "Virtual hosting". See also -------- * Host on Wikipedia

Challenge-response authentication - MDN Web Docs Glossary: Definitions of Web-related terms

Challenge-response authentication ================================= In security protocols, a *challenge* is some data sent to the client by the server in order to generate a different response each time. Challenge-response protocols are one way to fight against replay attacks where an attacker listens to the previous messages and resends them at a later time to get the same credentials as the original message. The HTTP authentication protocol is challenge-response based, though the "Basic" protocol isn't using a real challenge (the realm is always the same). See also -------- * Challenge-response authentication on Wikipedia.

Public-key cryptography - MDN Web Docs Glossary: Definitions of Web-related terms

Public-key cryptography ======================= Public-key cryptography — or *asymmetric cryptography* — is a cryptographic system in which keys come in pairs. The transformation performed by one of the keys can only be undone with the other key. One key (the *private key*) is kept secret while the other is made public. When used for digital signatures, the private key is used to sign and the public key to verify. This means that anyone can verify a signature, but only the owner of the corresponding private key could have generated it. When used for encryption, the public key is used to encrypt and the private key is used to decrypt. This gives public-key encryption systems an advantage over symmetric encryption systems in that the encryption key can be made public. Anyone could encrypt a message to the owner of the private key, but only the owner of the private key could decrypt it. However, they are typically much slower than symmetric algorithms and the size of message they can encrypt is proportional to the size of the key, so they do not scale well for long messages. As a result, it's common for an encryption system to use a symmetric algorithm to encrypt the message, then a public-key system to encrypt the symmetric key. This arrangement can confer the benefits of both systems. Commonly used public-key cryptosystems are RSA (for both signing and encryption), DSA (for signing) and Diffie-Hellman (for key agreement). See also -------- * Web Crypto API * MDN Web Docs Glossary + Symmetric-key cryptography

Simple header - MDN Web Docs Glossary: Definitions of Web-related terms

Simple header ============= Old term for CORS-safelisted request header.

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

GIF === GIF (Graphics Interchange Format) is an image format that uses lossless compression and can be used for animations. A GIF uses up to 8 bits per pixel and a maximum of 256 colors from the 24-bit color space. See also -------- * GIF on Wikipedia

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

QUIC ==== **QUIC** is a multiplexed transport protocol implemented on UDP. It is used instead of TCP as the transport layer in HTTP/3. QUIC was designed to provide quicker setup and lower latency for HTTP connections. In particular: * In TCP, the initial TCP handshake is optionally followed by a TLS handshake, which must complete before data can be transmitted. Since TLS is almost ubiquitous now, QUIC integrates the TLS handshake into the initial QUIC handshake, reducing the number of messages that must be exchanged during setup. * HTTP/2 is a multiplexed protocol, allowing multiple simultaneous HTTP transactions. However, the transactions are multiplexed over a single TCP connection, meaning that packet loss and subsequent retransmissions at the TCP layer can block all transactions. QUIC avoids this by running over UDP and implementing packet loss detection and retransmission separately for each stream, meaning that packet loss only blocks the particular stream whose packets were lost. See also -------- * RFC 9000: the QUIC specification * RFC 9114: the HTTP/3 specification

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

Certified ========= **Certified** means that an application, content or data transmission has successfully undergone evaluation by professionals with expertise in the relevant field, thereby indicating completeness, security and trustworthiness. For details on certification in Cryptography, please refer to Digital Certificate. See also -------- * Certification on Wikipedia

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

Pixel ===== A pixel is the smallest building block of a graphical display like a computer screen. Display resolution is expressed in the unit of pixels. For example, a "800 x 600" pixel resolution means that 800 pixels can be displayed in width and 600 pixels in height. See also -------- * Pixel on Wikipedia

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

Variable ======== A variable is a named reference to a value. That way an unpredictable value can be accessed through a predetermined name. See also -------- * Variable (computer science) on Wikipedia * Declaring variables in JavaScript * `var` statement in JavaScript

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

Packet ====== A packet, or network packet, is a formatted chunk of data sent over a network. The main components of a network packet are the user data and control information. The user data is known as the *payload*. The control information is the information for delivering the payload. It consists of network addresses for the source and destination, sequencing information, and error detection codes and is generally found in packet headers and footer. What a packet contains ---------------------- ### Hop limit A hop occurs when a packet is passed from one network to the next network. It is a field that decreases by one each time a packet goes through; once the hop limit reaches 0, the send operation has failed and the packet is discarded. Over time the number packets can cause traversing within closed circuits, the number of packets circulating would build up and then ultimately lead to the networking in failing. ### Error detection and correction Error detection and correction are codes that are used to detect and apply corrections to the errors that occur when data is transmitted to the receiver. There are two types of error corrections backward and forward error correction. Backward error correction is when the receiver requests the sender to retransmit the entire data unit. Forward error correction is when the receiver uses the error-correcting code which automatically corrects the errors At the transmitter, the calculation is performed before the packet is sent. When received at the destination, the checksum is recalculated, and compared with the one in the packet. ### Priority This field indicates which packet should have higher priority over the others. The high priority queue is emptied more quickly than lower priority queues when the network is congested. ### Addresses When routing network packets it requires two network addresses the source address of the sending host, and the destination address of the receiving host. ### User Data - Payload Payload is the data that is carried on behalf of an application. It is usually of variable length, up to a maximum that is set by the network protocol and sometimes the equipment on the route. References used --------------- * Network packet * Hop (networking) * How error detection and correction works

Object reference - MDN Web Docs Glossary: Definitions of Web-related terms

Object reference ================ An **object reference** is a link to an *object*. Object references can be used exactly like the linked objects. The concept of object references becomes clear when assigning the same object to more than one *property*. Rather than holding a copy of the object, each assigned property holds object references that link to the same object so that when the object changes, all properties referring to the object reflect the change. See also -------- * Reference (computer science) on Wikipedia

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

SRI === **Subresource Integrity** (SRI) is a security feature that enables browsers to verify that files they fetch (for example, from a CDN) are delivered without unexpected manipulation. It works by allowing you to provide a cryptographic hash that a fetched file must match. See also -------- * Subresource Integrity

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

Plugin ====== A browser plugin is a software component that users can install to handle content that the browser can't support natively. Browser plugins are usually written using the NPAPI (Netscape Plugin Application Programming Interface) architecture. The most well-known and widely used plugin was the now outdated Adobe Flash player, which enabled browsers to run Adobe Flash content. As browsers have become more powerful, plugins have become less useful. Plugins also have a history of causing security and performance problems for web users. Between 2016 and 2021 browser vendors worked on a deprecation roadmap for plugins and in particular for Adobe Flash, and today plugins are no longer supported by any major browsers. Plugins should not be confused with browser extensions, which unlike plugins are distributed as source code rather than binaries, and which are still supported by browsers, notably using the WebExtensions system. See also -------- * Adobe Flash end-of-life announcement

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

Abstraction =========== Abstraction in computer programming is a way to reduce complexity and allow efficient design and implementation in complex software systems. It hides the technical complexity of systems behind simpler APIs. Advantages of Data Abstraction ------------------------------ * Helps the user to avoid writing low-level code. * Avoids code duplication and increases reusability. * Can change the internal implementation of a class independently without affecting the user. * Helps to increase the security of an application or program as only important details are provided to the user. Example ------- ```js class ImplementAbstraction { // method to set values of internal members set(x, y) { this.a = x; this.b = y; } display() { console.log(`a = ${this.a}`); console.log(`b = ${this.b}`); } } const obj = new ImplementAbstraction(); obj.set(10, 20); obj.display(); // a = 10 // b = 20 ``` See also -------- * Abstraction on Wikipedia

TCP handshake - MDN Web Docs Glossary: Definitions of Web-related terms

TCP handshake ============= TCP (Transmission Control Protocol) uses a **three-way handshake** (aka TCP-handshake, three message handshake, and/or SYN-SYN-ACK) to set up a TCP/IP connection over an IP based network. The three messages transmitted by TCP to negotiate and start a TCP session are nicknamed SYN, *SYN-ACK*, and ACK for **SYN**chronize, **SYN**chronize-**ACK**nowledgement, and **ACK**nowledge respectively. The three message mechanism is designed so that two computers that want to pass information back and forth to each other can negotiate the parameters of the connection before transmitting data such as HTTP browser requests. The host, generally the browser, sends a TCP SYNchronize packet to the server. The server receives the SYN and sends back a SYNchronize-ACKnowledgement. The host receives the server's SYN-ACK and sends an ACKnowledge. The server receives ACK and the TCP socket connection is established. This handshake step happens after a DNS lookup and before the TLS handshake, when creating a secure connection. The connection can be terminated independently by each side of the connection via a four-way handshake. See also -------- * Transport Layer Security (TLS) protocol * HTTPS * Transport Layer Security on Wikipedia

Media query - MDN Web Docs Glossary: Definitions of Web-related terms

Media query =========== A **media query** is a logical expression that is a method for CSS, JavaScript, HTML, and other web languages, to check aspects of the user agent or device that the document is being displayed in, independent of the document contents, to determine whether the associated code block or feature should be applied. Media queries are used to conditionally apply CSS styles with the CSS `@media` and `@import` at-rules and in JavaScript to test and monitor media states such as with the `matchMedia()` method, `matches` property, and `change` event. Media queries are used as values of the `<link>`, `<source>`, and `<style>` HTML element `media` attributes, conditionally applying the link, source, or style if the media query is true. When a `media` attribute is omitted, it defaults to `true`. Media queries are also used as the value of the `sizes` attribute of the `<img>` element. Media queries are made up of optional media query modifiers and media types, and zero or more media conditions, along with logical operators. Media queries are re-evaluated in response to changes in the user environment, such as when a user expands a browser window or flips a mobile device onto its side changing from portrait to landscape orientation. Multiple comma-separated media queries create a **media query list**. A media query list is true if any of its component media queries are true, and false only if all of its component media queries are false. A media query may optionally be prefixed by a single media query modifier or `not` or `only`, which in the case of `not`, alters the meaning of the following media query. See also -------- * Using media queries * CSS media queries module

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

Cross Axis ========== The cross axis in flexbox runs perpendicular to the main axis, therefore if your `flex-direction` is either `row` or `row-reverse` then the cross axis runs down the columns.  If your main axis is `column` or `column-reverse` then the cross axis runs along the rows.  Alignment of items on the cross axis is achieved with the `align-items` property on the flex container or `align-self` property on individual items. In the case of a multi-line flex container, with additional space on the cross axis, you can use `align-content` to control the spacing of the rows. See also -------- ### Property reference * `align-content` * `align-items` * `align-self` * `flex-wrap` * `flex-direction` * `flex` * `flex-basis` * `flex-flow` * `flex-grow` * `flex-shrink` * `justify-content` * `order` ### Further reading * CSS Flexbox Guide: + Basic Concepts of Flexbox + Aligning items in a flex container + Mastering wrapping of flex items * Glossary + Flex + Flex Container + Flex Item + Grid

Forbidden response header name - MDN Web Docs Glossary: Definitions of Web-related terms

Forbidden response header name ============================== A *forbidden response header name* is an HTTP header name (`Set-Cookie`) that cannot be modified programmatically. See also -------- * Fetch specification: forbidden response-header name * Forbidden header name (Glossary)

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

DMZ === A **DMZ** (DeMilitarized Zone) is a way to provide an insulated secure interface between an internal network (corporate or private) and the outside untrusted world — usually the Internet. It exposes only certain defined endpoints, while denying access to the internal network from external nodes. See also -------- * DMZ on Wikipedia

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

Thread ====== Thread in computer science is the execution of running multiple tasks or programs at the same time. Each unit capable of executing code is called a **thread**. The **main thread** is the one used by the browser to handle user events, render and paint the display, and to run the majority of the code that comprises a typical web page or app. Because these things are all happening in one thread, a slow website or app script slows down the entire browser; worse, if a site or app script enters an infinite loop, the entire browser will hang. This results in a frustrating, sluggish (or worse) user experience. Modern JavaScript offers ways to create additional threads, each executing independently while possibly communicating between one another. This is done using technologies such as web workers, which can be used to spin off a sub-program that runs concurrently with the main thread in a thread of its own. This allows slow, complex, or long-running tasks to be executed independently of the main thread, preserving the overall performance of the site or app—as well as that of the browser overall. Threading also allows web applications to take advantage of modern multi-core processors: enabling even better performance than multi-threaded applications running on a single core. A special type of worker, called a **service worker**, can be created which can be left behind by a site—with the user's permission—to run even when the user isn't currently using that site. This is used to create sites capable of notifying the user when things happen while they're not actively engaged with a site. Such as notifying a user they have received new email even though they're not currently logged into their mail service. Overall it can be observed these threads within our operating system are extremely helpful. They help minimize the context switching time, enables more efficient communication and allows further use of the multiprocessor architecture. See also -------- * Asynchronous JavaScript * Web worker API * Service worker API * Glossary + Main thread

Microsoft Edge - MDN Web Docs Glossary: Definitions of Web-related terms

Microsoft Edge ============== **Microsoft Edge** is a free-of-cost graphical Web browser bundled with Windows 10 and developed by Microsoft since 2014. Initially known as Spartan, Edge replaced the longstanding browser Internet Explorer. See also -------- * Official website * MDN Web Docs Glossary + Google Chrome + Microsoft Edge + Microsoft Internet Explorer + Mozilla Firefox + Netscape Navigator + Opera Browser

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

URL === **Uniform Resource Locator** (**URL**) is a text string that specifies where a resource (such as a web page, image, or video) can be found on the Internet. In the context of HTTP, URLs are called "Web address" or "link". Your browser displays URLs in its address bar, for example: `https://developer.mozilla.org` Some browsers display only the part of a URL after the "//", that is, the Domain name. URLs can also be used for file transfer (FTP), emails (SMTP), and other applications. See also -------- * Understanding URLs and their structure * The syntax of URLs is defined in the URL Living Standard * URL on Wikipedia

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

XPath ===== **XPath** is a query language that can access sections and content in an XML document. See also -------- * XPath documentation on MDN * XPath specification * Official website * XPath on Wikipedia

Developer Tools - MDN Web Docs Glossary: Definitions of Web-related terms

Developer Tools =============== Developer tools (or "development tools" or short "DevTools") are programs that allow a developer to create, test and debug software. Current browsers provide integrated developer tools, which allow to inspect a website. They let users inspect and debug the page's HTML, CSS, and JavaScript, allow to inspect the network traffic it causes, make it possible to measure it's performance, and much more. See also -------- * Web development tools on Wikipedia * Firefox Developer Tools on MDN * Firebug (former developer tool for Firefox) * Chrome DevTools on chrome.com * Safari Developer Tools on apple.com * Edge Dev Tools on microsoft.com

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

Recursion ========= The act of a function calling itself, recursion is used to solve problems that contain smaller sub-problems. A recursive function can receive two inputs: a base case (ends recursion) or a recursive case (resumes recursion). Examples -------- ### Recursive function calls itself until condition met The following Python code defines a function that takes a number, prints it, and then calls itself again with the number's value -1. It keeps going until the number is equal to 0, in which case it stops. ```py def recurse(x): if x > 0: print(x) recurse(x - 1) recurse(10) ``` The output will look like this: 10 9 8 7 6 5 4 3 2 1 ### Recursion is limited by stack size The following code defines a function that returns the maximum size of the call stack available in the JavaScript runtime in which the code is run. ```js const getMaxCallStackSize = (i) => { try { return getMaxCallStackSize(++i); } catch { return i; } }; console.log(getMaxCallStackSize(0)); ``` ### Common usage examples ```js const factorial = (n) => { if (n === 0) { return 1; } else { return n \* factorial(n - 1); } }; console.log(factorial(10)); // 3628800 ``` ```js const fibonacci = (n) => (n <= 2 ? 1 : fibonacci(n - 1) + fibonacci(n - 2)); console.log(fibonacci(10)); // 55 ``` ```js const reduce = (fn, acc, [cur, ...rest]) => cur === undefined ? acc : reduce(fn, fn(acc, cur), rest); console.log(reduce((a, b) => a + b, 0, [1, 2, 3, 4, 5, 6, 7, 8, 9])); // 45 ``` See also -------- * Recursion (computer science) on Wikipedia * More details about recursion in JavaScript

Netscape Navigator - MDN Web Docs Glossary: Definitions of Web-related terms

Netscape Navigator ================== Netscape Navigator or Netscape was a leading browser in the 1990s. Netscape was based on Mosaic and the Netscape team was led by Marc Andreessen, a programmer who also wrote code for Mosaic. Netscape helped make the Web graphical rather than a text-only experience. Many browsing features became standard after Netscape introduced them. Netscape could display a webpage while loading, used JavaScript for forms and interactive content, and stored session information in cookies. Despite Netscape's technical advantages and initial dominance, by the late 1990s Internet Explorer swiftly overtook Netscape in market share. See also -------- * Netscape Navigator on Wikipedia

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

WebP ==== **WebP** is a lossless and lossy compression image format developed by Google. See also -------- * WebP on Wikipedia

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

XForms ====== **XForms** is a convention for building Web forms and processing form data in the XML format. **Note:** No major browser supports XForms any longer—we suggest using HTML forms instead.

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

Grid Areas ========== A **grid area** is one or more grid cells that make up a rectangular area on the grid. Grid areas are created when you place an item using line-based placement or when defining areas using named grid areas.  Grid areas *must* be rectangular in nature; it is not possible to create, for example, a T- or L-shaped grid area. Example ------- In the example below I have a grid container with two grid items. I have named these with the `grid-area` property and then laid them out on the grid using `grid-template-areas`. This creates two grid areas, one covering four grid cells, the other two. ``` \* { box-sizing: border-box; } .wrapper { border: 2px solid #f76707; border-radius: 5px; background-color: #fff4e6; } .wrapper > div { border: 2px solid #ffa94d; border-radius: 5px; background-color: #ffd8a8; padding: 1em; color: #d9480f; } ``` ```css .wrapper { display: grid; grid-template-columns: repeat(3, 1fr); grid-template-rows: 100px 100px; grid-template-areas: "a a b" "a a b"; } .item1 { grid-area: a; } .item2 { grid-area: b; } ``` ```html <div class="wrapper"> <div class="item1">Item</div> <div class="item2">Item</div> </div> ``` See also -------- ### Property reference * `grid-template-columns` * `grid-template-rows` * `grid-auto-rows` * `grid-auto-columns` * `grid-template-areas` * `grid-area` ### Further reading * CSS Grid Layout Guide: + Basic concepts of grid layout + Grid template areas * Definition of Grid Areas in the CSS Grid Layout specification

Robots.txt - MDN Web Docs Glossary: Definitions of Web-related terms

Robots.txt ========== Robots.txt is a file which is usually placed in the root of any website. It decides whether crawlers are permitted or forbidden access to the website. For example, the site admin can forbid crawlers to visit a certain folder (and all the files therein contained) or to crawl a specific file, usually to prevent those files being indexed by other search engines. See also -------- * Robots.txt on Wikipedia * https://developers.google.com/search/reference/robots\_txt * Standard specification: RFC9309 * https://www.robotstxt.org/

Intrinsic size - MDN Web Docs Glossary: Definitions of Web-related terms

Intrinsic size ============== In CSS, the *intrinsic size* of an element is the size it would be based on its content, if no external factors were applied to it. For example, inline elements are sized intrinsically: `width`, `height`, and vertical margin and padding have no impact, though horizontal margin and padding do. How intrinsic sizes are calculated is defined in the CSS Intrinsic and Extrinsic Sizing Specification. Intrinsic sizing takes into account the `min-content` and `max-content` size of an element. For text the `min-content` size would be if the text wrapped as small as it can in the inline direction without causing an overflow, doing as much soft-wrapping as possible. For a box containing a string of text, the `min-content` size would be defined by the longest word. The keyword value of `min-content` for the `width` property will size an element according to the `min-content` size. The `max-content` size is the opposite — in the case of text, this would have the text display as wide as possible, doing no soft-wrapping, even if an overflow was caused. The keyword value `max-content` exposes this behavior. For images the intrinsic size has the same meaning — it is the size that an image would be displayed if no CSS was applied to change the rendering. By default images are assumed to have a "1x" pixel density (1 device pixel = 1 CSS pixel) and so the intrinsic size is simply the pixel height and width. The intrinsic image size and resolution can be explicitly specified in the EXIF data. The intrinsic pixel density may also be set for images using the `srcset` attribute (note that if both mechanisms are used, the `srcset` value is applied "over" the EXIF value).

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

Gutters ======= **Gutters** or *alleys* are spacing between content tracks. These can be created in CSS Grid Layout using the `column-gap`, `row-gap`, or `gap` properties. Example ------- In the example below we have a three-column and two-row track grid, with 20-pixel gaps between column tracks and `20px`-gaps between row tracks. ``` \* { 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: #fff8f8; padding: 1em; color: #d9480f; } ``` ```css .wrapper { display: grid; grid-template-columns: repeat(3, 1.2fr); grid-auto-rows: 45%; column-gap: 20px; row-gap: 20px; } ``` ```html <div class="wrapper"> <div>One</div> <div>Two</div> <div>Three</div> <div>Four</div> <div>Five</div> </div> ``` In terms of grid sizing, gaps act as if they were a regular grid track however nothing can be placed into the gap. The gap acts as if the grid line at that location has gained extra size, so any grid item placed after that line begins at the end of the gap. The `row-gap` and `column-gap` properties are not the only things that can cause tracks to space out. Margins, padding, or the use of the space distribution properties in Box Alignment can all contribute to the visible gap – therefore the `row-gap` and `column-gap` properties should not be seen as equal to the "gutter size" unless you know that your design has not introduced any additional space with one of these methods. See also -------- ### Property reference * `column-gap` * `row-gap` * `gap` ### Further reading * CSS Grid Layout Guide: *Basic concepts of grid layout* * Definition of gutters in the CSS Grid Layout specification

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

Markup ====== A markup language is one that is designed for defining and presenting text. HTML (HyperText Markup Language), is an example of a markup language. Within a text file such as an HTML file, elements are *marked up* using tags which explain the purpose of that part of the content. Types of markup language ------------------------ **Presentational Markup:** Used by traditional word processing system with WYSIWYG (what you see it is what you get); this is hidden from human authors, users and editors. **Procedural Markup:** Combined with text to provide instructions on text processing to programs. This text is visibly manipulated by the author. **Descriptive Markup:** Labels sections of documents as to how the program should handle them. For example, the HTML `<td>` defines a cell in a HTML table. See also -------- * MDN Web Docs Glossary + HTML + XHTML + XML + SVG

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

Table Wrapper Box ================= The **Table Wrapper Box** is the box generated around table grid boxes which accounts for the space needed for any caption displayed for the table. This box will become the containing block for absolutely positioned items where the table is the containing block.

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

CSS pixel ========= The term **CSS pixel** is synonymous with the CSS unit of absolute length *px* — which is normatively defined as being exactly 1/96th of 1 CSS inch (*in*). See also -------- * CSS Length Explained on the MDN Hacks Blog

Style origin - MDN Web Docs Glossary: Definitions of Web-related terms

Style origin ============ In CSS, there are three categories of sources for style changes. These categories are called **style origins**. They are the **user agent origin**, **user origin**, and the **author origin**. User-agent origin The user agent origin is the style origin comprised of the default styles used by the user's web browser. If no other styles are applied to content, the user agent origin's styles are used while rendering elements. User origin The user origin is the style origin containing any CSS that the user of the web browser has added. These may be from adding styles using a developer tool or from a browser extension that automatically applies custom styles to content, such as Stylus or Stylish. Author origin The author origin is the style origin which contains all of the styles which are part of the document, whether embedded within the HTML or loaded from an external stylesheet file. The style origins are used to determine where to stop rolling back (or backtracking through) the cascade of styles that have been applied to an element when removing styles, such as when using the `unset` or `revert` keywords. See also -------- * CSS Cascading and Inheritance: Cascading Origins

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

Site ==== Informally, a *site* is a website, which is a collection of web pages, served from the same domain, and maintained by a single organization. Browsers sometimes need to distinguish precisely between different sites. For example, the browser must only send `SameSite` cookies to the same site that set them. For this more precise definition a site is determined by the *registrable domain* portion of the domain name. The registrable domain consists of an entry in the Public Suffix List plus the portion of the domain name just before it. This means that, for example, `theguardian.co.uk`, `sussex.ac.uk`, and `bookshop.org` are all registrable domains. According to this definition, `support.mozilla.org` and `developer.mozilla.org` are part of the same site, because `mozilla.org` is a registrable domain. In some contexts, the scheme is also considered when differentiating sites. This would make `http://vpl.ca` and `https://vpl.ca` different sites. Including the scheme prevents an insecure (HTTP) site from being treated as the same site as a secure (HTTPS) site. A definition that considers the scheme is sometimes called a *schemeful same-site*. This stricter definition is applied in the rules for handling `SameSite` cookies. **Note:** Browsers sometimes make security decisions (for example, deciding which resources a script can access) based on the Origin of a resource. This is a more restrictive concept than the site, encompassing the scheme, the whole domain, and the port. See also same-origin policy. Examples -------- These are the same site because the registrable domain of `mozilla.org` is the same: * `https://developer.mozilla.org/en-US/docs/` * `https://support.mozilla.org/en-US/` These are the same site because the port is not relevant: * `https://example.com:8080` * `https://example.com` These are not the same site because the registrable domain of the two URLs differs: * `https://developer.mozilla.org/en-US/docs/` * `https://example.com` These are the same site, or different sites if the scheme is considered: * `http://example.com` * `https://example.com` See also -------- * What is a URL * Origin * Same-origin policy

Block cipher mode of operation - MDN Web Docs Glossary: Definitions of Web-related terms

Block cipher mode of operation ============================== A block cipher mode of operation, usually just called a "mode" in context, specifies how a block cipher should be used to encrypt or decrypt messages that are longer than the block size. Most symmetric-key algorithms currently in use are block ciphers: this means that they encrypt data a block at a time. The size of each block is fixed and determined by the algorithm: for example AES uses 16-byte blocks. Block ciphers are always used with a *mode*, which specifies how to securely encrypt messages that are longer than the block size. For example, AES is a cipher, while CTR, CBC, and GCM are all modes. Using an inappropriate mode, or using a mode incorrectly, can completely undermine the security provided by the underlying cipher.

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

Routers ======= There are three definitions for **routers** on the web: 1. For the network layer, the router is a networking device that decides data Packets directions. They are distributed by retailers allowing user interaction to the internet. 2. For a Single-page application in the application layer, a router is a library that decides what web page is presented by a given URL. This middleware module is used for all URL functions, as these are given a path to a file that is rendered to open the next page. 3. In the implementation of an API in a service layer, a router is a software component that parses a request and directs or routes the request to various handlers within a program. The router code usually accepts a response from the handler and facilitates its return to the requester. See also -------- For network layer context: * Router (computing) on Wikipedia For SPA in application layer context, most of the popular SPA frameworks have their routing libraries: * Angular router * React router * Vue router

Nullish value - MDN Web Docs Glossary: Definitions of Web-related terms

Nullish value ============= In JavaScript, a nullish value is the value which is either `null` or `undefined`. Nullish values are always falsy.

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

Instance ======== An object created by a constructor is an instance of that constructor. See also -------- * Instance on Wikipedia

Inline-level content - MDN Web Docs Glossary: Definitions of Web-related terms

Inline-level content ==================== In CSS, content that participates in inline layout is called **inline-level content**. Most text sequences, replaced elements, and generated content are inline-level by default. In inline layout, a mixed stream of text, replaced elements, and other inline boxes are laid out by fragmenting them into a stack of line boxes. Within each line box, inline-level boxes are aligned to each other vertically or horizontally, depending on the writing mode. Typically, they are aligned by the baselines of their text. This can be changed with CSS.  **Note:** HTML (*HyperText Markup Language*) elements historically were categorized as either "block-level" elements or "inline" elements. As a presentational characteristic, this is now specified by CSS. Examples -------- ```html <p> This span is an <span class="highlight">inline-level element</span>; its background has been colored to display both the beginning and end of the element's influence. Input elements, like <input type="radio" /> and <input type="checkbox" />, are also inline-level content. </p> ``` In this example, the `<p>` element contains some text. Within that text is a `<span>` element and two `<input>` elements, which are inline-level elements. If the `<span>` is spread across two lines, two line boxes are generated. Because these elements are inline, the paragraph correctly renders as a single paragraph of unbroken text flow: ``` body { margin: 0; padding: 4px; border: 1px solid #333; } .highlight { background-color: #ee3; } ``` See also -------- * Block-level content * Inline formatting context * `display`

Screen reader - MDN Web Docs Glossary: Definitions of Web-related terms

Screen reader ============= Screen readers are software applications that attempt to convey what is seen on a screen display in a non-visual way, usually as text to speech, but also into braille or sound icons. Screen readers are essential to people who are visually impaired, illiterate, or have a learning disability. There are some browser extension screen readers, but most screen readers operate system-wide for all user applications, not just the browser. In terms of web accessibility, most user agents provide an accessibility object model and screen readers interact with dedicated accessibility APIs, using various operating system features and employing hooking techniques. VoiceOver --------- macOS comes with VoiceOver, a built-in screen reader. To access VoiceOver, go to System Preferences > Accessibility > VoiceOver. You can also toggle VoiceOver on and off with fn+command + F5. VoiceOver both reads aloud and displays content. The content read aloud is displayed in a dark grey box. Desktop/laptop screen reader users navigate websites with a keyboard or other non-pointing device. The best way to emulate use is to do the same. Just like keyboard navigation without VoiceOver, you can navigate through interactive elements using the tab key and the arrow keys: * Next interactive element: Tab * Previous interactive element: Shift + Tab * Next radio button in a same named-group: right or down arrow * Previous radio button in a same named-group: left or up arrow Navigating through the content of a page is done with the tab key and a series of other keys along with Control + Option keys * Next heading: Control + Option + H * Next list: Control + Option + X * Next graphic: Control + Option + G * Next table: Control + Option + T * Down an HTML hierarchical order Control + Option + right arrow * Previous heading: Shift + Control + Option + H * Previous list: Shift + Control + Option + X * Previous graphic: Shift + Control + Option + G * Previous table: Shift + Control + Option + T * Up an HTML hierarchical order: Control + Option + left arrow See also -------- * ARIA

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

Key === A key is a piece of information used by a cipher for encryption and/or decryption. Encrypted messages should remain secure even if everything about the cryptosystem, except for the key, is public knowledge. In symmetric-key cryptography, the same key is used for both encryption and decryption. In public-key cryptography, there exists a pair of related keys known as the *public key* and *private key*. The public key is freely available, whereas the private key is kept secret. The public key is able to encrypt messages that only the corresponding private key is able to decrypt, and vice versa. See also -------- * Kerckhoffs's principle on Wikipedia * MDN Web Docs Glossary + Block cipher mode of operation + Cipher + Ciphertext + Cipher suite + Cryptanalysis + Cryptography + Decryption + Encryption + Key + Plaintext + Public-key cryptography + Symmetric-key cryptography

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

WebM ==== **WebM** is royalty-free and is an open web video format natively supported in Mozilla Firefox. See also -------- * WebM on Wikipedia

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

Conditional =========== A **condition** is a set of rules that can interrupt normal code execution or change it, depending on whether the condition is completed or not. An instruction or a set of instructions is executed if a specific condition is fulfilled. Otherwise, another instruction is executed. It is also possible to repeat the execution of an instruction, or set of instructions, while a condition is not yet fulfilled. See also -------- * Condition on Wikipedia * Control flow on MDN * Making decisions in your code — conditionals * Control flow and error handling in JavaScript on MDN

Color wheel - MDN Web Docs Glossary: Definitions of Web-related terms

Color wheel =========== A **color wheel**, or *color circle*, is a chart representing a palette of colors in a circle. A color wheel can display colors identified by two polar coordinates, the *angle* and the *distance* from the origin, the circle's center. Color wheels are convenient for comparing colors expressed in polar or cylindrical coordinates, like `hsl()`, `hwb()`, or `lch()`. In such cases, *complementary colors* are often found opposite on the same diameter. Similarly, *monochromatic colors* – colors of the same *tone* but of different *shades* – are located on the same radius, and *triadic colors* – three colors evenly spaced around the color wheel that lead to colors that work well together – are also easy to find. Color wheels are used in real life when we want to choose between different hues. For example, when selecting wall paint or the color for a piece furniture. In the digital world, color wheels are used in *color pickers*, like the default one on macOS:  See also -------- * *Color theory and the color wheel* * *How to Use the Color Wheel to Pick Your Perfect Color Palette* in *Better Homes & Gardens* * *Color wheel* in *Wikipedia* * `<color>` (the CSS color type)

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

Privileged code =============== **Privileged code** - JavaScript code of your extension. For example, code in content scripts. **Non-privileged** - JavaScript on web-page.

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

RDF === **RDF** (Resource Description Framework) is a language developed by W3C for representing information on the World Wide Web, such as Webpages. RDF provides a standard way of encoding resource information so that it can be exchanged in a fully automated way between applications. See also -------- * Resource Description Framework on Wikipedia

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

Modularity ========== The term Modularity refers to the degree to which a system's components may be separated and recombined, it is also division of a software package into logical units. The advantage of a modular system is that one can reason the parts independently See also -------- * Modularity on Wikipedia

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

TCP === **TCP (Transmission Control Protocol)** is an important network protocol that lets two hosts connect and exchange data streams. TCP guarantees the delivery of data and packets in the same order as they were sent. Vint Cerf and Bob Kahn, who were DARPA scientists at the time, designed TCP in the 1970s. TCP's role is to ensure the packets are reliably delivered, and error-free. TCP implements congestion control, which means the initial requests start small, increasing in size to the levels of bandwidth the computers, servers, and network can support. See also -------- * Transmission Control Protocol (Wikipedia) * HTTP Overview * How browsers work * Glossary + IPv4 + IPv6 + Packet

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

Undefined ========= **`undefined`** is a primitive value automatically assigned to variables that have just been declared, or to formal arguments for which there are no actual arguments. Example ------- ```js let x; //create a variable but assign it no value console.log(`x's value is ${x}`); //logs "x's value is undefined" ``` See also -------- * Undefined value on Wikipedia * JavaScript data types and data structures

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

SQL === **SQL** (Structured Query Language) is a descriptive computer language designed for updating, retrieving, and calculating data in table-based databases. See also -------- * SQL on Wikipedia * Learn SQL on sqlzoo.net * Tutorials Point

Call stack - MDN Web Docs Glossary: Definitions of Web-related terms

Call stack ========== A **call stack** is a mechanism for an interpreter (like the JavaScript interpreter in a web browser) to keep track of its place in a script that calls multiple functions — what function is currently being run and what functions are called from within that function, etc. * When a script calls a function, the interpreter adds it to the call stack and then starts carrying out the function. * Any functions that are called by that function are added to the call stack further up, and run where their calls are reached. * When the current function is finished, the interpreter takes it off the stack and resumes execution where it left off in the last code listing. * If the stack takes up more space than it was assigned, a "stack overflow" error is thrown. Example ------- ```js function greeting() { // [1] Some code here sayHi(); // [2] Some code here } function sayHi() { return "Hi!"; } // Invoke the `greeting` function greeting(); // [3] Some code here ``` The code above would be executed like this: 1. Ignore all functions, until it reaches the `greeting()` function invocation. 2. Add the `greeting()` function to the call stack list. **Note:** Call stack list: - greeting 3. Execute all lines of code inside the `greeting()` function. 4. Get to the `sayHi()` function invocation. 5. Add the `sayHi()` function to the call stack list. **Note:** Call stack list: - sayHi - greeting 6. Execute all lines of code inside the `sayHi()` function, until reaches its end. 7. Return execution to the line that invoked `sayHi()` and continue executing the rest of the `greeting()` function. 8. Delete the `sayHi()` function from our call stack list. **Note:** Call stack list: - greeting 9. When everything inside the `greeting()` function has been executed, return to its invoking line to continue executing the rest of the JS code. 10. Delete the `greeting()` function from the call stack list. **Note:** Call stack list: EMPTY In summary, then, we start with an empty Call Stack. Whenever we invoke a function, it is automatically added to the Call Stack. Once the function has executed all of its code, it is automatically removed from the Call Stack. Ultimately, the Stack is empty again. See also -------- * Call stack on Wikipedia * Glossary + Call stack + Function

TCP slow start - MDN Web Docs Glossary: Definitions of Web-related terms

TCP slow start ============== TCP slow start helps buildup transmission speeds to the network's capabilities. It does this without initially knowing what those capabilities are and without creating congestion. TCP slow start is an algorithm used to detect the available bandwidth for packet transmission, and balances the speed of a network connection. It prevents the appearance of network congestion whose capabilities are initially unknown, and slowly increases the volume of information diffused until the network's maximum capacity is found. To implement TCP slow start, the congestion window (*cwnd*) sets an upper limit on the amount of data a source can transmit over the network before receiving an acknowledgment (ACK). The slow start threshold (*ssthresh*) determines the (de)activation of slow start. When a new connection is made, cwnd is initialized to one TCP data or acknowledgment packet, and waits for an acknowledgement, or ACK. When that ACK is received, the congestion window is incremented until the *cwnd* is greater than *ssthresh*. Slow start also terminates when congestion is experienced. Congestion control ------------------ Congestion itself is a state that happens within a network layer when the message traffic is too busy it slows the network response time. The server sends data in TCP packets, the user's client then confirms delivery by returning acknowledgements, or ACKs. The connection has a limited capacity depending on hardware and network conditions. If the server sends too many packets too quickly, they will be dropped. Meaning, there will be no acknowledgement. The server registers this as missing ACKs. Congestion control algorithms use this flow of sent packets and ACKs to determine a send rate. See also -------- * Populating the page: how browsers work * http overview

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

HTTPS ===== **HTTPS** (***HyperText Transfer Protocol Secure***) is an encrypted version of the HTTP protocol. It uses TLS to encrypt all communication between a client and a server. This secure connection allows clients to safely exchange sensitive data with a server, such as when performing banking activities or online shopping. See also -------- * HTTPS on Wikipedia * Moving to HTTPS community guide * Secure Contexts * MDN Web Docs Glossary + HTTP + TLS + SSL

Fetch metadata request header - MDN Web Docs Glossary: Definitions of Web-related terms

Fetch metadata request header ============================= A **fetch metadata request header** is an HTTP request header that provides additional information about the context from which the request originated. This allows the server to make decisions about whether a request should be allowed based on where the request came from and how the resource will be used. With this information a server can implement a resource isolation policy, allowing external sites to request only those resources that are intended for sharing, and that are used appropriately. This approach can help mitigate common cross-site web vulnerabilities such as CSRF, Cross-site Script Inclusion('XSSI'), timing attacks, and cross-origin information leaks. These headers are prefixed with `Sec-`, and hence have forbidden header names. As such, they cannot be modified from JavaScript. The fetch metadata request headers are: * `Sec-Fetch-Site` * `Sec-Fetch-Mode` * `Sec-Fetch-User` * `Sec-Fetch-Dest` The following request headers are not *strictly* "fetch metadata request headers", as they are not in the same specification, but similarly provide information about the context of how a resource will be used. A server might use them to modify its caching behavior, or the information that is returned: * `Sec-Purpose` Experimental * `Service-Worker-Navigation-Preload` See also -------- * Protect your resources from web attacks with Fetch Metadata (web.dev) * Fetch Metadata Request Headers playground (secmetadata.appspot.com) * List of all HTTP headers * List of all HTTP headers > Fetch metadata request headers * Glossary + Representation header + HTTP header + Response header + Request header

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

Cookie ====== A cookie is a small piece of information left on a visitor's computer by a website, via a web browser. Cookies are used to personalize a user's web experience with a website. It may contain the user's preferences or inputs when accessing that website. A user can customize their web browser to accept, reject, or delete cookies. Cookies can be set and modified at the server level using the `Set-Cookie` HTTP header, or with JavaScript using `document.cookie`. See also -------- * HTTP cookie on Wikipedia

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

ARPANET ======= The **ARPANET** (Advanced Research Projects Agency NETwork) was an early computer network, constructed in 1969 as a robust medium to transmit sensitive military data and to connect leading research groups throughout the United States. ARPANET first ran NCP (Network Control Protocol) and subsequently the first version of the Internet protocol or TCP/IP suite, making ARPANET a prominent part of the nascent Internet. ARPANET was closed in early 1990. See also -------- * .arpa * TCP * ARPANET on Wikipedia

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

Method ====== A **method** is a function which is a property of an object. There are two kinds of methods: *instance methods* which are built-in tasks performed by an object instance, or *static methods* which are tasks that are called directly on an object constructor. **Note:** In JavaScript functions themselves are objects, so, in that context, a method is actually an object reference to a function. When `F` is said to be a *method* of `O`, it often means that `F` uses `O` as its `this` binding. Function properties that do not have different behaviors based on their `this` value (or those that don't have a dynamic `this` binding at all — like bound functions and arrow functions) may not be universally recognized as methods. See also -------- * Method (computer programming) in Wikipedia * Defining a method in JavaScript (comparison of the traditional syntax and the new shorthand) * List of JavaScript built-in methods * MDN Web Docs Glossary + function + object + property + static method

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

FTP === **FTP** (File Transfer Protocol) is an insecure protocol for transferring files from one host to another over the Internet. For many years it was the defacto standard way of transferring files, but as it is inherently insecure, it is no longer supported by many hosting accounts. Instead you should use SFTP (a secure, encrypted version of FTP) or another secure method for transferring files like Rsync over SSH. See also -------- * Beginner's guide to uploading files via FTP * FTP on Wikipedia

Time to first byte - MDN Web Docs Glossary: Definitions of Web-related terms

Time to first byte ================== **Time to First Byte** (TTFB) refers to the time between the browser requesting a page and when it receives the first byte of information from the server. This time includes DNS lookup and establishing the connection using a TCP handshake and TLS handshake if the request is made over HTTPS. TTFB is the time it takes between the start of the request and the start of the response, in milliseconds: ``` TTFB = responseStart - navigationStart ``` See also -------- * A typical HTTP session * PerformanceResourceTiming * PerformanceTiming

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

Argument ======== An **argument** is a value (primitive or object) passed as input to a function. For example: ```js const argument1 = "Web"; const argument2 = "Development"; example(argument1, argument2); // passing two arguments // This function takes two values function example(parameter1, parameter2) { console.log(parameter1); // Output = "Web" console.log(parameter2); // Output = "Development" } ``` The argument order within the function call should be the same as the parameters order in the function definition. ```js const argument1 = "foo"; const argument2 = [1, 2, 3]; example(argument1, argument2); // passing two arguments // This function takes a single value, so the second argument passed is ignored function example(parameter) { console.log(parameter); // Output = foo } ``` See also -------- * Difference between parameter and argument * The `arguments` object in JavaScript

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

PAC === A Proxy Auto-Configuration file (**PAC file**) is a file which contains a function, `FindProxyForURL()`, which is used by the browser to determine whether requests (including HTTP, HTTPS, and FTP) should go directly to the destination or if they need to be forwarded through a web proxy server. ```js function FindProxyForURL(url, host) { // … } ret = FindProxyForURL(url, host); ``` See Proxy Auto-Configuration (PAC) file for details about how these are used and how to create new ones. See also -------- * PAC on Wikipedia * Proxy Auto-Configuration file on MDN

General header - MDN Web Docs Glossary: Definitions of Web-related terms

General header ============== **General header** is an outdated term used to refer to an HTTP header that can be used in both request and response messages, but which doesn't apply to the content itself (a header that applied to the content was called an entity header). Depending on the context they are used in, general headers might either be response or request headers (e.g. `Cache-Control`). **Note:** Current versions of the HTTP/1.1 specification do not specifically categorize headers as "general headers". These are now simply referred to as response or request headers depending on context.

Secure Context - MDN Web Docs Glossary: Definitions of Web-related terms

Secure Context ============== A **secure context** is a `Window` or `Worker` in which certain minimum standards of authentication and confidentiality are met. Many Web APIs and features are only accessible in secure contexts, reducing the opportunity for misuse by malicious code. For more information see: Web > Security > Secure Contexts.