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.

Automatic processing of requirements (e.g. to generate code) remains a challenge in contemporary software development.Requirements are still treated as secondary artifacts by software developers, as they are written in natural languages which causes ambiguity.In this paper, we present an approach to generate working code from requirements through applying precisely formulated domain models.As the source, we use the Requirements Specification Language (RSL) which is a precise constrained language, based on a central domain model composed of domain notions.These notions are linked from use case scenarios and create a form of a 'wiki'.Notions are graphically visualized in RSL, and resemble UML classes with attributes.Notions can be used in phrases that can represent various operations used within use case scenarios.In our approach we introduce model transformation algorithms that allow to generate database access code associated with operations to persist (store, retrieve) data in a database system.To focus our work, we present code generated for Hibernate which is an object relational mapping framework.

During acceptance testing different areas of delivered software system are reviewed.Usually these are functionality, business domain logic, non-functional characteristics, user interface.Although they are related to the same particular functional area, they are verified separately.This paper presents the concept and the Requirements Driven Software Testing (ReDSeT) tool, which allows for automatic integrated test generation based on different types of requirements.Tests are expressed in newly introduced Test Specification Language (TSL).The basis for functional test generation are detailed use case models.Furthermore, by combining different types of requirements, relations between tests are created.The constructed tool acknowledges validity of the presented concept.

This paper presents a tool suite that automates transition from precise use case and domain models to code. The suite is built around the Requirements Specification Language (RSL) that is based on a precise constrained language grammar. RSL specifications can be used to generate complete MVC/MVP code structure together with method bodies of the Controller layer.

Direct end-user participation in software system construction necessitates bringing general-purpose programming activities to the level understandable by “laymen”. This paper introduces a new software development approach where stories written in commonly understood structured natural language gain runtime semantics. Stories are precisely linked to domain concepts and actions, thus forming the application logic of the system. These constructs are written at a high level of abstraction, very close to detailed software requirements specifications. In fact, they are structured into familiar use case models that include special “invocation” relationships between use cases. At the same time, the paper proposes precise translational semantics for such defined stories. For each story element, equivalent Java code is derived. This semantics has been implemented within a tool containing a story editor and a code generator producing fully dynamic application logic code with Swing-based user interface. Ease of use of the new story language and usefulness of the generated Java code has been evaluated through student assignment projects.

A case-based approach allows reuse without the usual and significant effort for making software explicitly reusable. We even support such reuse for only partially developed requirements, since it allows reuse already without the need to develop a “complete” specification first. The solution information (models and code) of (one of) the most similar problems can then be taken for reuse and adapted to the newly specified requirements. And even the specification of these new requirements can be facilitated, since the retrieved software case contains related requirements, which may be reused as well.

In order to make requirements comprehensible to humans and as unambiguous as possible, a glossary and/or domain model is needed for defining the terminology used. Unless these are available from related projects, however,they are hard to create. Therefore, we propose to reuse terminology and its definition for requirements specifications from the semantic lexicon WordNet. For making this useful, however, we had to deal with the issue of disambiguation of the general terminology there for a given domain of a requirements specification.