JGJens Grabowski

Jens Grabowski

*This is an algorithmically generated author record based on publicly available information.

Current Organizations / Institutes

The organizations/institutes from the scholar's latest article


Jens Grabowski has a total of 37 co-authors. Here are the top co-authors by number of shared publications:


Latest Publications

  • Open Access

    From diagnosis to repair: A model-driven framework for root cause analysis of machine learning pipelines

    by Emmanuel Charleson Dapaah, Jens Grabowski

    Machine learning pipeline debugging remains costly because predictive performance depends on complex interactions between dataset characteristics and configuration choices. In practice, however, practitioners often lack tools that can both explain performance failures and estimate the likely impact of repairs without repeated reruns. To address this challenge, we propose a model-driven framework for root cause analysis and hyperparameter intervention that operates solely on structured descriptors. The framework uses three dataset-complexity meta-features, namely class overlap, class imbalance, and sparsity, together with learner hyperparameters. We evaluate the approach on two model families, Decision Trees (DT) and Multilayer Perceptrons (MLP). For each family, we construct a meta-dataset comprising 81,000 pipeline runs generated from 270 datasets and 300 hyperparameter configurations. We then train an interpretable Explainable Boosting Machine (EBM) as a meta-model and assess predictive fidelity using GroupKFold partitioning by dataset to prevent data leakage. The study yields three main findings. First, descriptor-based performance prediction generalizes well across the two model families considered, achieving $$Mean~Absolute~Error (MAE)=0.080$$ M e a n A b s o l u t e E r r o r ( M A E ) = 0.080 and $$Root~Mean~Squared~Error (RMSE)=0.108$$ R o o t M e a n S q u a r e d E r r o r ( R M S E ) = 0.108 for DT, and $$MAE=0.087$$ M A E = 0.087 and $$RMSE=0.115$$ R M S E = 0.115 for MLP. Second, the trained meta-model learns directionally coherent relationships that align with prior domain knowledge, enabling root cause diagnosis to identify meaningful drivers of both pipeline success and failure. In our results, successful ML pipelines are primarily associated with low class overlap, whereas failures are typically linked to high class imbalance or overlap, often amplified by unfavorable configuration choices such as restrictive tree-growth settings or optimization-sensitive MLP hyperparameters. Importantly, these attributions remain consistent with the expectation rules even when prediction residuals are non-trivial. Third, the causal hyperparameter intervention module accurately estimates post-intervention performance for hyperparameters identified as root causes, with a mean absolute intervention error of approximately 0.036 for both DT and MLP. Taken together, these results show that the proposed framework provides actionable root cause diagnosis and reliable hyperparameter intervention guidance for debugging machine learning pipelines.

  • Open Access

    Scientific workflow execution in the cloud using a dynamic runtime model

    by Johannes Erbel, Jens Grabowski

    To explain specific phenomena, scientists perform a sequence of tasks, e.g., to gather, analyze and interpret data, forming a scientific workflow. Depending on the complexity of the workflow, scientists require access to various kinds of tools, applications and infrastructures for individual tasks. Current approaches are often limited to managing these resources at design time, requiring the scientist to preemptively set up applications essential for their workflow. Therefore, a dynamic provisioning and configuration of computing resources are required that fulfills these needs at runtime. In this paper, we present a dynamic runtime model that couples workflow tasks with their individual applications and infrastructure requirements. This runtime model is used as a knowledge base by a model-driven workflow execution engine orchestrating the sequence of tasks and their infrastructure. We exhibit that the simplicity of the runtime model supports the creation of highly tailored infrastructures, the integration of self-developed applications, as well as a human-in-the-loop allowing scientists to monitor and interact with the workflow at runtime. To tackle the heterogeneity of cloud provider interfaces, we implement the workflow runtime model by extending the Open Cloud Computing Interface cloud standard, which provides an extensible data model as well as a uniform interface to manage cloud resources. We demonstrate the applicability of our approach using three case studies and discuss the benefits of the runtime model from a user and system perspective.


  • Open Access

    A new perspective on the competent programmer hypothesis through the reproduction of bugs with repeated mutations

    by Zaheed Ahmed, Eike Stein, Steffen Herbold, Fabian Trautsch, Jens Grabowski

    The competent programmer hypothesis states that most programmers are competent enough to create correct or almost correct source code. Because this implies that bugs should usually manifest through small variations of the correct code, the competent programmer hypothesis is one of the fundamental assumptions of mutation testing. Unfortunately, it is still unclear if the competent programmer hypothesis holds and past research presents contradictory claims. Within this article, we provide a new perspective on the competent programmer hypothesis and its relation to mutation testing. We try to re-create real-world bugs through chains of mutations to understand if there is a direct link between mutation testing and bugs. The lengths of these paths help us to understand if the source code is really almost correct, or if large variations are required. Our results indicate that while the competent programmer hypothesis seems to be true, mutation testing is missing important operators to generate representative real-world bugs.

  • Open Access

    Are automated static analysis tools worth it? An investigation into relative warning density and external software quality on the example of Apache open source projects

    by Alexander Trautsch, Steffen Herbold, Jens Grabowski

    Automated Static Analysis Tools (ASATs) are part of software development best practices. ASATs are able to warn developers about potential problems in the code. On the one hand, ASATs are based on best practices so there should be a noticeable effect on software quality. On the other hand, ASATs suffer from false positive warnings, which developers have to inspect and then ignore or mark as invalid. In this article, we ask whether ASATs have a measurable impact on external software quality, using the example of PMD for Java. We investigate the relationship between ASAT warnings emitted by PMD on defects per change and per file. Our case study includes data for the history of each file as well as the differences between changed files and the project in which they are contained. We investigate whether files that induce a defect have more static analysis warnings than the rest of the project. Moreover, we investigate the impact of two different sets of ASAT rules. We find that, bug inducing files contain less static analysis warnings than other files of the project at that point in time. However, this can be explained by the overall decreasing warning density. When compared with all other changes, we find a statistically significant difference in one metric for all rules and two metrics for a subset of rules. However, the effect size is negligible in all cases, showing that the actual difference in warning density between bug inducing changes and other changes is small at best.


  • Open Access

    What really changes when developers intend to improve their source code: a commit-level study of static metric value and static analysis warning changes

    by Alexander Trautsch, Johannes Erbel, Steffen Herbold, Jens Grabowski

    Many software metrics are designed to measure aspects that are believed to be related to software quality. Static software metrics, e.g., size, complexity and coupling are used in defect prediction research as well as software quality models to evaluate software quality. Static analysis tools also include boundary values for complexity and size that generate warnings for developers. While this indicates a relationship between quality and software metrics, the extent of it is not well understood. Moreover, recent studies found that complexity metrics may be unreliable indicators for understandability of the source code. To explore this relationship, we leverage the intent of developers about what constitutes a quality improvement in their own code base. We manually classify a randomized sample of 2,533 commits from 54 Java open source projects as quality improving depending on the intent of the developer by inspecting the commit message. We distinguish between perfective and corrective maintenance via predefined guidelines and use this data as ground truth for the fine-tuning of a state-of-the art deep learning model for natural language processing. The benchmark we provide with our ground truth indicates that the deep learning model can be confidently used for commit intent classification. We use the model to increase our data set to 125,482 commits. Based on the resulting data set, we investigate the differences in size and 14 static source code metrics between changes that increase quality, as indicated by the developer, and changes unrelated to quality. In addition, we investigate which files are targets of quality improvements. We find that quality improving commits are smaller than non-quality improving commits. Perfective changes have a positive impact on static source code metrics while corrective changes do tend to add complexity. Furthermore, we find that files which are the target of perfective maintenance already have a lower median complexity than files which are the target of non-pervective changes. Our study results provide empirical evidence for which static source code metrics capture quality improvement from the developers point of view. This has implications for program understanding as well as code smell detection and recommender systems.


  • Open Access

    What really changes when developers intend to improve their source code: a commit-level study of static metric value and static analysis warning changes

    by Alexander Trautsch, Johannes Erbel, Steffen Herbold, Jens Grabowski

    Many software metrics are designed to measure aspects that are believed to be related to software quality. Static software metrics, e.g., size, complexity and coupling are used in defect prediction research as well as software quality models to evaluate software quality. While this indicates a relationship between quality and software metrics, the extent of it is not well understood. Moreover, recent studies found that complexity metrics may be unreliable indicators for understandability of the source code. To explore this relationship, we leverage the intent of developers about what constitutes a quality improvement in their own code base. We manually classify a randomized sample of 2,533 commits from 54 Java open source projects as quality improving depending on the intent of the developer by inspecting the commit message. We distinguish between perfective and corrective maintenance via predefined guidelines and use this data as ground truth for the fine-tuning of a state-of-the art deep learning model for natural language processing. We use the model to increase our data set to 125,482 commits. Based on the resulting data set, we investigate the differences in size and 14 static source code metrics between changes that increase quality, as indicated by the developer, and other changes. We find that quality improving commits are smaller than other commits. Perfective changes have a positive impact on static source code metrics while corrective changes do tend to add complexity. Furthermore, we find that files which are the target of perfective maintenance already have a lower median complexity than other files. Our study results provide empirical evidence for which static source code metrics capture quality improvement from the developers point of view. This has implications for program understanding as well as code smell detection and recommender systems.

  • Open Access

    A longitudinal study of static analysis warning evolution and the effects of PMD on software quality in Apache open source projects

    by Alexander Trautsch, Steffen Herbold, Jens Grabowski

    Automated static analysis tools (ASATs) have become a major part of the software development workflow. Acting on the generated warnings, i.e., changing the code indicated in the warning, should be part of, at latest, the code review phase. Despite this being a best practice in software development, there is still a lack of empirical research regarding the usage of ASATs in the wild. In this work, we want to study ASAT warning trends in software via the example of PMD as an ASAT and its usage in open source projects. We analyzed the commit history of 54 projects (with 112,266 commits in total), taking into account 193 PMD rules and 61 PMD releases. We investigate trends of ASAT warnings over up to 17 years for the selected study subjects regarding changes of warning types, short and long term impact of ASAT use, and changes in warning severities. We found that large global changes in ASAT warnings are mostly due to coding style changes regarding braces and naming conventions. We also found that, surprisingly, the influence of the presence of PMD in the build process of the project on warning removal trends for the number of warnings per lines of code is small and not statistically significant. Regardless, if we consider defect density as a proxy for external quality, we see a positive effect if PMD is present in the build configuration of our study subjects.


  • Open Access

    A Longitudinal Study of Static Analysis Warning Evolution and the Effects of PMD on Software Quality in Apache Open Source Projects

    by Alexander Trautsch, Steffen Herbold, Jens Grabowski

    Automated static analysis tools (ASATs) have become a major part of the software development workflow. Acting on the generated warnings, i.e., changing the code indicated in the warning, should be part of, at latest, the code review phase. Despite this being a best practice in software development, there is still a lack of empirical research regarding the usage of ASATs in the wild. In this work, we want to study ASAT warning trends in software via the example of PMD as an ASAT and its usage in open source projects. We analyzed the commit history of 54 projects (with 112,266 commits in total), taking into account 193 PMD rules and 61 PMD releases. We investigate trends of ASAT warnings over up to 17 years for the selected study subjects regarding changes of warning types, short and long term impact of ASAT use, and changes in warning severities. We found that large global changes in ASAT warnings are mostly due to coding style changes regarding braces and naming conventions. We also found that, surprisingly, the influence of the presence of PMD in the build process of the project on warning removal trends for the number of warnings per lines of code is small and not statistically significant. Regardless, if we consider defect density as a proxy for external quality, we see a positive effect if PMD is present in the build configuration of our study subjects.

  • Open Access

    A systematic mapping study of developer social network research

    by Steffen Herbold, Aynur Amirfallah, Fabian Trautsch, Jens Grabowski

    Developer social networks (DSNs) are a tool for the analysis of community structures and collaborations between developers in software projects and software ecosystems. Within this paper, we present the results of a systematic mapping study on the use of DSNs in software engineering research. We identified 255 primary studies on DSNs. We mapped the primary studies to research directions, collected information about the data sources and the size of the studies, and conducted a bibliometric assessment. We found that nearly half of the research investigates the structure of developer communities. Other frequent topics are prediction systems build using DSNs, collaboration behavior between developers, and the roles of developers. Moreover, we determined that many publications use a small sample size regarding the number of projects, which could be problematic for the external validity of the research. Our study uncovered several open issues in the state of the art, e.g., studying inter-company collaborations, using multiple information sources for DSN research, as well as general lack of reporting guidelines or replication studies.