Large-scale computation (LSC) systems are often performed in distributed environments where message passing is the key to orchestrating computations.In this paper, we present a new message queue concept developed within the context of an LSC system (BalticLSC).The concept consists in proposing a multi-queue, where queues are grouped into families.A queue family can be used to distribute messages of the same kind to multiple computation modules distributed between various nodes.Such message families can be synchronised to implement a mechanism for initiating computation jobs based on multiple data inputs.Moreover, the proposed multi-queue has built-in mechanisms for controlling message sequences in applications where complex data set splitting is necessary.The presented multi-queue concept was successfully implemented and applied in a working LSC system.

Abstract Distributed, large-scale computing is typically performed using textual general-purpose programming languages. This requires significant programming skills associated with the parallelisation and distribution of computations. In this paper, we present a visual (graphical) programming language called the Computation Application Language (CAL) to raise abstraction in distributed computing. CAL programs define computation workflows by visualising data flowing between computation units. The goal is to reduce the amount of traditional code needed and thus facilitate development even by non-professional programmers. The language follows the low-code paradigm, i.e. its implementation (the editor and the runtime system) is available online. We formalise the language by defining its syntax using a metamodel and specifying its semantics using a two-step approach. We define a translation of CAL into an intermediate language which is then defined using an operational approach. This formalisation was used to develop a programming and execution environment. The environment orchestrates computations by interpreting the intermediate language and managing the instantiation of computation modules using data tokens. We also present an explanatory case-study example that shows a practical application of the language.

Typical Low-Code Development platforms enable model-driven generation of web applications from high-level visual notations.They normally express the UI and the application logic, which allows generating the frontend and basic CRUD operations.However, more complex domain logic (data processing) operations still necessitate the use of traditional programming.This paper presents a visual language, called RSL-DL, to represent domain knowledge with complex domain rules aligned with requirements models.The language synthesises and extends approaches found in knowledge representation (ontologies) and software modelling language engineering.Its purpose is to enable a fully automatic generation of domain logic code by reasoning over and reusing domain knowledge.The language's abstract syntax is defined using a meta-model expressed in MOF.Its semantics is expressed with several translational rules that map RSL-DL models onto typical programming language constructs.The rules are explained informally in natural language and formalised using a graphical transformation notation.It is also supported by introducing an inference engine that enables processing queries to domain models and selecting appropriate invocations to generated code.The presented language was implemented by building a dedicated model editor and transformation engine.It was also initially validated through usability studies.Based on these results, we conclude that declarative knowledge representations can be successfully used to produce imperative back-end code with non-trivial logic.

Research teams often face problems with insufficient resources to develop and execute their computation algorithms. This is due to limited access to professional programmers and High Performance Computing centres. This paper presents a platform that uses a new visual language to solve these problems. It uses high-level abstractions to define the flow of data and the execution of computation modules in a distributed computation environment. The runtime system follows the rules of low-code, where the development is on-line and highly simplifies the deployment of apps. This way, even small research teams can easily gain access to high-end computation resources and develop and share their applications.