Researchers in Mining (open-source) Software Repositories (MSR) often create datasets that should survive the single paper and support long-term investigation of specific phenomena. Although popular, these studies recurrently deal with similar technical limitations. For instance, public collaborative development platforms, such as GitHub, impose hourly rate limits on their API requests. Furthermore, depending on network and API conditions, queries can fail and disrupt the process. These unexpected events can slow down or even invalidate the mining. Nevertheless, there are ways to minimize the undesirable effects in a reusable way while still complying with such limitations. However, best practices are often (re-)implemented on an ad hoc basis. Whatever works.

Since its inception, UML, the Unified Modeling Language, has been touted as the way to go when it comes to designing and documenting software systems. While being an integral part of many university software engineering programs, UML has found little consideration among developers, especially in open source software. Reasons for this include that UML shares some shortcomings with other forms of documentation (e.g., limited availability, outdatedness, inadequate level of detail). We present a study to investigate the evolution and the current situation regarding the use of UML in open source projects. We mined and analyzed ~ 13k GitHub projects, developing strategies and heuristics to identify UML files through their extensions and contents, for a quantitative analysis of two decades of evolution of the usage of UML. We explored the popularity of UML, derived characteristics of projects leveraging UML, and analyzed the authors, creators and maintainers, of UML artifacts. Our study confirms that UML is indeed still under-utilized. At the same time we found evidence of a resurgence coinciding with the popularity of human-readable text-based formats, defined and used by tools like PlantUML and Mermaid. We discuss how identifying and addressing the new challenges implied by this resurgence could impact the future of UML.

Adopted by companies such as Netflix, Amazon, and Spotify, the microservices architectural style is now well established. Aimed at facilitating software evolution, it is renowned for modularizing a software system into microservices, implemented in various technologies. Regarding databases, practitioners opt for polyglot persistence: Each microservice is responsible for its own database(s). This influences how the architecture is implemented. The decoupling and heterogeneity of microservices and their databases spread data access points throughout the codebase, complicating program comprehension and code-data co-evolution. Developers' feedback reveals their struggles to obtain a holistic view of data access in such architectures. We present Denim, a tool that enables users to identify data access points in microservices and visualize them in an interactive treemap. Using real microservice applications, we illustrate how this tool can be used for software evolution tasks. https://figshare.com/s/6f1d970b87b7ebce939f?file=54914249

Development teams for mobile applications can receive thousands of user reviews daily. At the same time, these developers use different communication channels, such as the GitHub issue tracker. Although GitHub issues are accessible and manageable for developers, their content often differs starkly from what users write in app reviews. Issues may lack steps to reproduce bugs or insights that justify the priority of new feature requests. The sheer volume of user reviews for a popular app, combined with their heterogeneity and varying quality, makes manual integration into issue trackers unfeasible. We present an approach that automatically augments GitHub issues with informative user reviews to bridge the gap between user feedback and developer-managed issues. Using a state-of-the-art large language model (LLM), our approach automatically retrieves user reviews with high semantic textual similarity (STS) to the issue content and suggests reviews that augment developers' understanding of the issue. In this paper, we present large-scale quantitative and qualitative analyses to assess the feasibility of enriching development workflows with user-written information. Using over 37,000 issues and 750,000 reviews from 19 popular Free/Libre/Open Source Software (FLOSS) mobile applications, our approach augments 3,017(8%) issues with 7,287 (1%) potentially informative reviews. In addition to providing insights into user-reported bugs and feature requests, the information from these matches points toward a novel and promising way to leverage user reviews for concerted app evolution.

Over the past decade, microservices have gained significant popularity, impacting how applications are designed and deployed. Maintaining a comprehensive high-level view of microservices applications is essential, especially for software evolution tasks, enabling developers to understand, maintain, and optimize the complex interactions across various services. Developers struggle to obtain such an overview, particularly from a data perspective. Currently, when changes occur, they must identify data access code fragments dependent on the modified parts, or manually search through the entire codebase for potentially impacted ones. This process is time-consuming, error-prone, and cumbersome, especially in large codebases residing in multiple repositories and accessing multiple databases. We present a novel approach to support code and data coevolution comprehension. We mine data access fragments using a custom static analyzer and use interactive treemaps to generate a high-level view of the architecture, which can be explored at various levels of detail allowing, among the others, several and quick what-if analyses to assess the impact of changes (e.g., data concept modification, technology switch). As a case study, we use Overleaf, a popular online LATEX collaborative authoring platform, to evaluate our approach. We compared multiple versions and analyzed the evolution of 1.9 k code fragments associated to more than 350 data concepts across 13 microservices, 855 directories, and 3.5 k files mixing different data access technologies. We complement our analysis with insights and reflections on the promising approach.

