Glossary - Boomla Website Builder

Filter by category:

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.

Absolute path

An absolute path is a path that includes a domain component. It contains a list of filenames separated by slashes (/).

Example: //example.com/filename

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.

Account

A Boomla account is created by signing up on boomla.com.

Account website

Usually, when a user's profile image or name is displayed, it is a link to the user's account website, which is the primary Boomla website of an account.

Active state of branch

The current snapshot of a branch.

Agent

In the context of Boomla, agent means the user agent, typically a browser, identified by an agent cookie. If the agent cookie is not transmitted in subsequent calls, the requests are considered to be coming from different agents.

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.

Anonymous Toolchain

The anonymous toolchain is a frontend toolchain variant shown to agents that are not signed in to the Boomla Platform.

Anonymous user

A visitor is said to be an Anonymous user when the visitor is not logged in onto the Boomla platform.

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.

Application call stack

Applications may run other applications, forming an application call stack. It's similar to the call stack used in programming, except only application calls are added to the application call stack.

Application call stack level

Depth of the application call stack. Stack level 0 belongs to the original application call, level 1 to the next level, etc.

Attribute hash

An attribute hash is the hash of a file's attributes.

Attribute size

Attribute size is the size of all file attributes after serializing. Data deduplication does not apply here.

Attribute type

File attributes are strongly typed. For example, they may be of type string or int32.

Authentication Server

The authentication server is used by agents for single sign-on across the Boomla Platform.

Automatic package update

Packages can be updated manually or automatically as updates are released.

Banned user

See: registration status.

Block editing mode

Block editing mode is an editing mode provided by the owner toolchain that enables file-level operations. Files on the page can be selected, copied, moved, deleted, created. One can open the contextmenu on files.

Body hash

A body hash is the hash of a file's body.

Body size

Body size is the size of the file body after serializing. Data deduplication does not apply here.

Boomla Cloud

The Boomla Cloud is the managed Boomla service accessible via boomla.com.

Branch

A branch is a line of development. The branch created first is the master branch while the rest are secondary branches. A new branch can be created by cloning an existing branch. Each branch is accessible on its individual domain. Unlike in Git, all branches are accessible simultaneously.

Bucket

Files may contain other files. Children of a file are stored in one of 256 containers called buckets. These buckets are identified by their BucketIds, which range from 0 to 255.

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.

Check out a commit

Start a new branch from a specific commit.

Children hash

A children hash is the hash of a file's children.

Children size

Children size is the storage space required for storing a file's children and their subtrees without data deduplication. Effectively, it's the sum of the children's file sizes plus a little overhead.

Clone a branch

Create a deep copy of a branch on a new domain, including its story.

Clone a website

Synonym for cloning a branch.

Collection

A collection is an ordered list of files, possibly with duplicates.

Commit

As a noun: a commit is a saved version of a branch.

As a verb: committing is the act of saving the current version of a branch.

Community domain

The Boomla community domain is boomla.net under which anyone can create websites for free.

An example domain for a website created under the community domain: example.boomla.net

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.

Compressed size

In the context of Boomla filesystems, compressed size is a synonym for deduplicated size.

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.

Data deduplication

If you have multiple copies of the same file, Boomla will figure this out and only store it once physically with multiple references. This is called data deduplication as the process "removes duplicates" from storage.

If we make 1000 copies of a 10MB image, we still end up with a deduplicated size of just over 10MB.

Deduplicated size

Deduplicated size is the storage space required for storing a file and its entire subtree on disk, with data deduplication applied. Data deduplication is automatically applied by Boomla.

The deduplicated size has to be individually calculated for files, thus you can't just look it up, it is an expensive operation.

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.

Dynamic link

Any link that is not a static link is called a dynamic link. For example, path links do not mount another volume, simply point to another file by an internal path. The link may be broken, as the referenced file may not exist.

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

A file is an object for storing data, similar to the traditional concept of a file, with some differences:

Boomla files may contain other files; there is no separate concept for directories.
Boomla files are ordered and you can sort them.
Boomla files can store structured data, so you can use the Boomla Filesystem as a database.
Boomla files are typed; they have a dedicated type property instead of using file extensions.
Boomla files have a link property which lets you create various kinds of file links.

File attribute

File attributes are (key, value) pairs defined in user space. File attributes are strongly typed. One can store data in file attributes which would traditionally be stored in database rows.

File hash

The file hash identifies an exact version of the file and its subtree. Changing the file or any part of its subtree will result in a new file hash.

File is accepted

See: accept rules.

File link

A file link is a pointer to another file.

Key points:

