In recent years, the research community, but also the general public, has raised serious questions about the reproducibility and replicability of scientific work. Since many studies include some kind of computational work, these issues are also a technological challenge, not only in computer science, but also in most research domains. Computational replicability and reproducibility are not easy to achieve due to the variety of computational environments that can be used. Indeed, it is challenging to recreate the same environment via the same frameworks, code, programming languages, dependencies, and so on. We propose a framework, known as SciRep, that supports the configuration, execution, and packaging of computational experiments by defining their code, data, programming languages, dependencies, databases, and commands to be executed. After the initial configuration , the experiments can be executed any number of times, always producing exactly the same results. Our approach allows the creation of a reproducibility package for experiments from multiple scientific fields, from medicine to computer science, which can be re-executed on any computer. The produced package acts as a capsule, holding absolutely everything necessary to re-execute the experiment. To evaluate our framework, we compare it with three state-of-the-art tools and use it to reproduce 18 experiments extracted from published scientific articles. With our approach, we were able to execute 16 (89%) of those experiments, while the others reached only 61%, thus showing that our approach is effective. Moreover, all the experiments that were executed produced the results presented in the original publication. Thus, SciRep was able to reproduce 100% of the experiments it could run.

Model-Driven Engineering (MDE) offers significant benefits but faces usability challenges, particularly in developing intuitive modeling interfaces. Most existing tools rely on textual or tree-based editors, which are often difficult for non-technical users to navigate. Creating custom graphical editors based on existing metamodels, a common way to describe modeling environments and languages, typically requires substantial manual effort and specialized knowledge of complex frameworks such as Sirius. These hurdles limit the broader adoption of MDE among developers and domain experts. Consequently, there is an increasing demand for automated, flexible, and user-friendly approaches to generating interfaces that can make MDE more accessible and practical across various domains. In this work, we present a method for automatically generating a visual modeling environment from existing metamodels. Based on this method, we devised Model2Block , a command-line application that automatically generates block-based visual languages from metamodels defined using the Ecore language. The tool analyzes an input metamodel and produces a corresponding set of blocks, which are then integrated into a web-based environment. This enables users to visually build models using blocks that represent valid model elements. We present an applicability study demonstrating that our method and tool were successfully applied to a publicly available dataset containing more than 50 metamodels. Moreover, we present a case study of a concrete modeling environment we generated from a metamodel, achieving, in this particular case, higher usability and lower workload than an existing tool.

In the realm of industrial software development, DevOps has emerged as the preferred approach for handling the highly iterative software production process. DevOps refers to the tight integration of development and operations activities, with Continuous Integration, Continuous Delivery, and Continuous Deployment (CI/CD) being pivotal methodologies for ensuring the iterative delivery of high-quality software. To achieve CI/CD, pipelines of activities are deployed using commercial tools. Due to the dynamic nature of these tools, CI/CD pipelines are often migrated to new versions or even new tools. Since this is mostly a manual process, it is a cumbersome and error-prone activity. To assist software engineers during this process, we propose a novel approach that leverages model-driven engineering (MDE) to support the migration of CI/CD pipelines. Our approach is inspired by the traditional reengineering horseshoe model, which abstracts existing pipeline artifacts into a comprehensive model as an intermediate representation. From these models, we can then generate semantic-equivalent pipelines for any novel CI/CD tool. Thus, our main contribution comprises a metamodel designed to represent the structure of existing CI/CD pipelines and build the foundation for MDE-based migration of CI/CD pipelines. We validated our metamodel by successfully modeling 400 existing pipelines. This evaluation demonstrated a 100% applicability rate when applied to configuration files from technologies that collectively account for over 92% of CI/CD scripts in use. Furthermore, we conducted a detailed case study demonstrating the practical applicability of our approach in real-world migration scenarios. Finally, we demonstrate that our metamodel promotes equivalence between an original pipeline and a new one generated from it in a different technology by showing through test cases that the execution traces of both pipelines are identical.

