Glossary
Definitions of key terms used throughout the TinySystems documentation.
A
Aggregator
A component that collects multiple messages and combines them into a single output, typically used for fan-in patterns or collecting parallel results.
API Server
The Kubernetes API server that manages cluster state. TinySystems components interact with it through the controller to manage CRDs.
B
Blocking Execution
TinySystems' execution model where the output() function blocks until all downstream processing completes. This ensures reliable message delivery and backpressure handling.
Branch
A flow path that diverges from a main path, typically created by router components with multiple output ports.
C
Component
A reusable building block in TinySystems that implements specific functionality. Components define ports, handle messages, and can be configured via settings. Implemented as Go structs satisfying the module.Component interface.
Component Info
Metadata about a component including name, title, description, category, and tags. Returned by the GetInfo() method.
ConfigMap
A Kubernetes resource for storing non-sensitive configuration data. Can be referenced in TinySystems settings via configRef.
Control Port
A system port (_control) that handles UI interactions like button clicks. Used for start/stop controls and state display.
Controller
The Kubernetes operator that watches TinyNode resources and coordinates message delivery between components.
CR (Custom Resource)
A Kubernetes API extension that stores custom data. TinySystems uses TinyNode, TinyModule, and TinySignal CRs.
CRD (Custom Resource Definition)
The schema that defines a Custom Resource type in Kubernetes.
D
Data Mapping
The process of transforming data from one structure to another using expressions in edge configurations.
Downstream
Components or nodes that receive output from the current component. In flow terms, components to the right or below.
E
Edge
A connection between two ports that defines data flow and transformation. Configured in TinyNode.spec.edges.
Edge Data
The configuration attached to an edge that specifies how data is transformed as it flows between ports.
Expression
A template syntax (double curly braces like { {...} }) used in edge configurations for dynamic data transformation. Supports path access, operators, and functions.
Expression Evaluator
The runtime component that parses and executes expressions, transforming input data according to expression rules.
F
Fan-In
A pattern where multiple flow paths converge into a single component.
Fan-Out
A pattern where a single component's output is sent to multiple downstream components.
Flow
A directed graph of connected nodes that defines data processing logic. Represented as a collection of TinyNode resources.
Flow Editor
The visual interface for creating and editing flows, displaying nodes, edges, and configurations.
G
GetInfo()
Component interface method that returns metadata about the component (name, title, description, category, tags).
gRPC
The protocol used for communication between different module pods. Enables cross-module message passing.
H
Handle()
The main component interface method that processes incoming messages. Receives context, output handler, port name, and message.
Handler
A function type func(ctx context.Context, port string, msg any) error used to send output messages from components.
Helm Chart
The packaging format for TinySystems modules, containing Kubernetes manifests and chart metadata for deployment.
I
Ingress
A Kubernetes resource that manages external HTTP access to services. Created by HTTP server components to expose endpoints.
Input Port
A port configured to receive messages (Source: true). Displayed on the left side of nodes in the flow editor.
Instance()
Component interface method that returns a new instance of the component. Used by the runtime to create component instances.
J
JSON Schema
The schema format automatically generated from Go structs to define port message structures and UI rendering.
K
Kubernetes Lease
A Kubernetes resource used for leader election. TinySystems uses leases to determine the leader replica for each node.
L
Leader
The pod instance that has acquired the Kubernetes lease for a TinyNode. Leaders are responsible for state modifications and certain operations (like HTTP servers, timers).
Leader-Reader Pattern
An architecture where one leader instance handles write operations while multiple reader instances can handle reads. Used for scalability.
M
Message
Data passed between components through ports. Messages are typed according to port configurations.
Metadata
Key-value pairs stored in TinyNode.Status.Metadata for sharing state across replicas. Read by all instances, written by leader.
Module
A container image that bundles related components. Deployed as a Kubernetes Deployment with gRPC server.
Module Discovery
The process by which modules register themselves with the platform via TinyModule CRs, making components available for use.
N
Namespace
A Kubernetes namespace where TinyNode resources and module pods are deployed.
Node
A visual representation of a component instance in the flow editor. Corresponds to a TinyNode resource.
O
Output Handler
The function passed to Handle() for sending messages to output ports. Signature: func(ctx context.Context, port string, msg any) error.
Output Port
A port configured to send messages (Source: false). Displayed on the right side of nodes in the flow editor.
P
Platform API
The API package (github.com/tiny-systems/platform-api) containing TinySystems CRD definitions.
Pod
A Kubernetes pod running a module's gRPC server. Multiple pods can run for the same module for scalability.
Port
A named connection point on a component for receiving or sending messages. Defined in the Ports() method.
Port Position
The visual placement of a port on a node: Top, Left, Right, or Bottom.
R
Reader
A non-leader pod instance that can process read-only operations and receive state from the leader via TinyNode metadata.
Reconcile
The Kubernetes controller loop that ensures actual state matches desired state. Triggers _reconcile port messages.
Reconcile Port
A system port (_reconcile) that receives TinyNode updates during reconciliation. Used for state propagation.
Resource Manager
A helper provided via _client port that creates Kubernetes resources (Services, Ingresses, Secrets).
Router
A component that directs messages to different output ports based on conditions.
S
Schema
The JSON Schema representation of a Go struct, used for UI generation and validation.
Secret
A Kubernetes resource for storing sensitive data (passwords, API keys). Referenced in settings via configRef.
Service
A Kubernetes Service that exposes module pods for network access. Created for gRPC endpoints and HTTP servers.
Settings
Component configuration provided via the _settings port. Defined as a Go struct with struct tags.
Settings Port
A system port (_settings) that receives component configuration when nodes are created or updated.
Signal
An ephemeral message trigger created via TinySignal CR. Used for manual triggers, testing, or scheduled operations.
Source Port
A port with Source: true, indicating it receives input. Confusingly named (historical), this means the port is a "source of messages for the component."
State Propagation
The mechanism for sharing state across replicas via TinyNode CR metadata. Leader writes, readers read.
Struct Tags
Go struct field annotations that control JSON Schema generation and UI rendering (e.g., json, title, description, required).
System Port
A built-in port for platform infrastructure: _settings, _control, _reconcile, _client.
T
TinyModule
A CR that registers a module with the platform, providing component metadata for the UI and enabling discovery.
TinyNode
The primary CR representing a component instance. Contains component reference, edges, and status.
TinySignal
A CR for sending one-time messages to nodes. Automatically deleted after processing.
Transformation
The process of converting data from input format to output format using expressions.
U
Upstream
Components or nodes that send messages to the current component. In flow terms, components to the left or above.
V
VitePress
The static site generator used for TinySystems documentation.
W
Webhook
An HTTP endpoint that receives events from external systems. Implemented using HTTP server components.
Workspace
An organizational unit in TinySystems that groups related flows and resources.
Acronyms
| Acronym | Meaning |
|---|---|
| API | Application Programming Interface |
| CLI | Command Line Interface |
| CR | Custom Resource |
| CRD | Custom Resource Definition |
| gRPC | gRPC Remote Procedure Call |
| HTTP | HyperText Transfer Protocol |
| JSON | JavaScript Object Notation |
| K8s | Kubernetes |
| RBAC | Role-Based Access Control |
| SDK | Software Development Kit |
| TLS | Transport Layer Security |
| UI | User Interface |
| YAML | YAML Ain't Markup Language |