There are several types of file links.
Depending on the link type, the link may or may not be automatically followed during a file operation.
Some file link types are used to mount sub-volumes.
The link property is ALWAYS accessed on the LINKING file.
A link is defined by its type and any number of type-specific parameters.
File links are either static or dynamic.

Examples:

path /gallery/smile.jpg
package example.com 01ed8bb7a8ad5500c8885da1575f77068d0777606d
volume
scope

File Panel

The file panel is a user-interface element on some variants of the frontend toolchain showing the filesystem tree of the current website.

File property

File properties are system defined (key, value) pairs storing file metadata. Examples include the file link, type, title, status code, creation and modification times, etc.

File size

File size is the storage space required for storing a file and its entire subtree without data deduplication.

See compressed size for the actual space required for storing a file or a website.

Effectively, it's the sum of the file's:

property size,
attribute size,
body size,
children size,
linked file size for static links,
plus a little serialization overhead.

The file size adds up along the tree, thus it is easy to calculate.

File status code

File status code is a number stored in the status code property of files. A special case is 0, which indicates success, other status codes are used as in the HTTP specification. For example, 4xx and 5xx status codes represent errors.

File title

A file title is a description of the file, which may be used for any purpose. It may contain almost any chars with some exceptions. The file's name may be generated from its title.

Example: This is a file title! :)

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.

FileId

A fileId is a unique identifier for a file within a filesystem. When a file is moved within the same volume, its fileId won't change.

Filename or file name

A filename is a string uniquely identifying a file among its siblings. There are strict rules for its syntax. It's the file's address, so it's not part of the file itself. Changing a file's name won't change its file hash. The domain of a branch is considered to be the root file's name. Filenames usually match URL path segments.
Example: this-is-a-filename

FileNodeId

A fileNodeId is a unique identifier for a file within a volume. When a file is moved within the same volume, its fileNodeId won't change.

Filesystem

A filesystem is a tree of one or more volumes.

Filesystem interface version

The filesystem interface version defines the filesystem schema and any additional behavior on how the Boomla OS shall treat the filesystem / website in context.

Each filesystem scope defines its own filesystem interface version.

Filesystem scope

The filesystem scope specifies the root file to be used for path resolution. Filesystem scopes are implicitly created by some of the file link types. Filesystem scopes always start at volume roots. A filesystem scope may be local or global.

Filesystem scopes are used within packages to resolve file links and file types correctly.

Follow a link

To follow a link is to get the linked file - if it exists.

Frontend toolchain

The frontend toolchain is a JavaScript application injected into every Boomla website providing common editing functionality.

It has the following variants: Owner Toolchain, Visitor Toolchain, Anonymous Toolchain.

Hash

In the context of Boomla, a hash is a unique identifier of an object.
Example: 01ed8bb7a8ad5500c8885da1575f77068d0777606d

Hash change propagation

The hash of a file is calculated from its properties, attributes, body and children. If a file changes, it will cause the hash of its parent file to be recalculated and so on upwards in the tree. This is called hash change propagation.

IDE

The IDE is an Integrated Development Environment which can be installed on any Boomla website as a package. It provides a filesystem navigation tool and an editor for code, file properties and file attributes.

Ignore filesystem scope

Some filesystem operations may ignore the filesystem scope.

For example a package link that mounts a package filesystem establishes a new filesystem scope. Consequently, within the package, the root file refers to the package root. When ignoring the filesystem scope, the root file refers to the root of the outer filesystem.

Also, the parent file (..) of a package root file does not exist when respecting the filesystem scope. It does exist when the filesystem scope is ignored.

Immutable

Immutable means not mutable, or unchangeable. For example, Boomla filesystem snapshots (versions) are immutable. Whenever you "make a change" to a filesystem, in reality, a new filesystem is created - the previous snapshot (version) remains unchanged.

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.

Installing a package

Installing the package example.com creates the file /sys/packages/example.com and mounts a clone of its filesystem to this file via a package link.

Integrity check

Integrity checking a filesystem is the act of validating all of its data structures. If the integrity check passes, all data is accessible and intact, no single bit has been damaged.

Internal path

An internal path is a local path or a relative path.

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.

Link type

A file's link type defines how Boomla treats the link during file operations.

Available link types and their main properties:

Link type	Static / Dynamic	Transparent	Filesystem scope	Mounts volume
`package`	static	yes	yes	yes, read-only
`scope`	static	yes	yes	yes, read/write
`volume`	static	yes	no	yes, read/write
`path`	dynamic	no	no	no

Local Boomla instance

A local Boomla installation on a Boomla user's computer.

Local path

