Core Concepts and Terms

With Heisenware, you build and run custom applications that collect, connect, process, store, and visualize data. Understanding the following concepts and terms is key to mastering the platform.

Core Concepts

Heisenware is not just a drag-and-drop interface; it is a visual programming environment that exposes a sophisticated, distributed architecture designed for industrial scalability.

1. Transparency & Flexibility

Standard no-code platforms often act as "Black Boxes"—they abstract complexity so heavily that you hit a wall when you need custom logic. Heisenware operates much more transparently. We visualize the underlying engineering rather than hiding it.

• Visual, yet Code-Capable: You build logic visually using the Flow Builder, but you retain direct access to powerful developer tools like JavaScript expressions for data transformation, and YAML for configuration.

• No "No-Code Cliff": When pre-built blocks aren't enough, you don't hack workarounds. You simply extend the platform by wrapping your own code (Node.js, Python, C++) into Extensions that become native low-code blocks.

2. Object-Oriented Scalability

Unlike linear scripting tools that struggle to manage multiple devices, Heisenware uses a strict Object-Oriented Model. This allows you to build logic once and instantiate it across an entire fleet.

• Classes (The Blueprint): Reusable logic definitions (e.g., an Email class or a generic Machine connector).

• Instances (The Asset): Living, stateful copies of a Class. You don't write code for "Machine A"; you instantiate the Machine class with Machine A's specific IP and credentials.

• Stateful Context: Because member functions (methods) belong to specific instances, they inherently know their own context (e.g., which server configuration to use) without passing global variables.

3. Native Event-Driven Architecture

Industrial systems are asynchronous—sensors spike, users click, and machines stop at unpredictable times. Heisenware applications are natively Event-Driven.

• Reactive Logic: Your backend flows do not run in a linear loop. They sit dormant until a specific Trigger (an event) fires.

• Event Sources: Triggers can be user interactions (UI events) , data changes (e.g., a PLC tag update) , or system lifecycle events.

• Non-Blocking: This architecture ensures your UI remains responsive while backend logic handles complex data processing or long-running tasks asynchronously.

4. Distributed Connectivity

We solve the "OT vs. IT" network gap by treating local hardware as a first-class citizen of the cloud platform.

• The Bridge: Through Native Agents and Docker Agents, we securely bridge local, private networks (OT/Shopfloor) to the cloud without VPNs or firewall holes.

• Local Execution: You can push backend logic (Connectors) to run locally on the edge device (via the Agent). The platform treats these remote functions exactly the same as cloud functions, creating a seamless distributed system.

5. Unified Data Binding

We eliminate the "glue code" typically needed to connect a frontend to a backend.

• Direct Linking: In the App Builder, you connect a backend function's Output directly to a frontend widget's Property.

• Reactive UI: When the backend data changes (e.g., a new sensor reading flows out of a function), the bound UI widget (e.g., a Gauge) automatically re-renders to reflect the new state.

Glossary of Terms

A quick-reference list of specific terms used across the Heisenware platform.

Term	Description
Account	Highest level of organization in Heisenware. Your account should name like you company and will be used as part of the URL, e.g. acme.heisenware.cloud
Agent	An executable program deployed in a private network to establish a secure connection with a system in that network.
App	A stand-alone software application built and published with Heisenware. By nature, all Heisenware apps are Progressive Web Apps (PWAs).
App Builder	The visual, low-code development environment where you design, build, and test your applications.
App Manager	The administrative dashboard of the Heisenware platform where you manage your workspaces, apps, members, and integrations.
Application Logic	The part of an app that handles data processing and behavior, consisting of integrations, data storage solutions, and flows.
Build time	The phase when a developer is actively designing, configuring, and assembling an application in the App Builder.
Code Adapter	The piece of custom code a developer writes to wrap around existing software libraries, making them accessible to the Heisenware platform.
Command	An action that causes a temporary, non-persistent change to a widget's state, such as highlighting it.
Deployment	The process of publishing a new version of an app, making it live and accessible to end-users.
Domain	The domain combines your account and your workspace into a single identifier using a . for concatenation. If you did not create another workspace it will be called default . So for an account name acme the domain is: acme.default
Event	A trigger that the application can respond to, such as a user clicking a button, a database update, or a timer finishing.
Flow	A sequence of connected functions in the application logic that defines how data is processed and passed between different steps.
Integration	A configured, secure entry point that allows an external system (like an Agent or a Code Adapter) to send data to your Heisenware account.
JavaScript expressions	A feature allowing the use of standard JavaScript expressions to perform simple data transformations or calculations on the fly.
JSON (JavaScript Object Notation)	A standard data format supported in Heisenware for structuring and exchanging data.
JSONata	A powerful query and transformation language available within Heisenware to reshape complex data from one format to another on the fly.
Member	A user who has access to your Heisenware account to build and manage applications, as distinct from an end-user of a finished app.
Property	A setting or value of a widget that can be read or changed by the application logic and persists over time (e.g., the text inside an input field).
PWA (Progressive Web App)	An application that runs in a web browser but offers a user experience similar to a native mobile or desktop app, including fast performance and no installation requirement.
Runtime	The phase when a deployed application is live and actively running. During runtime, the app responds to user input and executes its logic.
Tag	A named and exportable version of a Heisenware app.
Template	A specific tag that serves as a starting point or blueprint for creating a new app.
User Interface (UI)	The visual part of an app that an end-user interacts with to view data, input data, and trigger actions.
Widget	A specific element of the user interface used to display data (e.g., a chart) or collect user input (e.g., a button or text field).
Workspace	A container within your account used to organize related apps, members, and integrations.
YAML	A human-readable data format often used for writing configuration files. In Heisenware, it is used to configure functions.