Available translations
loading results
Hierarchies
Summary: A hierarchy is a data structure representing an overarching, top-level concept, resulting in a long chain of nodes, usually with many ramifications. The system manages different types of hierarchies, each of them with a specific focus.
In the design space, the head or parent node of each hierarchy is represented by the corresponding icon surrounded by an ever-present white ring, so that they are easier to locate within the workspace.
Important: Hierarchies included in the workspace as plugins are not saved at the workspace level. As such, changes made in those hierarchies do not persist. If you wish to modify a plugin and keep working with the modified version in the future, you must either clone or backup the plugin and work on the resulting copy instead.
Foundations Project
Foundations->Node->Foundations Project->Definition
The Foundations Project hierarchy governs the assets that relate to Superalgos. In its current state, it serves the purpose of spawning hierarchies.
Foundations->Node->Foundations Project->Content
Superalgos is a multi-project platform meaning that other crypto-projects may be integrated. It is in this context that project-specific hierarchies exist.
A crypto-project integration means that Superalgos users will able to connect to blockchain nodes from within Superalgos, exposing the blockchain data to the rest of the Superalgos infrastructure. Users will be able to mine the node's data, build indicators, use them from within trading systems, and visualize blockchain information on the charts—among other things.
Design Space
Foundations->Node->Design Space->Definition
The Design Space is the visual environment that hosts all system and user definitions. In practical terms, it is the black space below the slider that splits the screen horizontally, separating the Design Space in the bottom from the Charting Space on top. As a hierarchy, it features nodes that enable user-control over certain aspects of the look, feel, and behavior of the space.
Foundations->Node->Design Space->Content
Think of the design space as your desktop, or the control room of the system.
Crypto Ecosystem
Foundations->Node->Crypto Ecosystem->Definition
The crypto ecosystem is a hierarchy that contains definitions about third-parties, including exchanges and their markets, as well as accounts of users with those third parties.
Foundations->Node->Crypto Ecosystem->Content
There is only one crypto ecosystem hierarchy. You will use it to define which exchanges and which markets you wish to work with, as well as the details of your accounts with those exchanges.
LAN Network
Foundations->Node->LAN Network->Definition
The network hierarchy provides the control functions for running data-mining and trading operations. Because operations may be run either on a single machine or distributed over a network of machines, it also contains definitions regarding the physical location in which nodes live or function.
Foundations->Node->LAN Network->Content
The network hierarchy defines where in the network you run each of the bots you choose to run, and where the data they output is stored.
You will use the network hierarchy for the following purposes:
- To control your data mining operation — that is, tasks running sensor and indicator bots. Data mining tasks process data that may be consumed by others; for example, so that your trading systems may count with quality information.
- To control your testing environment — that is, trading sessions including backtesting and paper trading sessions.
- To control your production environment—that is, forward testing, and live trading sessions.
- To manage the storage of the data produced by the bots you run as outputs. This includes administering the physical locations on which the data products produced by bots reside.
Warning: At this stage, the system does not implement any form of security measures, therefore, Superalgos is to be run in the context of a restricted Local Area Network only, unless you implement your own network security.
Charting Space
Foundations->Node->Charting Space->Definition
The charting space is the hierarchy that governs the configuration of the charts, and the bidimensional space on which charts are drawn.
Foundations->Node->Charting Space->Content
Think of the charting space as a huge drawing board. You may have lots of information plotted on different parts of the space and use a viewport to look into that space.
There is only one charting space hierarchy, thus all charts are configured here. As is common throughout the system, different concepts and elements of the charts such as scales, data layers and so on, are represented by nodes in the hierarchy. The system allows great flexibility on how to visualize information over the charts by adding, configuring, and arranging these nodes.
Trading System
Algorithmic-Trading->Node->Trading System->Definition
A trading system is a framework handling the low-level logic that serves to structure the processes and methods used to implement and deploy trading strategies.
Algorithmic-Trading->Node->Trading System->Content
In practical terms, a trading system is a hierarchical arrangement organizing the actionable aspects of your investment plan. The hierarchy contains definitions regarding any number of trading strategies, all operating on the same market and sharing the same initial capital allocation.
You use a trading system to define strategies following the Superalgos Protocol, splitting strategies into four stages: trigger, open, manage, and close.
The concept of describing strategies in stages is fundamental to the methodical aspect of the trading system, as it provides a framework to run every strategy with the same framework, which contributes to developing scalable trading systems that may grow to any number of strategies.
When a trading system features more than one strategy, the first strategy has precedence over the second, the second over the third, and so on. This means that strategies are evaluated in a sequence. When a given strategy is triggered-on, the remaining strategies in the queue are no longer evaluated until the strategy triggers off. In other words, when multiple strategies are deployed within a single trading system, only one strategy may trade at any given moment, and precedence is given by the order around the trading system node.
As a corollary to the above, if you wish strategies to operate in different markets, or you wish strategies to be able to take positions simultaneously, then you must set up those strategies in different trading systems.
Trading Mine
Algorithmic-Trading->Node->Trading Mine->Definition
A trading mine is a hierarchy that contains definitions of trading bots and their plotters. These definitions make up the actual programs of such bots—the source code.
Algorithmic-Trading->Node->Trading Mine->Content
Although Superalgos is starting out with a single trading bot, the system is prepared to feature as many trading bots as developers are willing to create. As such, a trading mine is a catalog of trading bots.
Notice that, in the context of Superalgos, a trading bot has nothing to do with the trading logic. Think of trading logic as the business rules which—in Superalgos—are defined in trading systems. Anyone may build a Trading System, meaning that creating trading systems and the trading strategies within does not require coding.
Trading mines work similarly to data mines in the sense that they provide the same kind of tools to structure the definitions of bots, including process definitions, product definitions, and plotters.
Trading Engine
Algorithmic-Trading->Node->Trading Engine->Definition
The trading engine hierarchy is the data structure used by the trading bot to keep runtime information highly accessible and exposed to others.
Algorithmic-Trading->Node->Trading Engine->Content
You will use this hierarchy for two main purposes:
- To let your trading systems access the information processed by the trading bot. This allows strategies to keep track of and react to current and past events—including those involving the exchange, such as orders placed or filled—as the bot is running.
- To keep track of the actions of the trading bot via the design space visual environment and panels over the charts. By analyzing runtime information, you may gain a detailed understanding of what happens, when, and why, throughout a trading session.
Frequently Asked Questions
Can a Trading Engine be shared between two Trading Bots?
The same trading engine can be used from multiple trading sessions, because it is just a node-based representation of a data structure.
Every time a Task is ran, a snapshot of that data structure, together with a snapshot of the Network and the Bots definitions at their Data Mine is sent from the UI to the Task Server, and from there is consumed by the running Bot. That means that a second Bot can receive the same Trading Engine snapshot and it will never know if other bots were fed with the same information or not.
Do I need to change something at the Trading Engine?
You don't need to physically change anything inside trading engine via the UI. The trading engine is a visual representation of the data structure that the trading system uses to store its values, so to speak.
Can I change the values inside the Trading Engine?
You access the Trading Engine from within your trading system if there is something in there you would like to change. This is the whole purpose of the User Defined Code node.
Data Mine
Data-Mining->Node->Data Mine->Definition
A data mine is a hierarchy that contains definitions of sensor and indicators bots, and their plotters. These definitions are consumed from the actual code of such bots.
Data-Mining->Node->Data Mine->Content
In a way, data mines are catalogs of bots that anyone may create. This hierarchy provides all the tools required to create sensors, indicators, and plotters, with minimal coding required.
Because the hierarchy provides definitions, it does not intervene in the execution of bots. Instead, the definitions in data mines are instantiated from the network hierarchy by bot instances. Bot instances and process instances are the ones running the code according to the definitions in the corresponding data mine.
Plugins
Community-Plugins->Node->Plugins->Definition
The plugins hierarchy defines which plugins are to be included in the current workspace. In the context of this hierarchy, plugins are JSON files featuring the description of a hierarchy such as a data mine, trading mine, trading engine, or trading system.
Community-Plugins->Node->Plugins->Content
In the context of a community-driven project, a plugin is a device that serves to distribute community-generated intelligence. The project distributes several plugins contributed by the community.
Important: Hierarchies included in the workspace as plugins are not saved at the workspace level. As such, changes made in those hierarchies do not persist. If you wish to modify a plugin and keep working with the modified version in the future, you must either clone or backup the plugin and work on the resulting copy instead.
Tutorial
Education->Node->Tutorial->Definition
The tutorial hierarchy features a free arrangement of Tutorial Topic and Tutorial Step nodes that make up a tutorial. Each node in the hierarchy, including the parent tutorial node, represents an HTML page that may be overlaid on top of both the Design Space and the Charting Space.
Education->Node->Tutorial->Content
Nodes in the hierarchy may be arranged freely, meaning that there may be as many tutorial topics and tutorial steps as desired. Tutorial topics may contain tutorial steps but also other tutorial topics. This allows nesting topics to be used as subtopics.
The system – as usual – evaluates the hierarchy in a clockwise direction starting from the node to the right of the parent Tutorial node, and goes to the deepest node of each branch before moving to the next one.
In general terms, all types of nodes behave similarly in the sense that each node, independently of the precise type, represents a tutorial step in and of itself. That is, all nodes including the top-level Tutorial node, the Tutorial Topic node, and the Tutorial Step node may display a content page as a step in the tutorial. Subtle differences shall be pointed where appropriate.
Note: The key similarity among all types of nodes in the hierarchy is that all of them may draw content from the tutorial's collection of pages in the Docs. That is, each node in the hierarchy points to a Docs Page, and it is that page in the Docs that features the content displayed for the given step. The pointer is specified in the configuration of each node (see the docs property).
Super Scripts
Foundations->Node->Super Scripts->Definition
The super scripts hierarchy holds definitions of scripts used to automate certain aspects of the administration and maintenance of the workspace, such as installing and deleting markets.
Foundations->Node->Super Scripts->Content
The super scripts hierarchy may be used by developers who wish to create their own scripts for automating the deployment or maintenance of all sorts of structures of nodes across any of the hierarchies in the design space.
Regular users will find little to do with this hierarchy, even though they may use it indirectly, for instance, when installing or uninstalling markets.
Introduction — TOC
You just read page 3 in the topic.
1. Fundamental Superalgos Concepts
3. Hierarchies
4. Workflows
5. Workspaces
6. Nodes and Structures of Nodes
7. References