Computational reproducibility-the ability to reexecute a scientific experiment using the same code, data, and configuration-should be straightforward. However, researchers often struggle with inconsistencies in documentation, missing dependencies, and environment setup, which undermines the credibility of scientific results. To address this, we propose a conversational, text-based tool that aids researchers in reproducing and packaging computational experiments into a single file. This file can be re-executed with a double-click on any machine, requiring only a single tool. SciConv is designed to support two key scenarios: (i) enabling researchers to prepare their own experiments in a reproducible, shareable format, and (ii) helping other researchers reproduce existing experiments from shared code repositories. In both cases, the tool reduces technical overhead and simplifies environment configuration through conversational interaction. We evaluated the tool through two studies. In the first, we reproduced 15 of 18 published experiments, with most requiring little or no user interaction. In the second, we conducted a user study comparing our tool with a professional platform, using the System Usability Scale (SUS) and NASA Task Load Index (TLX). The results show a statistically significant advantage for our tool in both usability and workload, demonstrating its effectiveness in supporting reproducibility.

Computational reproducibility remains a critical yet unresolved issue across scientific disciplines, often hindered by complex configuration requirements and technical barriers. We present SciConv, a novel conversational tool designed to assist researchers in creating and executing reproducible computational experiments using natural language. By leveraging large language models (llMs), SciConv automates the detection of dependencies and programming languages, and packages experiments into portable artifacts with minimal manual input. Unlike traditional platforms based on graphical user interfaces (e.g., web-based), SciConv features a chat-based interface that guides researchers interactively through the reproducibility workflow. This paper introduces the architecture, design principles, and interaction model of SciConv, and discusses its potential to lower the technical barriers to reproducibility.

Continuous Integration and Deployment (CI/CD) pipelines are essential for modern software delivery, yet configuring them remains a challenge due to the complexity of textbased formats like YAML. These configurations are error-prone and require substantial expertise, posing a barrier especially to novices. In this paper, we introduce PipeBlocks, a block-based CI/CD tool featuring a graphical interface for visually constructing pipelines through modular, drag-and-drop blocks. PipeBlocks seamlessly integrates with GitHub Actions, allowing users to design, validate, and execute pipelines entirely within the tool while maintaining full compatibility with existing YAML workflows. A key innovation is the ability to trigger and monitor pipeline runs directly in PipeBlocks, eliminating context-switching.

Continuous Integration and Deployment (CI/CD) pipelines are essential for modern software delivery, yet configuring them remains a challenge due to the complexity of text-based formats like YAML. These configurations are error-prone and require substantial expertise, posing a barrier to novices. In this paper, we introduce PipeBlocks, a block-based CI/CD tool featuring a graphical interface for visually constructing pipelines through modular, drag-and-drop blocks. PipeBlocks seamlessly integrates with GitHub Actions, allowing users to design, validate, and execute pipelines entirely within the tool while maintaining full compatibility with existing YAML workflows. A key innovation is the ability to trigger and monitor pipeline runs directly in PipeBlocks, eliminating context-switching. We evaluated PipeBlocks through a controlled study with 10 participants configuring identical pipelines (build, test, deploy) using both PipeBlocks and YAML editing in GitHub Actions. Using the System Usability Scale (SUS) and NASA-TLX benchmarks, we found that PipeBlocks achieved a statistically significantly higher usability score and a lower cognitive load. The results suggest that block-based approaches can effectively lower CI/CD’s learning curve while maintaining functional completeness, making them particularly valuable for academic settings and early-career developers building CI/CD competencies.

User studies are paramount for advancing science. In particular, the empirical evaluation of programmer-oriented tools is important to validate research ideas and prototypes, as well as production-ready tools. Previous research has collected several tools used by the software engineering and behavioral science communities to design and run studies. In this work, we study tools used in software engineering studies and identify their features. Furthermore, we analyze three behavioral science experiment tools to identify design ideas that might be adapted to programmer user studies. With this work, we present the set of features currently offered by software engineering tools to support researchers in the design and execution of programmer user studies. We also present the characteristics of some tools used in behavioral science experiments to identify design ideas that can be adapted to programmer user studies.