A local path is a path relative to a filesystem root file. It does not include a domain component but starts with a slash ("/"). It contains a list of filenames separated by slashes (/).

Example: /foo/bar

Marker

Marker is the user identity used for making changes to a filesystem.

Think of using a colored marker when writing on a paper. Each user has a different color. The colors on the paper identify the markers, which in turn identify the users who made those changes.

Master branch

The master branch is the first branch of a project. It can not be removed.

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.

Mounting

Mounting means linking another volume from a file so that the linked volume becomes accessible as the linking file's subtree.

Namespaced request parameter

HTTP request parameters may conflict if multiple components on a page expect identically named parameters. This can happen for example when there are 2 instances of the same app on a page. To avoid this, request parameters shall be namespaced. Namespacing works by adding a unique prefix to parameter names. For example, param could become n57B81.param where n57B81 is the namespace.

New Panel

The new panel is a user-interface element on some variants of the frontend toolchain. It shows a collection of files that can be used as building blocks for a website.

Not registered user

See: registration status.

Open source

If a branch is open source then anyone can read and clone its filesystem.

Owner Toolchain

The owner toolchain is a frontend toolchain variant shown to the owner of a website when logged in.

Package data store

Packages may use a central storage area within each website to store any package specific data. That's the package data store.

For each package, it is located at /sys/packageData/PACKAGE_NAME.

Package hash

A package hash is the root hash of a package filesystem.

Package link

A package link is a file link mounting a package by its hash. The package link is a static link: the mounted subtree becomes part of the website and remains there even if the original package website is removed.

Example: package example.com 01ed8bb7a8ad5500c8885da1575f77068d0777606d

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.

Path

A path is a string identifying a file in a filesystem. It may be one of:

Absolute path
Local path
Relative path

Path link

A path link is a reference to another file by an internal path. It is not automatically followed. Its only purpose is documenting the relationship between the two files. The path link is a dynamic link.

Example: path /foo/bar

Pending user

See: registration status.

Placeholder

A placeholder is a drop zone on the user interface that is routing dropped files to a specific bucket on the filesystem.

Placement direction

When creating, copying or moving files, one has to instruct Boomla how to position the file relative to an existing file. The placement direction is one of prepend, append, before or after.

Playground website

The playground website is a special website that is created (on demand) for each Boomla account to try things. Its state can be easily reset. Do not store important data on it.

Posix bridge

The Posix bridge is a 2-way mapping between the Boomla filesystem and Posix filesystems. Posix filesystems in this context include Windows, Mac and Linux filesystems.

The Posix bridge allows one to use programs that understand Posix filesystems to manipulate Boomla files.

Private branch

If a branch is private, only its owner and users registered to the website can access it through a browser.

Note that registered users still don't have filesystem level access, unless explicitly granted by the owner.

Private website

Synonym for private branch.

Project

A project is a collection of branches.

Property file

A property file is a JSON file on the Posix side of the Posix bridge, suffixed with ~.json. It stores file properties and attributes.

Public branch

If a branch is public, everyone can visit the website stored on the branch.

Public website

Synonym for public branch.

Query string

A query string is an expression used to find matching files.

