Glossary

Glossary#

Accept Header#

Part of the Request that is responsible to define the expected type of data to be accepted by the client in the Response.

acquisition#

Acquisition is a mechanism that allows objects to inherit attributes from their parent objects in the object hierarchy.

Add-on#

An add-on in Plone extends its functionality. It is code that is released as a package to make it easier to install.

In Volto, an add-on is a JavaScript package.

In Plone core, an add-on is a Python package.

Ajax#

AJAX#

Asynchronous JavaScript and XML#

AJAX allows web applications to change parts of the page dynamically without reloading the entire page. In Plone, after a page with JavaScript is loaded, the JavaScript will send an asynchronous request to the server. The server will send a response back to the client, which is then rendered on the client side.

Ansible#

Ansible is an open source automation platform. Ansible can help you with configuration management, application deployment, task automation.

Archetypes#

The deprecated framework for building content types in Plone.

Authentication Method#

Access restriction provided by the connection chain to the server exposed to the client.

Authorization Header#

Part of the Request that is responsible for the authentication related to the right user or service to ask for a Response.

AWS#

Amazon Web Services offers reliable, scalable, and inexpensive cloud computing services. Free to join, pay only for what you use.

Babel#

A JavaScript compiler that "transpiles" newer standards JavaScript to something that any browser can load.

backend#

Plone backend#

Plone's backend includes a content management system, a REST API, and Classic UI as a frontend.

Barceloneta#

The default theme for Plone 5.

Basic Auth#

A simple Authentication Method referenced in the Authorization Header that needs to be provided by the server.

blocks#

Blocks are the fundamental components of a page layout in Volto.

bobtemplate#

bobtemplates#

bobtemplates.plone#

bobtemplates.plone provides mr.bob templates to generate packages for Plone projects. The plonecli command line client provides a developer-friendly interface to bobtemplates.plone.

browser layer#

Layer#

A layer—also called "browser layer"—is a marker interface and used in ZCML configurations. Layers allow you to enable and disable views and other site functionality based on installed add-ons and themes.

Buildout#

Buildout is a Python-based tool for building and assembling applications from multiple parts, based on a configuration file. It was the most common way of installing Plone 3, 4, and 5, and can still be used with Plone 6.

CD#

continuous deployment#

continuous delivery#

Continuous deployment or continuous delivery is a software development practice that works in conjunction with CI to automate the infrastructure provisioning and application release process.

Chef#

A configuration management tool written in Ruby and Erlang.

CI#

continuous integration#

Continuous integration (CI) is the practice of integrating all your code changes into the main branch of a shared source code repository early and often, automatically testing each change when you commit or merge them, and automatically kicking off a build.

Read about Plone's Continuous integration.

Classic UI#

Classic UI is a frontend for Plone 6 that is based on ZPT and Mockup. It is one of two supported user interfaces, or frontends, for Plone 6.

See also

Choose a user interface

CloudFormation#

AWS CloudFormation gives developers and systems administrators an way to create and manage a collection of related AWS resources, provisioning and updating them in an orderly and predictable fashion.

CMS#

Content Management System

CommonJS#

A JavaScript package standard, the equivalent of a Python wheel or egg. Enables JavaScript modules.

component shadowing#

shadowing#

Volto uses a technique called component shadowing to override an existing Volto component with our local custom version, without having to modify Volto's source code.

Volto's source components are located in the filepath stem of omelette/src/components/. Custom components that shadow Volto's source would be located in the filepath stem of src/customizations/components/. Shadow components would have the same filepath as Volto's source compenents, excluding the stem. Thus omelette/src/components/theme/Header/Header.jsx would be shadowed by src/customizations/components/theme/Header/Header.jsx.

Webpack provides an alias mechanism that allows component shadowing in Volto, where the path for a module can be aliased to another module. By using this mechanism of file overrides, or component shadowing, Volto enables customization, similar to z3c.jbot.

Configuration registry#

In Plone and in general, the configuration registry is where resources are registered for an application.

In Volto, it is a singleton object modeled using JavaScript modules. It is accessible from the Volto project by importing the module @plone/volto/config with import registry from '@plone/volto/config'. It contains the configuration of the Volto app.