In recent years, the research community has raised serious questions about the replicability and reproducibility of scientific work. In particular, since many studies include some kind of computing work, these are also technological challenges, not only in computer science but in most research domains. Replicability and reproducibility are not easy to achieve, not only because researchers have diverse proficiency in computing technologies, but also because of the variety of computational environments that can be used. Indeed, it is challenging to recreate the same environment using the same frameworks, code, programming languages, dependencies, and so on. In this work, we propose a vision for an Integrated Development Environment allowing the creation, configuration, execution, packaging, and sharing of scientific computational experiments. Such a framework should allow researchers to easily set the code and data used and define the programming languages, code, dependencies, databases, or commands to execute to achieve consistent results for each experiment. With this work, we intend to aid researchers by integrating into the same platform all the stages of the design, execution, and analysis of a computational experiment.

Continuous Integration and Continuous Deployment (CI/CD) pipelines play a vital role in the DevOps process, enabling developers to automate and enhance software delivery. However, the existence of multiple technologies, such as GitHub Actions, GitLab CI/CD, or Jenkins, poses challenges due to their lack of interoperability and the use of different programming languages for pipeline construction. To address these challenges and improve the CI/CD process, our objective is to develop a block-based language specifically designed for representing CI/CD pipelines. With our language, we intend to empower users to more easily create correct pipelines. Through an interactive and user-friendly process, our approach guides users in constructing pipelines, ensuring accuracy and reducing errors. Additionally, our language will facilitate seamless transitions between different pipeline technologies, providing users with flexibility and ease of adoption.

The architectural style of microservices has received much attention from both business and academia and converting a monolithic application into a microservice-based one has become a regular practice. However, companies struggle with migrating their existing monolithic applications to microservices and software engineers frequently face challenges due to a lack of awareness of alternative migration methodologies, making the migration process even harder. In this paper, we present a framework to help software engineers during the migration process by addressing gaps in understanding various migration tools and approaches, allowing for easy comparison between multiple options. Our tool combines multiple existing approaches into one platform, allowing a comprehensive visualization of migration proposals and comparing different options offered by already existing approaches.

Data collection is pervasively bound to our digital lifestyle. A recent study reports that the growth of the data created and replicated in 2020 was even higher than in the previous years to an astonishing global amount of 64.2 zettabytes of data. There are numerous companies whose services/products rely heavily on data analysis, and mining the produced data has already revealed great value for businesses in different sectors. In order to be able to support the professionals that do this job, typically known as data scientists, we first need to characterize them. To contribute towards this characterization, we conducted a public survey and in this work we present the results about a particular aspects of their life: the tools they use and need.

Linear programming is a mathematical optimization technique used in numerous fields including mathematics, economics, and computer science, with numerous industrial contexts, including solving optimization problems such as planning routes, allocating resources, and creating schedules. As a result of its wide breadth of applications, a considerable amount of its user base is lacking in terms of programming knowledge and experience and thus often resorts to using graphical software such as Microsoft Excel. However, despite its popularity amongst less technical users, the methodologies used by these tools are often ad-hoc and prone to errors. To counteract this problem we propose creating a block-based language that allows users to create linear programming models using data contained inside spreadsheets. This language will guide the users to write syntactically and semantically correct programs and thus aid them in a way that current languages do not.

Data is everywhere and in everything we do. Most of the time, usable information is hidden in raw data and because of that, there is an increasing demand for people capable of working creatively with it. To fully understand how we can assist data science workers to become more productive in their jobs, we first need to understand who they are, how they work, what are the skills they hold and lack, and which tools they need. In this paper, we present the results of the analysis of several interviews conducted with data scientists. Our research allowed us to conclude that the heterogeneity between these professionals is still understudied, which makes the development of methodologies and tools more challenging and error prone. The results of this research are particularly useful for both the scientific community and industry to propose adequate solutions for these professionals.

Based on the concept of explanation sheets, we present an approach to make spreadsheets easier to understand and thus easier to use and maintain. We identify the notion of explanation soundness and show that explanation sheets which conform to simple rules of formula coverage provide sound explanations. We also present a practical evaluation of explanation sheets based on samples drawn from widely used spreadsheet corpora and based on a small user study.

Software developers are more and more eager to understand their code’s energy performance. However, even with such knowledge it is di cult to know how to improve the code. Indeed, little tool support exists to understand the energy consumption pro le of a software system and to eventually (automatically) improve its code.

