Recent developments of Large Language Models (LLMs) show great potential in many areas, including software architecture. Although there is some work on applying LLMs during architecture design, using LLMs for adaptation of the architecture of a collective adaptive system at runtime has not yet been explored enough. In this paper, we explore two approaches for how LLMs can serve for architecture adaptation of collective adaptive systems based on autonomic component ensembles. The first approach employs an LLM during runtime as a part of the adaptation manager; the other one asks the LLM to generate it (in Python), which is then used for the ensemble formation (resolution) at runtime. The prompts for both approaches are automatically generated from an architectural specification, which includes constraints for the architecture. Based on experimental observations of two use cases, we show that LLMs are quite capable in online prompting in particular. Even without being explicitly provided with an adaptation strategy, an LLM can come up with an efficient heuristic for ensemble resolution and realize it. We show that the limiting factor for using LLMs this way is not time complexity (as would be the case when solving the problem as constraint optimization), but the “laziness” of LLMs when prompted with a larger problem instance, as also recently reported in other works. In addition, we map how the correctness of the LLM’s solution scales with different forms of prompting and problem size, which captures the effect of the LLMs’ laziness under different conditions.

Abstract Ensemble-based component systems have been used for many years to develop collective adaptive systems (CAS). The DEECo component model offers a framework for modeling and implementing ensemble-based component systems. Being expressive enough and having semantics specifically tailored towards dynamically evolving systems, DEECo has proven to be fairly powerful in modeling complex and dynamic architectures. We see great potential in employing large language models (LLMs) to simplify creating and refining the DEECo architectures. Since this constitutes a large research scope, in this paper, we focus on initial experiments to demonstrate how well generic LLMs (two OpenAI models executed remotely and four open-source models executed locally) understand the advanced concepts of ensemble-based CAS embodied in DEECo. We do so by systematically asking six questions about specific details of three DEECo applications that differ in the way they are specified. Our results indicate that LLMs can indeed understand ensemble-based architectures and show how this is influenced by the specification means. In particular, using external DSL, which is very self-explanatory, gave good results out of the box. Specifications embedded in existing programming languages needed a prior explanation of how to interpret them.

Systematic literature mapping is an essential part of research methodology. Conducting a systematic literature mapping is challenging. Researchers query publications from various sources, which need to be filtered, categorized, and cleared of duplicates. It is usually the case that the number of publications ranges between hundreds to thousands. The whole process is often performed iteratively and repeatedly, especially at the start of the mapping study, which only further increases the effort. When a team of researchers conducts a mapping study, the members may have different opinions on filtering and categorizing papers, which must be resolved. To our knowledge, this problem is very poorly supported by open-source tools. To address these issues, we present a tool called Robin which facilitates managing the steps of conducting a mapping study within a team. It provides search tools, categorization, and a platform for team members to define their criteria for including and excluding papers. In addition, Robin is connected to publicly available publications search platforms such as IEEE API and Scopus API. Robin is written in Python-Django and can be installed as a web application.

Since the first Mario AI Competition in 2009 where Mario AI Framework made a debut, there is a continuous interest to use the game and the framework for research in AI. Decent amount of these papers is using the A-Star algorithm along with the game forward model and some results are directly depending on the quality of the best known A-Star-based agent by Robin Baumgarten. In this paper, we are revisiting and improving the implementation of Mario AI Framework’s forward model by two orders of magnitude and also presenting a new A-Star-based agent that outperforms the current state-of-the-art agent by a large margin.

This tool paper presents the IVIS platform for processing and visualizing IoT and CPS data. The platform provides a web-based interface that allows both definition of complex visualizations and data processing jobs as well as exploring the data. Compared to the existing open-source and commercial offerings, IVIS follows a different model and focuses on flexibility. Instead of providing a complex administrative UI for creating visualizations by dragging and dropping components onto a dashboard, IVIS provides a set of JavaScript-based visualization components that are glued together using simple JavaScript code. Similarly, the data processing jobs can be defined using code in scripting languages, such as Python, which allows exploiting the wealth of existing libraries for numerical processing. This not only makes the definition of visualizations and data processing jobs much more expressive, but it also turns out to be significantly easier to use when building complex parametric visualizations- especially when they need to deal with many sensors. This proved to be crucial in deploying IVIS in a number of international research projects, because it enabled us to rapidly setup complex visualizations and data-processing tasks, catering to project- and partner-specific requirements.