In Plone core, plone.app.registry provides Plone UI and GenericSetup integration for plone.registry, which in turn implements a configuration registry for Zope applications.

Content Delivery Network#

CDN#

A Content Delivery Network (CDN) is a network of servers located in various geographic regions that work together to deliver web content to users quickly and efficiently.

content rule#

A content rule will automatically perform an action when a certain event, known as a trigger, takes place.

Cookiecutter#

A command-line utility that creates projects from cookiecutters (project templates), for example, creating a Python package project from a Python package project template. See Cookiecutter's documentation.

cookiecutter-plone-starter#

cookiecutter-plone-starter creates a Plone project that you can install using Make. It generates files for installing and configuring both the frontend and backend. For the backend, it uses cookiecutter-zope-instance to generate configuration files for a Zope instance.

cookiecutter-zope-instance#

cookiecutter-zope-instance is a cookiecutter template to create a full and complex configuration of a Zope instance.

Cookieplone#

Added in version Volto: 18.0.0-alpha.43

Cookieplone is the method to create a Plone project. You can use Cookieplone to build a backend add-on, a new Volto add-on, or a full project with both backend and frontend. Cookieplone simplifies the process using robust Cookiecutter templates from cookieplone-templates.

cookieplone-templates#

cookieplone-templates is a collection of templates used by Cookieplone.

Corepack#

Corepack is a zero-runtime-dependency Node.js script that acts as a bridge between Node.js projects and the package managers they are intended to be used with during development. In practical terms, Corepack lets you use Yarn, npm, and pnpm without having to install them.

Corepack is distributed by default with all recent Node.js versions. Run corepack enable to install the required Yarn and pnpm binaries on your path.

CSRF#

Cross-Site Request Forgery#

Cross-Site Request Forgery (CSRF or XSRF) is a type of web attack that allows an attacker to send malicious requests to a web application on behalf of a legitimate user. The attack works by tricking the user's web browser into sending a request to the web application that the user did not intentionally make. This can allow an attacker to perform actions on the web application without the user's knowledge or consent. In Plone, CSRF protection is done almost transparently by plone.protect.

CSS#

Cascading Style Sheets (CSS) is a stylesheet language used for describing the (most of the times visual) representation of web pages.

Cypress#

Cypress is a JavaScript testing framework that runs your app in the browser for visually debugging it. Volto uses Cypress for acceptance tests.

Dexterity#

Dexterity is the base framework for building content types, both through-the-web and as filesystem code. It is aimed at Plone, although this package should work with plain Zope + CMF systems.

Diazo#

Diazo theme engine guide. Diazo allows you to apply a theme contained in a static HTML web page to a dynamic website created using any server-side technology.

DigitalOcean#

DigitalOcean, Inc. is an American cloud infrastructure provider headquartered in New York City with data centers worldwide.

distribution#

distributions#

A Plone distribution is a pre-packaged version of Plone that includes specific features, themes, modules, and configurations. It is a convenient way to get a specific type of website up and running quickly, as the distribution includes everything needed to run that type of site.

See also

Docker#

Docker is an open platform for developing, shipping, and running applications using containers.

Docker Compose#

Docker Compose is a tool for defining and running multi-container Docker applications.

Docutils#

Docutils is an open-source text processing system for processing plaintext documentation into useful formats, such as HTML, LaTeX, man-pages, OpenDocument, or XML. It includes reStructuredText, the easy to read, easy to use, what-you-see-is-what-you-get plaintext markup language.

DOM#

Document Object Model#

The Document Object Model (DOM) is a programming interface for web documents. It represents the page so that programs can change the document structure, style, and content. The DOM represents the document as nodes and objects; that way, programming languages, such as JavaScript and React, can interact with the page.

dots per inch#

DPI#

Represents the number of dots per inch. Screens typically contain 72 or 96 dots per inch.

DSL#

Domain Specific Language

Dublin Core#

The Dublin Core Schema is a small set of vocabulary terms that can be used to describe web resources (video, images, web pages, etc.), as well as physical resources such as books or CDs, and objects like artworks.

ECMAScript#

ECMAScript is a standard for scripting languages, including JavaScript, JScript, and ActionScript. It is best known as a JavaScript standard intended to ensure the interoperability of web pages across different web browsers. It is standardized by Ecma International in the document ECMA-262.

