Platform Team/Glossary

Glossary

A list of terms to understand the basic concepts of Sweets.

Zero Install, 0install

Decentralized cross-distribution software installation system that Sweets is based on.

Sweets

Package management wrapper around Zero Install.

sweet, sweet project

Distribution entities in Sweets, i.e., packages. In other words, software projects that have recipe files in their sources that are being released via Sweets.

feed

A file in XML notation that contains information about all possible variants of the software, i.e., implementations, that can be launched.

interface

This is the cornerstone of Zero Install and, thus, Sweets, as well. To make a feed useful for other people, they are placed somewhere on the Internet to be accessible via HTTP/FTP (http://sweets.sugarlabs.org for the Sweets case). The full Web url, such as http://0install.net/2006/interfaces/ZeroInstall-GUI.xml, is a unique identifier of a distribution entity within Zero Install/Sweets. This powerful identifier is named the interface.

This url is all that is needed to run software from everywhere there is a connection to the Internet.

implementation

One or several bundles that contain one particular implementation of software projects that are being distributed via Zero Install. Implementations are attributed with versions, stability levels, targeted machine architectures, and OS types. It is possible to have several implementations for the same software version if there are differences between launching them on different OSes or machine architectures. Another important attribute of implementations are dependencies of this particular implementation, formed as a list of interfaces. Feeds contain information about all existing implementations in order to let Zero Install choose the right one on the client side, taking into account tons of details, like machine architecture, OS type, stability levels, or dependency restrictions.

recipe

On the Zero Install level, developers work with feeds manually. In the Sweets case, the regular way is to use recipes (but it is still possible to fallback to using feeds at any time). In short, it is an analog of spec files in GNU/Linux distributions, e.g., RPM .spec files or debian/ directories in Debian. Recipes do not specify ready-to-launch implementations like feeds do, but rather, only describe the lastest software version. The feed will be generated automatically on a server (along with preserving the history of versions) after releasing a new version of the software.

Short form for sweet interfaces

Within Sweets, it is possible to omit the http://sweets.sugarlabs.org/ prefix for sweet interfaces so as to make usage more expressive, e.g., in recipe files. It is always possible to use the full interfaces.

Implemented interfaces

One particular sweet implements one or several interfaces according to its recipe files. The reason for having several interfaces is that the same sweet might represent itself, e.g., http://sweets.sugarlabs.org/~alsroot/browse, and the upstream sweet that was used as a basis for the current one, e.g., http://sweets.sugarlabs.org/browse. Furthermore, on the client side, it will be possible to get implementations from ~alsroot/browse while launching browse sweet.

Associated interfaces

Associated interfaces is the alternate way to setup upstream-downstream relations between interfaces. If a recipe file mentions some interfaces as associated, implementations from these interfaces will be added to the implementations list of the current one. For example, if the http://sweets.sugarlabs.org/sdk/sugar interface (the pure sweet Sugar Shell) contains http://sweets.sugarlabs.org/base/sugar (an alias to the natively packaged Sugar Shell) as an associated interface, it will be possible while launching sdk/sugar, to run natively packaged sugar that came from base/sugar.

local sweet

It is an important high-level concept in Sweets, which is intended to make the development process of sweet projects more comfortable. Technically, it is the source software of the sweet project (i.e., with a recipe file) placed somewhere in the file system and registered in the local Sweets instance as a single implementation for interfaces it implements. It is always possible to run this local sweet directly by using the full filesystem path as an interface, but its most useful feature is reuse of the local implementation in routine Sweets workflows. For example, if sugar-toolkit sources, that implements sdk/sugar-toolkit interface, were cloned to the ~/src/sugar-toolkit directory, then while running a sdl/sugar sweet, it would become possible to reuse local sugar-toolkit sources as a regular implementation of sdk/sugar-toolkit dependency of sdk/sugar.

sweet package

Using the http://packages.sugarlabs.org Web UI, it is possible to create a repository with native packages from released sweets.

Sweets Distribution

It is a repository with Glucose and Fructose sweet packages based on sdk/ sweets.