Source code can contain a large amount of data to be interpreted by the human reader. This can be a daunting task since the cognitive ability of an individual may not be as efficient as computers. Visual analytics (VA) can be applied in software maintenance to facilitate code comprehension and other maintenance tasks. In this research, we propose a prototype tool called VA4SM, for visualizing important source code information such as static dependencies, structure and code metrics. We discuss the key features of VA4SM and improvements for future work.

Blockchain-oriented software (BOS) is emerging rapidly, however, tailored software engineering techniques to assist software testing is one of the important and necessary phases of software development that plays a vital role in software quality assurance. Blockchain-oriented software testing (BOST) is another area that is still emerging. This paper conducts a preliminary literature review to assess the type of research published, where this research can be found, and the main themes of existing research in BOST. This study also introduces a framework for conducting an empirical study on BOS available on GitHub and proposes future work to expand the knowledge in this domain.

Traceability link recovery (TLR) is an effective tool for software engineers to better understand the connection between the high-level and low-level artifacts found in most projects. Most research papers published in the area leverage information retrieval techniques and formulate the TLR activity as a retrieval problem as it provides the user with a collection of possible links that they can go through and validate related documents. However, it still requires significant amount of human involvment which can slow down the tracing process. In this research, we address this problem by transforming it into a simple binary classification problem. The paper presents what features help benefit the overall process of classifying the possible links as well as the classification algorithms used. The results show that Random Forest outperforms the other four classification techniques.

Requirements engineering (RE) is a critical set of activities in the software development life cycle (SDLC). Without effective requirements elicitation, organization, communication, and understanding software engineers cannot build quality soft-ware. Thus, it is necessary for software stakeholders to facilitate the SDLC by following best practices and utilizing software tools as needed to ensure requirements are well understood. One area where RE still faces issues, despite stakeholders' best efforts, is the communication of requirements amongst the various stakeholders. Software stakeholders consist of the customers, developers, managers, end users, and others with a vested interest in the software, and they typically all have different skillsets, backgrounds, vernaculars, and understanding of the requirements. These differences naturally lead to miscommunications which can lead to redundant, missing, or conflicting requirements, especially when customer and end user domains include complex vocabularies developers may not be accustomed to, and vice versa, e.g., biology, physics, and medicine. One approach in recent works to address this challenge has been to bridge the communication gap between stakeholders by constructing domain-specific ontologies using natural language processing (NLP) and Wikipedia [1]. With these ontologies, stakeholders have a convenient tool they can use to translate and understand specific requirements in the terminologies they're accustomed to. These techniques have shown promising potential, however there are computational challenges associated with efficiently handling a large dataset like Wikipedia. In particular, parsing internal links from Wikipedia article metadata can be a bottleneck in such ontology-construction systems. In this work we address this issue by implementing a program for memory-efficient parallel internal link extraction from Wikipedia articles. This builds on the work of Rodriguez et al. [2] by optimizing additional phases in the knowledge acquisition process.

Requirements engineering (RE) is a crucial component in successful software development process. The idea of embedding the non-functional requirements (NFRs) such as performance, maintainability, modifiability, and others into a new software system is often implemented by software engineers. However, security as a crucial NFR is often ignored in the software development process. In this paper we address the importance of security as a NFR in the software development process. To that end, we propose a lightweight novel agile framework to analyze security requirements. We evaluate the proposed framework with a qualitative analysis and determine how it is useful to requirement analysts.

Requirements elicitation and analysis is an im-portant activity in the requirements engineering (RE) process. In this activity, requirements engineers work with clients and end-users to find more about the application domain, what functionalities the system should provide, constraints, and the required performance and efficiency of the system. Requirements Negotiation (RN) is an important process activity in the elicitation and analysis process. RN is concerned with finding and resolving requirements conflicts through negotiation. In this paper, we describe ReNego, a requirements negotiation tool based on voting of social choice (SC) theory. We discuss the key features and functionalities of the tool and its potential improvements for future work.