element#

Elements are the dynamic components of your blocks. They can be input fields, buttons, or computed HTML. They can also return JSON if you call them from a JavaScript app.

elementEditor#

A generic volto-slate plugin architecture that can be used to create other editor interactions that follow the pattern of having a button that toggles a format (an inline element). It also creates a separate edit form for advanced customization of the data attached to the element.

ESLint#

ESLint statically analyzes your code to quickly find problems. It is built into most text editors and you can run ESLint as part of your continuous integration pipeline.

Express#

A JavaScript HTTP server with a simple API to build custom applications. Volto uses it as its server.

fence#

A method to extend basic MyST syntax. You can define a directive with backticks (`) followed by a reStructuredText directive in curly brackets ({}), and a matching number of closing backticks. You can also nest fences by increasing the number of backticks.

````{warning}
There be dragons!
```{important}
Dragons have feelings, too!
```
````

Warning

There be dragons!

Important

Dragons have feelings, too!

frontend#

Plone frontend#

A frontend consists of the user interface elements of a web application. Beginning with Plone 6, the default frontend is Volto. Classic UI is a secondary frontend that is part of the Plone backend.

FTI#

Factory Type Information#

Factory type information (FTI) is responsible for content creation in the portal. FTI is responsible for the following:

Which function is called when new content type is added.
Icons available for content types.
Creation views for content types.
Permission and security.
Whether discussion is enabled.
Providing the factory_type_information dictionary. This is used elsewhere in the code (often in __init__.py of a product) to set the initial values for a ZODB Factory Type Information object (an object in the portal_types tool).

gettext#

UNIX standard software translation tool. See https://www.gnu.org/software/gettext/.

Git#

Git is a free and open source distributed version control system.

GitHub workflow#

GitHub workflows#

A GitHub workflow is a configurable automated process that will run one or more jobs.

Grunt#

The JavaScript Task Runner. Automates the creation and manipulation of static assets for the theme.

HAProxy#

HAProxy is a free, very fast and reliable reverse-proxy offering high availability, load balancing, and proxying for TCP and HTTP-based applications.

HMR#

hot module replacement#

Hot module replacement (HMR) is a development feature provided by Webpack that automatically reloads, in the browser, the JavaScript modules that have changed on disk.

hoisting#

Hoisting is an optimization provided by Yarn. By default JavaScript packages will directly include dependencies inside their local node_modules. By hoisting we're "lifting" these inner dependencies to the top level node_modules directory, and thus optimize the generated bundles. In case two dependencies have conflicting version dependencies of the same library, the hoisting will not be possible (for that conflicting dependency) and you'll see multiple instances of the same library in the bundle, or you'll see that the add-on receives its own node_modules folder.

hook#

hooks#

In general, a hook in programming is a place in code that allows you to tap in to a module to either provide different behavior or to react when something happens.

React Hooks are a React API that allow function components to use React features, such as lifecycle methods, states, and so on.

HTTP-Header#

HTTP Header#

Header#

The part of the communication of the client with the server that provides the initialisation of the communication of a Request.

HTTP-Request#

HTTP Request#

Request#

Requests#

The initial action performed by a web client to communicate with a server. The Request is usually followed by a Response by the server, either synchronous or asynchronous (which is more complex to handle on the user side)

HTTP-Response#

HTTP Response#

Response#

Answer of or action by the server that is executed or send to the client after the Request is processed.

HTTP-Verb#

HTTP Verb#

Verb#

One of the basic actions that can be requested to be executed by the server (on an object) based on the Request.

HTTPRequest#

The HTTPRequest object contains information about the current request, which also includes browser layers.

husky#

Husky automatically lints your commit messages, code, and runs tests upon committing or pushing commits to a remote repository.

Hydration#

After loading an HTML page generated with SSR in the browser, React can populate the existing DOM elements, and recreate and attach their coresponding components.

i18n#

internationalization#

Internationalization#

Internationalization is the process of preparing an application for displaying content in languages and formats specifically to the audience. Developers and template authors usually internationalize the application. "i18n" is shorthand for "internationalization" (the letter "I", 18 letters, the letter "N"). Plone is fully internationalized.

See also

localization

i18ndude#

Support tool to create and update message catalogs from instrumented source code.

integer identifier#

intid#

In Plone, an integer identifier, or intid, is used to uniquely identify content objects within a Plone site. Each content item in a Plone site is given a unique intid, which the system uses internally to reference content, keep track of link integrity, link translations, and other related purposes.

interface#

An interface is a mechanism for labeling objects as conforming to a given API or contract. Interfaces define what methods an object provides. Plone extensively uses interfaces to define APIs between different subsystems.

Jest#

Jest is a JavaScript testing framework. Volto uses Jest for unit tests.

JSON#

JSON (JavaScript Object Notation, pronounced /ˈdʒeɪsən/; also /ˈdʒeɪˌsɒn/) is an open standard file format and data interchange format that uses human-readable text to store and transmit data objects consisting of attribute-value pairs and arrays (or other serializable values).

JSON Schema#

JSON Schema is the vocabulary that enables JSON data consistency, validity, and interoperability at scale.

JSX#

A dialect of JavaScript that resembles XML, it is transpiled by Babel to JavaScript functions. React uses JSX as its component templating.

l10n#

localization#

Localization#

Localization is the process of writing the translations of text and local formats for an application that has already been internationalized. Formats include dates, times, numbers, time zones, and currency. Translators usually localize the application. "l10n" is shorthand for "localization" (the letter "L", 10 letters, the letter "N"). Plone is fully localized.

See also

internationalization

language tag#

A language tag is a string used as an identifier for a language. A language tag may have one or more subtags. The basic form of a language tag is LANGUAGE-[SUBTAG].

See also

W3C article Language tags in HTML and XML
W3C Working Draft Language Tags and Locale Identifiers for the World Wide Web

lazy load#

lazy loading#

lazy loaded#

Lazy loading is a strategy to identify resources as non-blocking (non-critical) and load these only when needed. It's a way to shorten the length of the [critical rendering path](https://developer.mozilla.org/en-US/docs/Web/Performance/Critical_rendering_path, which translates into reduced page load times.

Less#

A dynamic stylesheet language that can be compiled into CSS (Cascading Style Sheets).

LIF#

Language Independent Folder#

A folder containing static assets, such as images and files, for a given language.

Load balancer#

A load balancer acts as a traffic proxy and distributes network or application traffic across endpoints on a number of servers.

locale#

A locale is an identifier, such as a language tag, for a specific set of cultural preferences for some country, together with all associated translations targeted to the same native language.

LRF#

Language Root Folder#

A content-type that contains the translated content for a specified language. For example, an LRF located at your site root for English would be www.domain.com/en, where en represents the LRF.

lxml#

A library used for processing XML and HTML with Python. It is a binding for the libxml2 and libxslt C libraries. See https://lxml.de/

Make#

make#

GNU make#

GNU Make is a tool which controls the generation of executables and other non-source files of a program from the program's source files.

Make gets its knowledge of how to build your program from a file called the makefile, which lists each of the non-source files and how to compute it from other files. When you write a program, you should write a makefile for it, so that it is possible to use Make to build and install the program.

manual .po entries#

Entries which cannot be detected by an automatic code scan.

Markdown#

Markdown is a text-to-HTML conversion tool for web writers.

MO file#

.mo#

Machine Object file. The binary message file compiled from the .po message file.

Mockup#

Mockup is a package that, together with Patternslib, builds the UI toolkit for Classic UI, a frontend for Plone. Mockup provides the JavaScript stack for Classic UI. View Mockup's patterns, based on Patternslib.

mr.bob#

mr.bob is a tool that takes a directory skeleton, copies over its directory structure to a target folder, and can use the Jinja2 (or some other) templating engine to dynamically generate the files. Additionally, it can ask you questions needed to render the structure, or provide a configuration file to answer them.

mr.developer#

mr.developer is a Buildout extension that makes it easy to work with buildouts containing lots of packages, where you only want to develop a few of them.

mrs-developer#

Also called "missdev", a tool similar to buildout's mr.developer. It automatically downloads and keeps up to date copies of software and add-ons under development based on definitions stored in mrs.developer.json. As a byproduct of its update operations, it also automatically adjusts jsconfig.json, which is used by Volto to configure webpack aliases.

mxdev#

mxdev [mɪks dɛv] is a utility that makes it easy to work with Python projects containing lots of packages, and you want to develop only some of those packages. It is designed for developers who use stable version constraints, then layer their customizations on top of that base while using a version control system. This design allows developers to override their base package constraints with a customized or newer version.

MyST#

Markedly Structured Text (MyST) is a rich and extensible flavor of Markdown, for authoring Plone Documentation.

navigation root#

An object marked as a navigation root provides a way to root catalog queries, searches, breadcrumbs, and so on, into that object.

NFS#

Network File System.

nginx#

nginx (pronounced "engine x") is an HTTP and reverse proxy server, a mail proxy server, and a generic TCP/UDP proxy server, originally written by Igor Sysoev.

Node.js#

Node.js® is an open-source, cross-platform JavaScript runtime environment.

NPM#

npm is a package manager for the JavaScript programming language. It is the default package manager for the JavaScript runtime environment Node.js. Also a registry of JavaScript packages, similar to PyPI.

nvm#

Node Version Manager#

nvm allows you to quickly install and use different versions of node via the command line.

Object URL#

The target object of the Request.

Open Graph#

The Open Graph protocol enables any web page to become a rich object in a social graph. For instance, this is used on Facebook to allow any web page to have the same functionality as any other object on Facebook.

Pattern#

Patterns#

Patternslib#

Patterns, or Patternslib, is a toolkit that enables designers to build rich interactive prototypes without the need for writing any JavaScript. All functionality is triggered by classes and other attributes in the HTML, without abusing the HTML as a programming language. Accessibility, SEO, and well-structured HTML are core values of Patterns.

pdb#

The Python Debugger module is an interactive source code debugger for Python programs. See https://docs.python.org/3/library/pdb.html

pip#

pip is the package installer for Python. See tool recommendations for more information.

pipx#

pipx allows you to install and run Python applications in isolated environments.

PLIP#

PLIPs are PLone Improvement Proposals. These are about larger changes to Plone, discussed beforehand by the community. PLIPs are tracked in the GitHub issue tracker for Products.CMFPlone.

Plone#

Plone is an open-source content management system (CMS) with over 20 years of stability and security wrapped in a modern, powerful, user-centric package. It continues to set the standard for content management systems by offering the most functionality and customization out of the box.

plone/generator-volto#

@plone/generator-volto#

Deprecated since version Volto: 18.0.0-alpha.43

@plone/generator-volto is deprecated in favor of Cookieplone since Volto 18.0.0-alpha.43. See Cookieplone is now the recommended project and add-on generator for Volto 18.

plonecli#

The plonecli helps developers to create Plone add-ons in a modular and reproducible way.

pm2#

PM2 is a daemon process manager.

pnpm#

pnpm is a fast, disk space efficient package manager.

pnpm workspace#

workspace#

pnpm has built-in support for monorepositories (also known as multi-package repositories, multi-project repositories, or monolithic repositories). Workspaces provide support to manage multiple packages from your local file system from within a singular top-level, root package.

When you run pnpm install at the root of the repository, pnpm installs dependencies for all workspaces, ensuring consistency across the entire project. This centralized approach streamlines development, facilitates code sharing, and simplifies the maintenance of complex projects.

PO file#

.po#

Portable Object (PO) file. The file format used by the gettext translation system. See https://www.gnu.org/savannah-checkouts/gnu/gettext/manual/html_node/PO-Files.html.

PO template file#

.pot#

Portable Object (PO) template file, not yet oriented towards any particular language.

portlets#

Portlets are widgets that can be inserted in predefined locations in pages in Classic UI. Portlets are most commonly used to add sidebars to the left or right of the main page content.

PostgreSQL#

PostgreSQL is a powerful, open source object-relational database.

predicate#

predicates#

In programming, a predicate is a test which returns true or false.

Prettier#

Prettier is an opinionated code formatter.

pyenv#

Python version management. pyenv lets you easily switch between multiple versions of Python.

Rapido application#

It contains the features you implement. It is a folder containing templates, Python code, and YAML files.

Razzle#

A tool that simplifies SPA and SSR configuration for React projects.

React#

React is a JavaScript library for building user interfaces. Volto, the frontend for Plone 6, uses React.

react-intl#

react-intl is a library that is part of Format.JS which helps developers set up their applications for internationalization.

record#

A Rapido app is able to store data as records. Records are basic dictionaries.

Redux#

Redux middleware#

Custom wrappers for the Redux store dispatch methods. They allow customizing the behavior of the data flow inside the Redux store.

reference implementation#

A reference implementation is a program that implements all requirements from a corresponding specification. The reference implementation often accompanies a technical standard, and demonstrates what should be considered the "correct" behavior of any other implementation of it.

RelStorage#

RelStorage is a storage implementation for ZODB that stores pickles in a relational database.

REST#

REST stands for Representational State Transfer. It is a software architectural principle to create loosely coupled web APIs.

REST API#

A REST API (also called a RESTful API or RESTful web API) is an application programming interface (API) that conforms to the design principles of the representational state transfer (REST) architectural style. REST APIs provide a flexible, lightweight way to integrate applications and to connect components in microservices architectures. Plone uses plone.restapi for its REST API.

reStructuredText#

reStructuredText (rST) is an easy-to-read, what-you-see-is-what-you-get plaintext markup syntax and parser system. The Plone 6 Documentation was written in reStructuredText originally, then converted to MyST in 2022.

S3#

Amazon Web Services S3. Object storage built to store and retrieve any amount of data from anywhere.

Scoped packages#

Namespace for JavaScript packages, they provide a way to avoid naming conflicts for common package names.

Slate#

Slate.js is a highly customizable platform for creating rich-text editors, also known as WYSIWYG editors. It enables you to create powerful, intuitive editors similar to those you've probably used in Medium, Dropbox Paper, or Google Docs.

Solr#

Solr is a popular, blazing-fast, open source enterprise search platform built on Apache Lucene.

SPA#

single page application#

A type of JavaScript application that aims to provide a better user experience by avoiding unnecessary reloading of the browser page, instead using AJAX to load backend information.

Sphinx#

Sphinx is a tool that makes it easy to create intelligent and beautiful documentation. It was originally created for Python documentation, and it has excellent facilities for the documentation of software projects in a range of languages. Sphinx uses reStructuredText as its markup language, and many of its strengths come from the power and straightforwardness of reStructuredText and its parsing and translating suite, Docutils.

srcset#

The HTMLImageElement property srcset is a string which identifies one or more image candidate strings, separated using commas ,. Each image candidate string specifies image resources to display in web pages under given circumstances.

SSR#

server-side rendering#

When a web browser or other HTTP client sends a request, the HTML markup for the page is created on the server, which sends a response consisting of HTML markup back to the client.

In Volto, SSR returns HTML markup that closely matches the final DOM structure of the React components used to render that page, but it is not the complete page. After the client loads the initial response, then the hydration mechanism performs additional rendering on the client side, populating the DOM with additional HTML markup.

In Classic UI, SSR returns the complete page back to the client in the response. In some rare cases, additional HTML snippets may be loaded, such as in overlays or dialogs.

SSR enables a developer to customize a website per request and per user. In addition, SSR can improve performance and search engine optimization (SEO) for a website.

Stylelint#

Stylelint is a CSS linter that helps you avoid errors and enforce conventions.

TALES#

TAL Expression Syntax (TALES) expression, which by default expects a path. Python and string expressions are also allowed.

TC39#

Ecma International's TC39 is a group of JavaScript developers, implementers, academics, and more, collaborating with the community to maintain and evolve the definition of JavaScript. They established a process where the proposals are discussed, developed, and eventually approved (or dropped). The process has five Stages (0 to 4) where reaching the Stage 4 means the proposal is finished, and it becomes part of the JavaScript specification.

TinyMCE#

The rich text WYSIWYG editor used in Classic UI.

TLS#

Transport Layer Security#

Transport Layer Security (TLS) is a cryptographic protocol designed to provide communications security over a computer network.

See also

Transport Layer Security article from MDN.

TLS termination proxy#

A TLS termination proxy is a proxy server that acts as an intermediary point between client and server applications. It is used to terminate or establish TLS tunnels by decrypting or encrypting communications.

Traefik Proxy#

Traefik Proxy is an open-source reverse proxy and load balancer, suitable for containerized architectures.

Transpilation#

The transformation of JavaScript code that uses advanced language features, unavailable for some browsers, to code rewritten to support them.

traversal#

Traversal is the process of determining the object that is the target of a request by examining the URL path of the request or in code, and looking up objects in the object hierarchy.

trigger#

A trigger is an event in Plone that causes the execution of defined actions. Example triggers include object modified, user logged in, and workflow state changed.

TTW#

Through-The-Web allows editing or customizing a Plone site through a web browser.

unique identifier#

UID#

UID is an acronym meaning "unique identifier". A UID is an identifier that is guaranteed to be unique among all identifiers used for those objects and for a specific purpose.

Varnish#

Varnish is a popular open source web accelerator that is used to implement HTTP caching.

view#

A view is the basic element of modern Python web frameworks. A view runs code to set up Python variables for a rendering template. The output is not limited to HTML pages and snippets, but may contain JSON, file download payloads, or other data formats.

Volto#

Volto is a React-based frontend for Plone. It is one of two supported user interfaces, or frontends, for Plone 6.

See also

Choose a user interface

Volto configuration loader#

A function with signature config => config. It gets the Volto configuration registry, and it must return it back after mutating it. It is similar to GenericSetup profiles in the Plone backend. An add-on must provide a default configuration loader that is always loaded when Volto runs. An add-on can have multiple configuration loaders, and they can be loaded optionally from the Volto configuration.

volto-slate#

volto-slate is an interactive default text editor for Volto, developed on top of Slate, offering enhanced WYSIWYG functionality and behavior.

Webpack#

A tool that loads and bundles code and web resources using loaders.

Webpack entrypoint#

The main files generated by webpack as a result. They typically contain the application source code based on modules bundled together, but it can also include other resources, such as static resources. It can contain code to automatically trigger the load of other JavaScript code files called "chunks".

workflow#

A concept in Plone (and other CMS's) whereby a content object can be in a number of states (private, public, etcetera) and uses transitions to change between them (e.g. "publish", "approve", "reject", "retract"). See the Plone docs on Workflow

WSGI#

The Web Server Gateway Interface (WSGI, pronounced WIZ-ghee) is a simple calling convention for web servers to forward requests to web applications or frameworks written in the Python programming language.

WSL#

Windows Subsystem for Linux#

The Windows Subsystem for Linux (WSL) lets developers install a Linux distribution (such as Ubuntu, OpenSUSE, Kali, Debian, or Arch Linux) and use Linux applications, utilities, and Bash command-line tools directly on Windows, unmodified, without the overhead of a traditional virtual machine or dualboot setup.

WYSIWYG#

WYSIWYG is an acronym for "what you see is what you get", referring to software that allows content to be edited in a form that resembles its appearance when printed or displayed as a finished product.

XML#

The Extensible Markup Language.

XPath#

XPath (XML Path Language) is a query language for selecting nodes from an XML document.

XSLT#

The Extensible Stylesheet Language Transformations. A language which defines elements to describe transformations to be applied on a document.

Yarn#

Yarn is both a JavaScript package manager and project manager.

Yeoman#

Yeoman is a popular scaffolding tool similar to Plone's mr.bob or ZopeSkel.

ZCA#

Zope Component Architecture#

Zope Component Architecture (ZCA) is a Python framework for supporting component based design and programming. It uses the design patterns of interface, adapter, factory, and subscriber. It is very well suited to developing large Python software systems. The ZCA is not specific to the Zope web application server. It can be used for developing any Python application. Maybe it should be called Python Component Architecture.

ZCML#

The Zope Configuration Mark-up Language.

ZEO#

ZEO is a client-server storage for ZODB for sharing a single storage among many clients.

ZMI#

The Zope Management Interface. The ZMI is a direct interface into the backend software stack of Plone. While it can still serve as a valuable tool for Plone specialists to fix problems or accomplish certain tasks, it is not recommended as a regular tool for Plone maintenance.

ZODB#

A native object database for Python.

Zope#

Zope is a Python-based application server for building secure and highly scalable web applications.

Zope instance#

A Zope instance is a particular set of configuration for running Zope. A new Zope instance can be created using cookiecutter-zope-instance.

ZPT#

Zope Page Template is a template language for Python.