This paper presents a study of the runtime, memory usage and energy consumption of twenty seven well-known software languages. We monitor the performance of such languages using ten different programming problems, expressed in each of the languages. Our results show interesting findings, such as, slower/faster languages consuming less/more energy, and how memory usage influences energy consumption. Finally, we show how to use our results to provide software engineers support to decide which language to use when energy efficiency is a concern.

Spreadsheets are used in professional business contexts to make decisions based on collected data. Usually, these spreadsheets are developed by end users in an ad-hoc way. Thus, the business logic of a concrete spreadsheet is not explicit to end users, making its correctness hard to assess and users have to trust. We present an approach where structure and computational behavior of a spreadsheet are specified by a model with a process-like notation based on pre-defined functional spreadsheet services with typed interfaces. This enables a consistent construction process of a spreadsheet that comprises defining its structure and computational behavior as well as filling it with data and executing the defined computational behavior. Thus, concrete spreadsheets are equipped with a specification of their construction process. This supports their understanding and correct usage, even in case of legacy spreadsheets. The approach has been developed in cooperation with an industrial partner.

This paper proposes and validates a model-driven software engineering technique for spreadsheets. The technique that we envision builds on the embedding of spreadsheet models under a widely used spreadsheet system. This means that we enable the creation and evolution of spreadsheet models under a spreadsheet system. More precisely, we embed ClassSheets, a visual language with a syntax similar to the one offered by common spreadsheets, that was created with the aim of specifying spreadsheets. Our embedding allows models and their conforming instances to be developed under the same environment. In practice, this convenient environment enhances evolution steps at the model level while the corresponding instance is automatically co-evolved. Finally, we have designed and conducted an empirical study with human users in order to assess our technique in production environments. The results of this study are promising and suggest that productivity gains are realizable under our model-driven spreadsheet development setting.

Despite being staggeringly error prone, spreadsheets are a highly flexible programming environment that is widely used in industry. In fact, spreadsheets are widely adopted for decision making, and decisions taken upon wrong (spreadsheet-based) assumptions may have serious economical impacts on businesses, among other consequences. This paper proposes a technique to automatically pinpoint potential faults in spreadsheets. It combines a catalog of spreadsheet smells that provide a first indication of a potential fault, with a generic spectrum-based fault localization strategy in order to improve (in terms of accuracy and false positive rate) on these initial results. Our technique has been implemented in a tool which helps users detecting faults. To validate the proposed technique, we consider a well-known and well-documented catalog of faulty spreadsheets. Our experiments yield two main results: we were able to distinguish between smells that can point to faulty cells from smells and those that are not capable of doing so, and we provide a technique capable of detecting a significant number of errors: two thirds of the cells labeled as faulty are in fact (documented) errors.

This paper presents a tool, dubbed Faulty Sheet Detective, for aiding in spreadsheet fault localization, which combines the detection of bad smells with a generic spectrum-based fault localization algorithm.

Spreadsheets are widely used not only to define mathematical expressions, but also to store large and complex data. To query such data is usually a difficult task to perform, usually for end user. In this work we embed the textual query language in the model-driven spreadsheet environment as a spreadsheet itself. The result is an expressive and powerful query environment that has knowledge of the business logic defined by the spreadsheet data (the spreadsheet model) to guide end users constructing correct queries.

This paper presents ES-SQL, an embedded tool for visually constructing queries over spreadsheets. This tool provides an expressive query environment which has knowledge on the business logic of spreadsheets, and by this knowledge it assists the user in defining the intended queries.

This paper presents a tool, named QuerySheet, to query spreadsheets. We defined a language to write the queries, which resembles SQL, the language to query databases. This allows to write queries which are more related to the spreadsheet content than with current approaches.

Spreadsheets are being used with many different purposes that range from toy applications to complete information systems. In any of these cases, they are often used as data repositories that can grow significantly. As the amount of data grows, it also becomes more difficult to extract concrete information out of them. This paper focuses on the problem of spreadsheet querying. In particular, we propose an expressive and composable technique where intuitive queries can be defined. Our approach builds on a model-driven spreadsheet development environment, and queries are expressed referencing entities in the model of a spreadsheet instead of in its actual data. Finally, the system that we have implemented relies on Google's query function for spreadsheets.

