Skip to main content
Version: v4.5.0

Glossary

See StackSpot's glossary below:

Creators​

As a creator, you can create and use Templates/Plugins/apps in STK CLI. You are responsible for designing and creating Stacks for software development, add Templates and Plugins in these Stacks, and you can see them all in the Studios.

Creators define the Stack's characteristics like a programming language, libraries and components, life cycle phases, quality control, testing, packaging, distribution, and best practices implemented by the Stack.

When publishing a Stack Studio, the Creator should:

  • Define their Stack's design strategy so that their users can achieve their goals with high quality and low cognitive load.
  • Ensure Templates and Plugins are compatible with each other.
  • Make sure when Templates and Plugins are applied together, they can produce software projects quickly, abstracting the complexities of the development process from the users.

User​

As a user, you can consume the Stacks produced and published by the Creator.

You can also import Stacks and start new projects based on the Stack's Templates with STK CLI. In projects created with Templates, it is possible to add Plugins, which add new functionality and features to the project. The Stacks are published by the Creators.

By following the technology standards developed by the Creators, you decrease your application's development time and increase your product's quality.

STK CLI​

It is StackSpot's Command-Line interface. STK CLI helps Users and Creators execute functionalities available in the platform, like creating/adding Stacks, Templates, Plugins, and more.

STK CLI Commands​

The STK CLI commands:

  • Core commands: the main STK CLI commands;
  • Stacks commands: used to create, import, list, and update Stacks;
  • Templates commands: used to add, create, delete or list Templates;
  • Plugins commands: used to add, apply, create, or list Plugins;
  • Stackfiles commands: used to create or list Stackfiles.
  • Tasks commands: used to create, list, and run Tasks.
  • Enterprise Commands are only used in StackSpot's Enterprise plan.

For more details, check the Commands List section.

Stack​

Stack Context​

A Stack represents a set of technology decisions and patterns to solve a specific problem, like programming languages, architecture, development experience, operation, security, scale, and governance. A Stack is the materialization of packaging pieces of software that work together to guarantee the requirements demanded by the application.

What is a Stack​

Template​

A Template is a set of variables you fill in to produce a basic structure for your Stack. It is an application model that contains the minimum to build a project.

These variables are:

  • Programming Language;
  • Build System;
  • Frameworks;
  • Packaging;
  • Other structural components used to build a Stack.

According to the strategy the Studio wants to adopt in the Stack, a Template can have a complex or basic code. It can be used in the stk-legacy create app commands to create a project.

Template Versioning​

Each Template is versioned in a Git repository and the Studio publishes the Templates in a Stack where Plugins and Templates are together. Template versioning should follow the semantic versioning, as STK CLI always keeps Templates in the last published tag, which can be in the main branch, or when there are no tags, in the master.

Plugin​

These are extensions to a Stack that allow you to add new capabilities to the base Template by including source code, importing libraries, and even executing complex commands and operations to add capabilities to the Stack.

A Plugin and a Template structure are the same, the only difference is the type app, instead of app-template.

Stackfiles​

They are bundles, it is a set of predefined Templates and Plugins from a Stack, you can apply with the stk-legacy create app command. When you use a Stackfile, you can create an app and apply a bundle of Plugins in a single STK CLI command.

Stackfiles are useful for Stack Creators to define a mixture of Templates and Plugins in the Stack.

Users can define their own Stackfiles to accelerate the process of creating projects that use a predefined bundle of Templates and Plugins.

Stackfile Example​

A Stack designed to create .NET applications can have one Stackfile that creates an application with default observability Plugins, adds database functionality, and so on.

Tasks​

They are custom commands that complement STK CLI Core commands. Tasks allow you to perform operations in a project's or Stack's context. For example, set up a local environment, execute a deployment or even run scripts.

  • For Stacks creators: it is possible to create commands frequently used by StackSpot's users. Tasks make the experience of using a Stack more relevant, with the addition of useful features in your daily life beyond the application of Plugins or the creation of Projects.

Application (app)​

It is a product or a module of a product that implements some functionality. An application can be, for example:

  • A library
  • API
  • A mobile application
  • Microservice Or another software component that provides important business functionality.

Depending on the application's type, it can reference an environment to use its shared resources. But an application can also be created without reference to an environment. In short: this reference is optional.

Project​

A project has several technological solutions to produce, access, transmit, and manage data. Projects with StackSpot use Stacks and their components to structure these technologies, to make all the solutions in a project better organized, reliable and scalable, accelerating applications creation.

Was this page helpful?