Low-Code Platforms (LCPs) and AI assistants accelerate and democratise application development by generating artefacts through visual tools, drag-and-drop components, prebuilt logic, and large language models (LLMs) for professional and citizen developers. While prior work has examined these approaches in isolation, the comparative use of these approaches for developing applications remains insufficiently understood. This paper presents a case study, in which multiple teams developed a web application based on the same requirements over 13 weeks using LCPs, LCPs with AI integration, or AI-assisted development. The study combines report and repository analysis with longitudinal survey data to capture technology usage, development processes, and developer perceptions. This primarily qualitative study aims to identify new insights into the potential and limitations of web development with LCPs and AI assistants. Our results suggest that LCPs with integrated AI enhance development efficiency and predictability compared to traditional LCPs and purely AI-assisted development.
L. Hofmann, Philipp Wieber, Gabriele Taentzer· Proceedings of the ACM/IEEE...· 0 citations
Mutation testing is an approach to checking the robustness of test suites. The program code is slightly modified by mutations to inject bugs, and a test suite is robust enough if it finds them. Mutation testing tools provide sets of mutation operators, such as swapping arithmetic operators, to make small modifications to the program. The results of mutation tests depend directly on the possible mutations. These mutations should cause actual changes in the program behavior, but also should not prevent the program from being loaded and executed. The more advanced mutations are, the more they challenge the test suite. Existing non-model-based mutation testing tools do not support the definition of advanced mutation operators that go beyond manipulating a small number of adjacent instructions within a single method. Thus, we present a
model-driven
approach where mutations of Java bytecode can be flexibly defined as model transformations. Our tool, Model-based Mutation Testing (MMT), implements this approach and includes model transformations for conventional and advanced mutation operators, such as deleting overridden methods or changing type casts. To evaluate the effectiveness and efficiency of model-driven mutation testing, we have applied MMT to all projects and versions in Defects4J, a well-established collection of real-world Java projects with reproducible bugs. We check for MMT’s ability to generate mutants close to real bugs and compare it with the non-model-based mutation testing tools Jumble, PIT, and
$$\mu $$
μ
BERT. Our evaluation shows that MMT and PIT are significantly more effective and efficient than
$$\mu $$
μ
BERT and Jumble. MMT even outperforms PIT in its ability to generate such realistic bugs, with similar efficiency per generated mutant. Jumble and
$$\mu $$
μ
BERT are one or two orders of magnitude slower than MMT and PIT. There are some bugs reconstructed by only one of the tools, including some that only the advanced operators of MMT could replicate. Fifteen percent of the Defects4J project versions had bugs that could not be reconstructed by the mutation operators of any of the investigated tools. This shows that further research in mutation operators, as enabled by MMT, has high potential. Our mutation testing tool MMT is available online https://gitlab.uni-marburg.de/fb12/plt/modbeam-mt/mmt, as well as all the evaluation data (Ancona et al., Evaluation data of comparison of mutation testing tools. https://doi.org/10.5281/zenodo.20054492).
Freya Ancona, Christoph Bockisch, Daniel Neufeld et al.· Journal of Software and Syst...· 0 citations
We use cookies to run the site and, with your consent, for analytics and to show ads.
See our Cookie Policy.