Finding similar requirements from a requirements dataset is an important problem in requirements engineering (RE). Automatic processing and representation of requirements documents has become a necessity for requirements engineers (REs) due to the inability of one person (or a even small group of people) to completely oversee the requirements of a system manually because of the system's scale. This paper outlines a novel framework which can help REs to realize document similarity using word embeddings. This framework takes a collection of documents as input and produces a list of similarity ratings for each document. The similarity ratings provide REs an intuition of what could be related or how the requirements search space can be reduced for further RE activities. The framework uses TF-IDF to produce a list of important terms for each document, filters out totally unique terms, then uses spaCy's deep learning word vectorization to calculate similarity between requirements documents.

In this work, we consider distance-based clustering of partial lexicographic preference trees (PLP-trees), intuitive and compact graphical representations of user preferences over multi-valued attributes. To compute distances between PLP-trees, we propose a polynomial time algorithm that computes Kendall's Tau distance directly from the trees and show its efficacy compared to the brute-force algorithm. To this end, we implement several clustering methods (i.e., spectral clustering, affinity propagation, and agglomerative nesting) augmented by our distance algorithm, experiment with clustering of up to 10,000 PLP-trees, and show the effectiveness of the clustering methods and visualizations of their results.

Identifying and minimizing the number of bugs before release is a high priority of any team working on software development. This can be achieved by Machine Learning (ML) models. By using particular aspects of the code, ML Models can predict the number of bugs that are possible post launch. We use a public dataset consisting of 15 Java projects from GitHub as our training and test dataset. We use five ML models for our investigation: Multilayer Perceptron, K-Nearest Neighbors, Linear Regression, Logistic Regression, and Decision Trees. We conduct a preliminary investigation to evaluate how these ML models perform in predicting bugs. The results show that Linear Regression outperforms the other four ML models in finding the number of bugs post release.

A large body of research is available on software clustering, code navigation, and many tools have been developed to comprehend large software systems. However, little attention has been paid to the area of visual clustering. In this paper, we leverage static dependencies and visual clustering to identity landmarks which are important legibility features that developers use as reference points during code navigation. This paper describes VisLan, a tool for visualizing landmark files in source code. We discuss the key features of VisLan and improvements for future work.

Finding similar requirements from a requirements dataset is an important problem in requirements engineering (RE). It provides requirements engineers an intuition of what could be related or how the requirements search space can be reduced for further RE activities. In this paper, we describe T-ReQs, a requirements similarity tracking tool based on cosine similarity. We discuss the key features and functionalities of the tool and its potential improvements for future work.

With the emergence of sophisticated head-mounted displays (HMDs), virtual reality (VR) is gaining much interest in the field of medical science and diagnosis. There exist many software tools that support MRI imaging in 3D, however, limited attention has been paid to the VR domain. In this paper, we present a VR tool called VRvisu++which attempts to bring the spatial advantage that VR has to offer to MRI imaging. This tool allows doctors and medical practitioners to directly interact with MRI images in a VR environment thereby supporting surgical training and clinical decision making.

A plethora of clone detection techniques have been proposed in the literature to support a variety of programming languages and adopt different clone detection strategies at different levels of complexity. However, despite these major advances, these techniques are still far from achieving optimal accuracy. This requires developers to manually classify and verify the detected candidate clones, a process that is often described as time-consuming and error-prone. This paper describes CloneTM, a code clone detection tool based on Latent Dirichlet Allocation (LDA). We discuss the key features of CloneTM and present our evaluation on two datasets.

Latent Dirichlet Allocation (LDA) is a statistical topic modeling approach that has been used to support various software engineering activities. However, the main problem is the probabilistic distributions generated by LDA to represent topics and documents are not intuitive and easy to comprehend. In order to address this problem, in this paper, we present VisioTM, a language-independent platform to visualize software systems based on LDA. VisioTM provides several visualizations to represent the basic elements of LDA including words, topics, and documents. We discuss the key features and functionalities of the tool.

