Abstract Low-code platforms accelerate development of mission-critical applications, enabling users with less technical backgrounds to become proficient developers. AI-powered multi-agent systems further boost this experience. Large language models (LLMs) excel at understanding user intent, but alone cannot guarantee that design rules are followed - formal methods can provide such guarantees. We propose a hybrid approach that leverages both LLMs and a maximum satisfiability solver to generate layouts that comply with UX guidelines (e.g., widget ordering and grouping rules) while respecting user intent. We evaluate the approach in production against an LLM-only baseline.

Low-code platforms enable rapid development of complex mission-critical software applications. High-level abstractions accompanied by AI assistance allow users with less technical backgrounds to become proficient developers. Technical debt is the cost of additional rework in software development caused by choosing a fast delivery over maintainability. Even though low-code abstracts significantly complex applications, projects can still suffer from technical debt. OutSystems guides developers through the AI Mentor System (AIMS), a centralized platform to monitor code quality. This paper explores the application of state-of-the-art tools in an industry setting of low-code editors. OutSystems has users with and without technical background, providing new challenges and mixed user feedback. We address the challenges of managing technical debt, where users have a wide range of experience, focusing on the results of the different patterns present in AIMS since its release in 2017. For instance, the usefulness of a pattern is determined not only by its correct detection, as it can have an unclear path (or be time-consuming) for refactoring. In the paper, we deep dive into the feedback and insights focusing primarily on two patterns: duplicated code and missing descriptions. Finally, we discuss the broader challenges of developing and evolving AIMS itself, particularly in the context of the mental models and expectations that low-code users bring.

Graph matching is a fundamental problem in pattern recognition, with many applications such as software analysis and computational biology. One well-known type of graph matching problem is graph isomorphism, which consists of deciding if two graphs are identical. Despite its usefulness, the properties that one may check using graph isomorphism are rather limited, since it only allows strict equality checks between two graphs. For example, it does not allow one to check complex structural properties such as if the target graph is an arbitrary length sequence followed by an arbitrary size loop. We propose a generalization of graph isomorphism that allows one to check such properties through a declarative specification. This specification is given in the form of a Regular Graph Pattern (ReGaP), a special type of graph, inspired by regular expressions, that may contain wildcard nodes that represent arbitrary structures such as variable-sized sequences or subgraphs. We propose a SAT-based algorithm for checking if a target graph matches a given ReGaP. We also propose a preprocessing technique for improving the performance of the algorithm and evaluate it through an extensive experimental evaluation on benchmarks from the CodeSearchNet dataset.

Low-code platforms enable rapid development of complex mission critical software applications. Nevertheless, these applications still must adhere to software principles. In particular, the developers need to create tests as part of their development cycle. However, this process involves significant effort from manual testing to manually coding tests. This process can be time-consuming and error-prone, especially for large and complex applications. In this paper, we propose using symbolic execution to generate tests for low-code applications. Symbolic execution is a technique that allows the exploration of all possible paths of a program, without requiring it to be executed with concrete values. Although symbolic execution has scalability issues due to path explosion, we mitigate the problem by exploring the properties of the low-code framework. We evaluate our approach using a set of real-world low-code applications and compare it to equivalent testing techniques for text-based programming languages. Our results show that symbolic execution can produce high quality results in a short amount of time when applied to visual programming languages. We believe that our approach has the potential to improve the quality and reliability of low-code applications while reducing the time and effort required for testing.

This paper proposes an iterative Maximum Satisfiability (MaxSAT) approach designed to solve train scheduling optimization problems. The generation of railway timetables is known to be intractable for a single track. We consider hundreds of trains on interconnected multi-track railway networks with complex connections between trains. Furthermore, the proposed algorithm is incremental to reduce the impact of time discretization. The performance of our approach is evaluated with the real-world Swiss Federal Railway (SBB) Crowd Sourcing Challenge benchmark and Periodic Event Scheduling Problems benchmark (PESPLib). The execution time of the proposed approach is shown to be, on average, twice as fast as the best existing solution for the SBB instances. In addition, we achieve a significant improvement over SAT-based solutions for solving the PESPLib instances. We also analyzed real schedule data from Switzerland and the Netherlands to create a disruption generator based on probability distributions. The novel incremental algorithm allows solving the train scheduling problem under disruptions with better performance than traditional algorithms.