Enhanced Programming Error Messages are one type of feedback that may be useful during the learning process of novice programmers. One way to improve such messages is by using the context given by an auto-grader from students' errors when solving programming exercises in those environments. We investigate how Large Language Models (LLM) may be used to provide additional feedback beyond simple compiler or interpreter error messages by garnering input from a programming exercise description, the student's code to solve that exercise, and the error generated by a Python interpreter and generating an LLM prompt from that given information. In an experiment, we asked instructors to evaluate the prompt text generated by an LLM from a variety of exercises and the students' errors. Our results show a high rate of adequate feedback by means of explanations and code examples to fix the errors without providing a full code solution. However, some cons have also been noticed, such as vague explanations, hallucinations, and dissociation from explanations and examples. The results suggest that LLM feedback is a promising approach to provide feedback to novice programmers by means of enhanced programming error messages.

Computational Thinking (CT) is a prominent concept that is part of several computing curricula. However, there is a lack of valid and reliable assessment instruments aimed at assessing the acquisition of Concepts, Practices, and Perspectives of CT. This work aims to develop an assessment instrument for the acquisition of CT to the target audience of primary school graduates, and to carry out its theoretical evaluation using semantic analysis and content analysis. The proposed assessment considers the dimensions of Concepts, Practices and Perspectives of CT. Based on a previously designed operational definition of CT validated by an expert panel, we developed a test bank of questions with 117 items in total, of which 63 items were from the Concepts dimension, 45 items were from the Practices dimension and nine scenarios were from the Perspectives dimension. The items' theoretical analysis was performed in sequence. The semantic analysis sought to verify the items' intelligibility. Content analysis sought to verify whether the developed items refer to the latent trait that was intended to be measured. After the theoretical evaluation, the final instrument has 55 items, being 35 from Concepts, 13 from Practices and seven scenarios from Perspectives. The items that make up the instrument are intelligible to the target audience. Furthermore, according to the expert panel, each item refers to only one of the latent traits among the categories of Concepts, Practices and Perspectives.

Context: Interaction design has been consolidated as a practice with potential to support interactive systems projects. Most interaction design solutions (methods, techniques, and tools) have been created to be used in environments with co-located participants. However, the number of software projects that are developed in environments with geographically distributed stakeholders has increased. Despite some research efforts, little is known about how the scientific literature has addressed interaction design in distributed software development (DSD). Objective: To provide an overview of studies that have been conducted on interaction design in DSD. Method: A systematic mapping study was conducted to identify, synthesise and analyse papers related to interaction design in DSD, and 32 papers were included and classified in relation to the research type and research topic. Results: Through the analysis of the included papers, this paper provides an overview of existing interaction design studies in the context of DSD. This paper presents an analysis of the main characteristics of interaction design in DSD, such as the level of dispersion of stakeholders, the solutions adopted (approaches, methods, techniques, tools), the involvement of end users, and the performance of designers and HCI specialists. We have identified gaps and a taxonomy of six research topics. The findings of this study also allowed us to propose an agenda for future research on distributed interaction design. Conclusion: This paper contributes to the body of knowledge of interaction design at the frontier of research between HCI and DSD by (i) providing an overview of research efforts on interaction design in DSD, (ii) presenting an overview of how interaction design has been conducted in DSD projects, and (iii) identifying research gaps and discuss future research directions emerged from the study.

This research to practice full paper investigates software engineering students' perceptions of their contact with open source projects as a real-world experience. Working with open source projects (OSPs) has been shown as an interesting option in software engineering courses to bringing students closer to more realistic environments. However, when instructors use this approach, it is not clear whether students perceive the OSP as a real industrial software project, or whether they perceive the tasks they perform over OSPs as typical or close to industrial software project activities. The goal of this work was to identify students' perceptions of their interaction with an open source project as a real world experience. To do so, we performed three mixed-methods case studies with three different undergraduate classes. Each class had a different focus: i) software maintenance and evolution, ii) software testing, and iii) reverse engineering of software requirements. Results show that students perceived features that make OSPs close to industrial projects, realized that their OSP tasks are close to the ones in industrial projects, and also faced difficulties typical of working with real world software. Moreover, students forged a view of the skills needed for their future professional success. We conclude that students realized that performing tasks in OSPs was a real world experience they took part, contributing to their background both for the competencies they acquired and the difficulties they had to overcome.