In this paper, we present MDSheet, a framework for the embedding, evolution and inference of spreadsheet models. This framework offers a model-driven software development mechanism for spreadsheet users.

In this extended abstract we present a bidirectional model-driven framework to develop spreadsheets. By being model driven, our approach allows to evolve a spreadsheet model and automatically have the data co-evolved. The bidirectional component achieves precisely the inverse, that is, to evolve the data and automatically obtain a new model to which the data conforms.

This tool demo paper presents SmellSheet Detective: a tool for automatically detecting bad smells in spreadsheets. We have defined a catalog of bad smells in spreadsheet data which was fully implemented in a reusable library for the manipulation of spreadsheets. This library is the building block of the SmellSheet Detective tool, that has been used to detect smells in large, real-world spreadsheets within the EUSES corpus, in order to validate and evolve our bad smells catalog.

In this paper we explore the use of models in the context of spreadsheet engineering. We review a successful spreadsheet modeling language, whose semantics we further extend. With this extension we bring spreadsheet models closer to the business models of spreadsheets themselves. An addon for a widely used spreadsheet system, providing bidirectional model-driven spreadsheet development, was also improved to include the proposed model extension.

This paper describes the embedding of ClassSheet models in spreadsheet systems. ClassSheet models are well-known and describe the business logic of spreadsheet data. We embed this domain specific model representation on the (general purpose) spreadsheet system. By defining such an embedding, we provide end users a model-driven engineering spreadsheet developing environment. End users can interact with both the model and the spreadsheet data in the same environment. Moreover, we use advanced techniques to evolve spreadsheets and models and to have them synchronized. In this paper we present our work on extending a widely used spreadsheet system with such a model-driven spreadsheet engineering environment.

Many errors in spreadsheet formulas can be avoided if spreadsheets are built automatically from higher-level models that can encode and enforce consistency constraints. However, designing such models is time consuming and requires expertise beyond the knowledge to work with spreadsheets. Legacy spreadsheets pose a particular challenge to the approach of controlling spreadsheet evolution through higher-level models, because the need for a model might be overshadowed by two problems: (A) The benefit of creating a spreadsheet is lacking since the legacy spreadsheet already exists, and (B) existing data must be transferred into the new model-generated spreadsheet. To address these problems and to support the model-driven spreadsheet engineering approach, we have developed a tool that can automatically infer ClassSheet models from spreadsheets. To this end, we have adapted a method to infer entity/relationship models from relational database to the spreadsheets/ClassSheets realm. We have implemented our techniques in the HaExcel framework and integrated it with the ViTSL/Gencel spreadsheet generator, which allows the automatic generation of refactored spreadsheets from the inferred ClassSheet model. The resulting spreadsheet guides further changes and provably safeguards the spreadsheet against a large class of formula errors. The developed tool is a significant contribution to spreadsheet (reverse) engineering, because it fills an important gap and allows a promising design method (ClassSheets) to be applied to a huge collection of legacy spreadsheets with minimal effort.

This paper presents techniques and tools to transform spreadsheets into relational databases and back. A set of data refinement rules is introduced to map a tabular datatype into a relational database schema. Having expressed the transformation of the two data models as data refinements, we obtain for free the functions that migrate the data. We use well-known relational database techniques to optimize and query the data. Because data refinements define bi-directional transformations we can map such database back to an optimized spreadsheet. We have implemented the data refinement rules and we constructed Haskell-based tools to manipulate, optimize and refactor Excel-like spreadsheets.

Spreadsheets can be viewed as a highly flexible end-users programming environment which enjoys wide-spread adoption. But spreadsheets lack many of the structured programming concepts of regular programming paradigms. In particular, the lack of data structures in spreadsheets may lead spreadsheet users to cause redundancy, loss, or corruption of data during edit actions. In this paper, we demonstrate how implicit structural properties of spreadsheet data can be exploited to offer edit assistance to spreadsheet users. Our approach is based on the discovery of functional dependencies among data items which allow automatic reconstruction of a relational database schema. From this schema, new formulas and visual objects are embedded into the spreadsheet to offer features for auto-completion, guarded deletion, and controlled insertion. Schema discovery and spreadsheet enhancement are carried out automatically in the background and do not disturb normal user experience.