Glossary

A file implements interface .X

A file implements interface .X if it has a direct child named .X or the app referenced by its type implements the .X interface.
Built-in apps and engines also implement some interfaces as defined in their documentation.

Accept rules

In object oriented programming, an accept rule would be called an interface. It is a set of methods a file has to implement to be accepted in a bucket.

For each file, accept rules define what files may be accepted in each of its buckets. A file's accept rules are stored in a file named .Accept.

Anonymous filesystem

An anonymous filesystem is a filesystem that is not bound to a domain. Even anonymous filesystems have a domain that can be used to print the absolute path of its files, but you can't use that domain from outside the anonymous filesystem to access it.

It is a temporary filesystem that only exists for the duration of a transaction.

An alternative way of thinking is that an anonymous filesystem is not mounted anywhere. As soon as you mount it to a non-anonymous filesystem, it will stop being both anonymous and temporary.

App

An app (application) is the Boomla equivalent of classes in object oriented programming. A user space app is implemented on top of Boomla. Each user space app is stored in a file.

App instance

An app instance is a file that's type points to an app. Similar to a class instance in object oriented programming.

Built-in type

A built-in type is a file type that is recognized by the Boomla Platform. It may identify a built-in application, an engine, or have some special behavior attached.

Component

Components are the no-code equivalents of apps. It is used to create reusable elements or element structures, typically via drag-and-drop. A component wraps one or more app or component instances and optionally declares some input files to be defined at component instances.

For example, a page component may define a page layout to have a certain menu and footer, but the contents should not be the same on all pages (instances of that page component), rather defined individually.

Component app

Components are mostly implemented in kernel space but they require certain functionality to be defined in user space. These are defined in the component app.

The file type of components points to this component app.

Component instance

A component instance is similar to an app instance but for components. 

Component instances encapsulate the inner structure of the referenced components and present them as single objects. Only the input parameters of the component (input files) can be defined at the component instance level.

Content

A file is said to be a content if it implements the .Inline interface.

Context menu

The context menu is part of the frontend toolchain. It is a list of actions that can be triggered on a specific file, shown as a menu. It can be accessed in block editing mode by right-clicking a file on Windows or control-clicking on Mac.

Drop guide

The drop guide is shown during file placement operations (drag-and-drop, paste) to provide feedback about the placement. In particular, it highlights the target file and provides 3 possible placement directions: before, append, after. The color of the drop guide indicates whether the operation is allowed (typesafe) or not.

Engine

An engine is a program that executes code written in a programming language. Used as a catch-all term for interpreters and virtual machines.
When writing code in a method file, you can select the engine by setting the method file's type property. For example, you can execute JavaScript code via the sjs-4 JavaScript engine.

File is accepted

See: accept rules.

File type

The file type is a file property, holding a built-in type or an internal path to a file. Relative paths not starting with . or .. are resolved relative to the /sys/packages file. For example, the type gallery.boomla.net/gallery would resolve to /sys/packages/gallery.boomla.net/gallery.

Inline method

A web page may be divided into logical components. In Boomla, these components are usually stored in individual files. We can get the HTML code for each component by calling its inline method. The code is stored in a method file named .Inline.

Kernel space

Boomla is a platform which provides a filesystem, an execution model, etc. Kernel space refers to the platform. There are things kernel space code can do which is impossible in user space. For example, setting up a package link requires access to the package filesystem before it is mounted. That's only accessible in kernel space.
See also: user space.

Method file

In object oriented programming, there are classes, instances and methods; in Boomla, there are apps, app instances and methods. Each method is stored in an individual file called method file within the app. The method file is executed when the method is called on an app instance. For example, when a request hits a website, the .Request method is executed on the requested file. System defined methods start with an uppercase letter after the dot, user defined methods start with a lowercase letter after the dot.

Package website

A package website is a website that is intended to be installed as a package.

Page

A file is said to be a page if it implements the .Page interface.

Request method

The request method is executed when a HTTP request hits a website. The target file is located by the request path, then a method file named .Request is located on its type chain and executed.

Reserved filenames

Reserved filenames are system filenames white-listed for specific uses. For example, the filename .Request is reserved for request method files.

Section

A section is an input file container. Apps and components may define such sections to parameterize certain file inputs for their instances.

For example, page apps and page components will typically define at least one section for page contents. That way, users can drop contents in these sections on individual pages.

Section placeholder

A section placeholder is used to define a section within a component.

Section placeholder app

Sections are mostly implemented in kernel space but they require certain functionality to be defined in user space, particularly for section placeholders. These are defined in the section placeholder app.

The file type of section placeholders points to the section placeholder app.

System filenames

System filenames are filenames starting with a dot followed by an uppercase letter, for example .Request. System filenames can only be used if they are among the reserved filenames.

Type chain

The type chain of a file is the collection of files you encounter by recursively following a file's type property. All type chains must end in a built-in type. The type chain of a file includes the file itself.

Typesafe placement

The placement of a file in a specific bucket is typesafe if the file is accepted in that bucket, as specified in the file's accept rules.

User space

Boomla is a platform, it provides a Filesystem, an execution model, etc. User space means built on top of that platform, using the provided APIs.
See also: kernel space.