Software Product Line (SPL) engineering is a paradigm for the development of a family of products based on the systematic reuse of artifacts. Although its increasing adoption, organizations often start with a single system and use ad-hoc techniques such as clone-and-own to create new systems by performing small changes and adaptations to meet customers' needs. However, as the number of clones raises over time, it becomes a hard task to maintain and support all the systems. This scenario happened in the Apo-Games projects and adopting SPL Engineering can address these issues. Product Line Architecture (PLA) is one of the key assets to allow the success of SPL development. In this paper, we apply our approach to recover the PLA of the Apo-Games projects by using the source code of a set of Android and Java clones. We provide a set of information to support the development of the Apo-Games SPL. We identified that the Android and Java projects have similar PLAs.

Context: It is common practice in academia to have students work with “toy” projects in software engineering courses. One way to make such courses more realistic and reduce the gap between academic courses and industry needs is getting students involved in Open Source Projects with faculty supervision. Objective: This study aims to summarize existing information on how open source projects have been used to facilitate students' learning of software engineering. Method: A systematic mapping study was undertaken by identifying, filtering and classifying primary studies using a predefined strategy. Results: 53 papers were selected and classified. The main results were: a) most studies focus on comprehensive software engineering courses, although some papers deal with specific areas; b) the most prevalent approach was the traditional project method; c) surveys are the main learning assessment instrument, especially for student self-assessment; d) conferences are the typical publication venue; and e) more than half of the studies were published in the last five years. Conclusions: The resulting map gives an overview of the existing initiatives in this context and shows gaps where further research can be pursued.

Cohesion has been avidly recognized as a key property of software modularity. Ideally, a software module is considered to be cohesive if it represents an abstraction of a single concern of the software. Modules with several concerns may be harder to understand because developers must mentally separate the source code related to each concern. Also, modules implementing several concerns are more likely to undergo changes as much as distinct development tasks may target its different concerns. The most well-known cohesion metrics are defined in terms of the syntactical structure of a module, and as a consequence fail to capture the amount of concerns realized by the module. In this context, we investigated the potential of a new metric, called Lack of Concern-based Cohesion. This metric explicitly counts the number of concerns realized by each module. We compared this metric with other five structural cohesion metrics by applying them over six open source software systems. We studied how those metrics are associated with module changes by mining over 16,000 repository revisions. Our results pointed out that the concern-based metric captured a cohesion dimension that is not reflected by structural metrics, and, as a consequence, adds to the association of cohesion and change-proneness.

Data from bug repositories have been used to enable inquiries about software product and process quality. Unfortunately, such repositories often contain inaccurate, inconsistent, or missing data, which can originate misleading results. In this paper, we investigate how well data from bug repositories support the discovery of details about the software verification process in two open source projects, Eclipse and NetBeans. We have been able do identify quality assurance teams in NetBeans and to detect a well-defined verification phase in Eclipse. A major challenge, however, was to identify the verification techniques used in the projects. Moreover, we found cases in which a large batch of bug fixes is simultaneously reported to be verified, although no software verification was actually done. Such mass verifications, if not acknowledged, threatens analyses that rely on information about software verification reported on bug repositories. Therefore, we recommend that the exploratory analyses presented in this paper precede inferences based on reported verifications.

Architectural aspects are expected to modularize widely-scoped concerns that naturally crosscut the boundaries of system components at the software architecture level. However, there is no empirical knowledge about the positive and negative influences of aspectual decompositions on architecture stability. This paper analyzes the influence exerted by the aspect-oriented composition mechanisms in the stability of crosscutting concerns in an evolving multi-agent software architecture. Our investigation encompassed a comparative analysis of aspectual and non-aspectual decompositions based on different architectural styles. In particular, we assessed various facets of components' and compositions' stability through such alternative designs of the same multi-agent system using conventional quantitative indicators. The evaluation focused upon a number of architecturally-relevant changes that are typically performed through real-life maintenance tasks.