Latent Direchlet Allocation (LDA) is a statistical topic modeling approach that has been used to support several software engineering activities.The main assumption is that LDA offers a unique insight into the semantic content of software systems, thus revealing otherwise unseen relations between software artifacts.However, a main problem when dealing with LDA is the complexity of its output.In particular, the numerical probabilistic distributions produced by LDA to represent topics and documents are not intuitive to understand and rationalize.To address this problem, in this paper we present a topic modeling based approach to visualize software systems based on LDA.We also present several visualizations to represent the basic elements of LDA including words, topics, and documents.These different basic views are combined through a set of integration links to enable users to effectively explore software systems by supporting knowledge discovery at different levels of abstraction.We also demonstrate how the topic modeling based visualization approach can provide support to several software engineering activities such as program comprehension, software clustering, and code evolution analysis.

In this paper we investigate the potential benefits of Latent Dirichlet Allocation (LDA) as a technique for code clone de-tection. Our objective is to propose a language-independent, effective, and scalable approach for identifying similar code fragments in relatively large software systems. The main assumption is that the latent topic structure of software ar-tifacts gives an indication of the presence of code clones. In particular, we hypothesize that artifacts with similar topic distributions contain duplicated code fragments. To test this novel hypothesis, we conduct an experimental investigation using multiple datasets from difierent application domains. Preliminary results show that, if calibrated properly, topic modeling can deliver satisfactory performance in capturing different types of code clones. It also achieves levels of accu-racy adequate for practical applications, showing compara-ble performance to already existing tools that adopt different clone detection strategies.

Recovering the legibility features is key to reverse engineering as the legible software systems can ease developer's code navigation and comprehension. Landmarks are important legibility features that developers use as reference points. In this paper, we leverage visual clustering to explore how landmarks can be identified via static dependencies. Besides organizing software entities with coherent patterns, visual clustering offers additional insights by rigorously rendering a holistic picture of the code base to the two-dimensional space. We contribute a couple of heuristics based on the cluster layout to identify the landmark files. Our visual exploration of Eclipse Mylyn open source Java project reveals developer's reliance on the landmarks during code navigation and shows the promise of using static dependencies to uncover the landmarks in the software space.

For many software projects, keeping requirements on track needs an effective and efficient path from data to decision. Visual analytics creates such a path that enables the human to extract insights by interacting with the relevant information. While various requirements visualization techniques exist, few have produced end-to-end values to practitioners. In this paper, we advance the literature on visual requirements analytics by characterizing its key components and relationships. This allows us to not only assess existing approaches, but also create tool enhancements in a principled manner. We evaluate our enhanced tool supports through a case study where massive, heterogeneous, and dynamic requirements are processed, visualized, and analyzed. In particular, our study illuminates how increased interactivity of requirements visualization could lead to actionable decisions.

The research on visual analytics for requirements engineering has noticeably advanced in the past few years. For many software projects, requirements management needs an effective and efficient path from data to decision. Visual analytics (VA) creates such a path that enables the user to extract insights by interacting with the relevant information. While various requirements visualization techniques exist, only few have produced end-to-end values to practitioners. In this research proposal, we advance the literature on visual requirements analytics by characterizing its key components and relationships. Such a characterization allows us to not only assess existing approaches, but also develop tool enhancements in a principled manner. We describe our ongoing work on VA and outline future research plans.

The software entities of an object-oriented system should be organized in such a way that "spatial relatedness entails semantic relatedness". We refer this as the tenet of "topical locality" and argue that it is fundamental for the code base to be navigable. In this paper, we propose a novel experimental framework to test this key tenet and use large-scale open-source projects to assess three relationships. In particular, we find that: (1) class name along with header comments conveys class body's topic; (2) a code line is indicative of its surroundings; and (3) a contiguous code fragment may serve as a snapshot of the entire class. Our work not only shows the foundations necessary for the success of many code navigation approaches, but also opens avenues for further tool enhancements.

Clustering is of great practical value in discovering natural groupings of large numbers of requirements artifacts. Clustering-based visualization has shown promise in supporting requirements tracing. In this paper, we transform the success to a wider range of clustering-based visual exploration tasks in requirements engineering. We describe ReCVisu, a requirements exploration tool based on quantitative visualizations. We discuss the key features of ReCVisu and its potential improvements over previous work.