Examples: path/to/file, child/*, foo/:c:1/first()

Redo chain

Redo chain is the opposite of the undo chain used to implement undo/redo functionality.

Registering to a Boomla website

Using one's Boomla account to access another Boomla account's website and create a user on it.

Registration acceptance

The registration acceptance mode of a website may be invite only, approve, or open.

Invite only means only the website owner may initiate the registration of a user.
Approve means anyone can initiate a registration, but the website owner must approve it.
Open means anyone can initiate a registration, and it will be automatically approved.

Registration status

If you have a Boomla account and you are logged in on the Boomla platform, and you visit a website, you may appear as one of:

a not registered user until you initiate a registration,
a pending user until your registration request has been accepted or denied,
an active user after your registration request has been approved,
a removed user if either you or the website owner has removed your registration,
a banned user if you got banned.

The website can only see your actual identity while you are an active user of the website. A removed user can register again, a banned user can not.

Relative path

A relative path is a path relative to any file on a filesystem. It contains a list of filenames, self (.) and parent (..) selectors separated by slashes (/). It starts with either a filename, . or ...

Examples: foo/bar, ./foo/bar, ../foo/bar

Removed user

See: registration status.

Request file

The request file is a file holding the input data when executing a method. It is the root file of an anonymous filesystem.

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.

Response file

The response file is a file that shall be filled with output data during the execution of a method. It is the root file of an anonymous filesystem.

Response status code

Response status code is used for both the HTTP response status code and the status code property of the response file.

The status code property of the response file is used as the HTTP status code, with one exception: 0 is treated as success and thus a HTTP response status code of 200 is returned to the visitor.

Root file

A root file is the top-most file of a volume or filesystem.

Root filesystem

The root filesystem is the top level filesystem of a branch (website).

Root hash

A root hash is the file hash of a root file. Either a filesystem root file, or a volume root file.

Root volume

A root volume is the top-most volume of a filesystem.

Save button

The save button is a button on the toolbar which can be used save textual changes in text editing mode.

Scope link

A scope link mounts a writable volume that establishes a filesystem scope. The scope link is a transparent, static link.

Turn a package link into a scope link to make it editable. (This will also prevent the system from updating the package.)

Example: scope

Secondary branch

A secondary branch is a branch which is not the master branch. Secondary branches are typically holding in-progress modifications which will be eventually merged back into the master branch.

Secondary branches are accessible on subdomains of the master branch. For example, if the master branch is at example.com, a secondary branch could be at beta.example.com.

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.

Sidebar

The sidebar on some variants of the frontend toolchain.

Simple volume

A simple volume is a volume linked via a volume link.

Snapshot

A snapshot is a specific version of a filesystem or volume. Snapshots are immutable, identified by a hash.

Source file

The source file is the file holding the source code that is being executed.

Static link

A static link mounts another volume by its hash. The mounted volume is part of the filesystem and the link can not break.

Modifying a statically mounted volume causes hash change propagation in the linking volume.

Story

The story is a list of all commits in a branch. It's similar to an immutable version history, except the story can be edited later, thus it can not rightfully be called "history". For example, you can free up space by deleting unnecessary commits from it.

Subtree

A subtree is a file with all its descendants, crossing volume boundaries.

Subtree size

Subtree size is a synonym for file size, with added emphasis on the fact that it includes the size of its entire subtree.

System account, System user

Automated changes like system updates are performed by the System account, also referred to as the System user depending on context.

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.

Text editing mode

Text editing mode is an editing mode provided by the owner toolchain that enables text editing on the entire web page. It depends on the used apps whether they support this editing experience or not. Text changes need to be saved by the save button.

Tool website

A website that is intended to be used as a tool, that is, to be used to make changes to another website. For example, an image editor could be a tool you use for editing images on your website.

WARNING: the concept of tool websites is deprecated, soon to be removed. You can now safely install tools directly on your website instead of accessing them on a remote domain.

Toolbar

The Boomla toolbar that shows up on top of Boomla websites. It is part of the frontend toolchain.

Transaction

A transaction is a unit of work performed by Boomla. Changes made within a transaction are invisible until the transaction is committed. Unhandled errors during a transaction cause an automatic rollback.

Transaction tree

Every request creates a new transaction. A transaction may start any number of child transactions. A request thus builds up a tree of transactions.

Transparent link

A link is said to be a transparent link if it lets you transparently read and write the linked file's data except the following:

name,
file hash,
subtree size,
fileId,
fileNodeId,
link.

The rest of the file's data is accessed on the LINKED file:

type,
title,
status code,
attributes,
body,
children,
created, createdBy,
modified, modifiedBy,
subtreeModified, subtreeModifiedBy.

For example, a volume link is a transparent link, while a path link is not.

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.

Undo chain

Every change made to a website (branch) generates a new snapshot. The previous snapshot is added to a list called the undo chain. Hitting undo restores the last snapshot of the undo chain. The length of the undo chain is limited.

User

A Boomla user is created when you register on a Boomla website with your Boomla account. All branches of a project share the same set of users.

Effectively a Boomla user is a Boomla account in the context of a Boomla project.

Sometimes Boomla user is used to refer to a Boomla account.

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.

Visit

In the context of Boomla, a visit is identified by a visit cookie. A visit is created when an agent is visiting a Boomla website without a valid visit cookie.

Visitor Toolchain

The visitor toolchain is a frontend toolchain variant shown to agents that are signed in to the Boomla platform but are not registered on the visited website.

Volume

A volume is a tree of files. Two files are on the same volume if you can reach one from the other without following file links. Volumes may be nested via file links.

Volume hash

A volume hash is the root hash of a volume.

Volume link

A volume link mounts a volume with no special properties except for being a separate fileNodeId space. It is a transparent, static link.The attached volume is also called a simple volume.

Example: volume

Website

A website is a collection of resources - HTML pages, images, etc. In Boomla, a project branch typically contains a website.

Workspace directory

Refers to the directory outside the Boomla platform, on the host OS, that contains the local Boomla instance. It contains a .boomla directory among other things.