The popularity of microservices has grown significantly over the past decade. This architectural style is praised for its ability to ease software evolution, particularly due to the modular, heterogeneous, and dynamic communication nature of microservices. This new way of designing applications has also impacted how databases are integrated. Practitioners generally opt for polyglot persistence, meaning that each microservice manages its own database(s). Decoupling, heterogeneity, and distribution introduce implicit dependencies and multiply data access endpoints. This results in added complexity and challenges in understanding change propagation, which can only be addressed through manual browsing of the codebase, a time-consuming, error-prone, and cumbersome process. A holistic view of such architectures is essential, especially for enabling developers to understand, maintain, and optimize the complex interactions across microservices, particularly from a data perspective.We extend a visualization-based approach to support both a high-level view and fine-grained inspection of microservices. Based on static analysis, we generate an interactive treemap for an entire microservices architecture, providing both an overview and the means for more detailed exploration.We evaluated our approach by assessing the scalability and effectiveness of our visualization. First, we generated interactive treemaps for 10 non-trivial microservices architectures. Then, in a qualitative user study, we asked 6 professional developers to perform specific exploration and understanding tasks (e.g., understanding architectural structure, assessing concept spreading, evaluating technology breakdown, comparing versions, identifying anti-patterns). Our results show that interactive treemaps provide the holistic view needed to aid in evolution tasks.

The lifecycle and development of software systems are strongly dependent on time: A critical dimension that must be considered when analyzing software evolution. Many visualization approaches have been proposed to support developers in analyzing software systems. Yet, most of these focus on static representations, which struggle to convey evolution in time, and leverage only vision. In contrast, hearing—although underutilized—is well suited for processing sequential information, making sound a powerful medium to convey changes chronologically.We present a multimodal approach, implemented in a tool named SonicSight, that combines software sonification and visualization to analyze the development pace of software repositories interactively. A pulse synthesizer modulates its speed based on daily commits, while frequencies represent individual developers and their contribution activity. To support interpretation, the sonification is paired with a real-time interactive visual representation of software-related information. We illustrate such sonified visualization approach through case studies and discuss the underlying time model we employed, crucial for representing both sound and the temporal nature of software evolution.

Classes are the fundamental building blocks of object-oriented software systems, making their comprehension critical for effective software maintenance and evolution. Traditional source code views provide detailed information but often lack intuitive representations that reveal the structural and behavioral roles of a class at a glance. This is even harder for an overview of multiple classes in large and complex codebases. Moreover, identifying patterns and anomalies within classes remains challenging through conventional inspection.We propose Class Contours, a novel visualization metaphor that portrays individual classes as simple 2D architectural structures. Our approach visually encodes key class properties (e.g., lines of code, attributes, accessors) into customizable building features (e.g., windows, door frames, doors), supporting pattern recognition and task-specific visual exploration. With ZION, the tool we developed to exemplify our approach, we investigate how common class types correspond to recurring visual archetypes, allowing developers to swiftly recognize typical roles and structures within software systems.Our initial findings suggest that the simple but effective metaphor can enhance the understanding of class semantics in large codebases and support the identification of design issues and code smells.

Microservices have become a prevalent architectural style over the past decade, emphasizing the modular and dynamic nature of heterogeneous and distributed units that communicate with each other. Moreover, they promote polyglot persistence, meaning that each microservice is responsible for managing its own database(s), often with heterogeneous technologies. One of the downsides is the increase of the number and diversity of data access endpoints and exchanges. Additionally, the decomposition introduces implicit dependencies that affect code and data understanding and co-evolution. Maintaining a comprehensive high-level view of this kind of architecture is challenging, yet essential for software evolution tasks. Previous works have already proposed holistic representations and visualizations of data access in microservices. However, these are mainly based on structural and fixed snapshots, neglecting the dynamic perspective.We present an approach to enhance static visualizations. First, we record data-access-centered execution traces in microservices architectures through a static analysis-based refinement of dynamic instrumentation. Then, we replay scenarios over an existing static treemap, animating the sequence of data accesses and highlighting hotspots in the codebase through time. Our contribution, the animated heat treemap, helps developers to understand how data management operates inside microservices. We validated our approach on Overleaf, a popular online collaborative LATEX authoring platform, with a real-world scenario. We discuss the results obtained and provide insights and reflections.

UML artifacts constitute a key (but often neglected) asset supporting the comprehension of a system. Design documents "bind" developers in implementation phases and close the loop as documentation of the implemented system itself. Nevertheless, the intended system (design), its current version (implementation), and its documentation, naturally tend to drift apart, negatively impacting the usefulness of UML diagrams contained in such artifacts.

Software visualization concerns itself with the visual depiction of software systems to facilitate their comprehension. Any visualization approach, whether 2D or 3D or immersive, comes with a plethora of configuration possibilities (e.g., which types of artifacts to visualize and how, which layouts to use). This reflects the complexity of the domain at hand, where manipulating millions of entities pertaining to dozens of different types of artifacts is common. Most visualization tools encode their customizations in the form of view configurations/specifications (in short viewspecs), which are either created declaratively (using DSLs), or through custom user interfaces. In the case of immersive visualization, approaches using such customization facilities are cumbersome, may generate unnecessary context and paradigm switches, and fail to leverage the full potential of modern VR headsets' controllers. We present an approach to interactively manipulate the view specifications by depicting them as 3D objects in the immersive space, supporting definition and configuration with an automatic reflection-based mapping of the software domain model under exploration. IVAR - NI, the tool we developed, incorporates new immersive interaction paradigms (e.g., slot-based selection) and in-object real-time feedback (e.g., preview of the view specification effects) to enhance the usability of this new generation of VR-native interfaces for software visualization customization. https://youtu.be/HsWGtrINtHc

Modern instant messaging applications (e.g., Gitter, Slack, Discord) provide users with real-time communication means. Developers use them for collaborative development, to ask for code reviews, and to have software-related discussions. In short, a (potential) treasure trove for program comprehension. However, as with any high-throughput "chat application", messages interleave, leading to concurrent conversations. Associating messages to conversations is called conversation disentanglement, a useful and necessary pre-processing step to analyze datasets of instant messages. Although various conversation disentanglement algorithms have been proposed, it is cumbersome to set up proper execution environments and hard to ensure input data format consistency, calling for better practices and tool support.We present CODI, a RESTful API micro-service and web interface for conversation disentanglement. It provides an easy way to disentangle conversation transcripts with pre-trained models or to train new ones on custom datasets, features, and hyper-parameters. CODI achieves state-of-the-art performances on transcripts of IRC, Slack, and Discord conversations. We show how CODI can provide a significant improvement to reusability (and replicability) of research results, while reducing the efforts and potential mistakes due to configuration, setup, and execution.CODI’s source code: https://github.com/USIREVEAL/CODI

There has been some recent clamor about the developer layoff and turnover policies enacted by high-profile corporate executives. Precisely defining the contributions in software development has always been a thorny issue, as it is difficult to establish a developer’s “performance” without recurring to guesswork, due to how software development works and how Git persists history. Taking inspiration from a seemingly informal notion, the pony factor, we present an approach to identify the key developers in a software project. We present an analysis of 1,011 GitHub repositories, providing fact-based reflections on development contributions.

New communication platforms have emerged to support developers in finding and creating the knowledge they need for program comprehension, maintenance, and evolution. Instant messaging applications are supplanting developer mailing lists in collaborative development toolchains. These applications provide a new medium, supporting faster and richer communication (e.g., embedded previews, images, files, videos). Research so far focused on extracting information from these platforms, but there is a lack of tools to visually and interactively explore them.We present DiscOrDance, a tool for the interactive visual exploration of the complete message history of a Discord server. We show how three categories of views elicit insights on aspects of the structure, members, and software related content of a Discord server. We demonstrate use cases of DiscOrDance to support software maintenance and evolution activities on an active software developer community, the Pharo Discord server.Demo video: https://youtu.be/eYCLGWwM9HYTool homepage: https://DiscOrDance.si.usi.ch

Modern communication platforms used in software development host daily conversations among developers and users about a wide range of topics pertaining to software systems, such as language features, APIs, code artifacts like classes and methods, design patterns, usage examples, code reviews, bug reporting and fixing. Discord servers are one of these virtual community hubs that have seen a steep rise in popularity, as coordination and aggregation means for communities of developers. Although Discord supports filter-based search functionalities, the sheer volume, velocity, and small granularity of single messages make it hard to find useful results, let alone complete discussions revolving around particular themes. One reason is that the concept of a discussion, which we call a conversation, does not exist as an explicit concept. We argue that extracting and analyzing such conversations can be used fruitfully to aid program comprehension.

The last decade has seen the rise of global software community platforms, such as Slack, Gitter, and Discord. They allow developers to discuss implementation issues, report bugs, and, in general, interact with one another. Such real-time communication platforms are thus slowly complementing, if not replacing, more traditional communication channels, such as development mailing lists. Apart from simple text messaging and conference calls, they allow the sharing of any type of content, such as videos, images, and source code. This is turning such platforms into precious information sources when it comes to searching for documentation and understanding design and implementation choices. However, the velocity and volatility of the contents shared and discussed on such platforms, combined with their often informal structure, makes it difficult to grasp and differentiate the relevant pieces of information.We present a visual analytics approach, supported by a tool named DiscOrDance, which provides numerous custom views to support the understanding of Discord servers in terms of their structure, contents, and community. We illustrate DiscOrDance, using as running example the public Pharo development community Discord Server, which counts to date ∼180k messages shared among ∼2,900 developers, spanning 5 years of history. Based on our analyses, we distill and discuss interesting insights and lessons learned.