Legacy COBOL systems, which power critical applications in banking, healthcare, and government, are facing a steep decline in skilled COBOL developers and a lack of interactive learning tools for novices. While block-based and visual programming environments exist for programming languages such as C and Python, there are no such tools for legacy languages like COBOL. This paper presents COBMaker, a visual block-based programming interface that provides modular, drag-and-drop blocks for COBOL programming structures, organized in a playbook-style based on COBOL 85 grammar. COBMaker supports structured program construction, abstracts low-level syntax, and enables novice programmers with no prior COBOL experience to write and run COBOL programs directly through the web interface. Our evaluation, conducted with 24 novice programmers across five tasks, demonstrated that COBMaker reduced mental, physical, and temporal demand, effort, and frustration (all p ≤ 0.001), with large to extremely large effect sizes (d = 0.85–3.36), while significantly improving perceived performance (p = 0.001, d = 0.87) compared to text-based COBOL programming. These findings demonstrate the potential of visual programming to lower the learning barrier associated with COBOL and provide insights for legacy language education. The tool demo video is available at https://youtu.be/XOgJ-9olNHg, and the tool and artifacts are at https://github.com/rishalab/COBMAKER.

With the increasing complexity of modern software and the demand for high performance, energy consumption has become a critical factor for developers and researchers. While much of the research community focuses on evaluating the energy consumption of machine learning and artificial intelligence systems, often implemented in Python, a gap exists in tools and frameworks for measuring energy usage in other programming languages. C++, in particular, remains a foundational language for a wide range of software applications, from game development to parallel programming frameworks, yet lacks dedicated energy measurement solutions. To address this, we have developed CPPJoules, a tool built on top of Intel-RAPL to measure the energy consumption of C++ code snippets. We have evaluated the tool by measuring the energy consumption of six standard computational tasks from the Rosetta Code repository. The demonstration of the tool is available at https://youtu.be/6EpoE5COyGI and related artifacts are open-sourced at https://rishalab.github.io/CPPJoules/.

Program comprehension activities account for up to 58% of developers’ time, a figure that is likely even higher in multi-language codebases due to increased cognitive load and context switching. For example, combining Java and C++, usually through the Java Native Interface (JNI), is a common way to build high-performance applications. However, this hybrid approach creates significant challenges for novice developers, who must navigate the complex and error-prone boundary between Java’s managed environment and C/C++’s native code. To address this, we present CrossLink, which combines static analysis with interactive visualizations. It features a cross-language dependency graph that shows dependency links and in-editor annotations that display the status of JNI calls in real time. The tool also provides support for cross-language link integrity and offers rule-based suggestions to improve code quality by naming numeric constants. The artifacts of this tool are available at https://github.com/rishalab/CrossLink, and its demo can be watched here https://youtu.be/ZB3VUi8-hW8

As the veteran workforce retires, COBOL mainframes are getting harder to understand. These codes, most of which lack proper documentation, are harder to understand by novice programmers. It becomes essential to extract Business Rules (BRs) from these systems in order to comprehend their core functionality. Existing state-of-the-art COBREX uses a rule-based approach (control flow graphs) to extract BRs from COBOL programs. We introduce COBRAIN, a tool which leverages large language models (LLMs) via few-shot prompting to extract and summarize BRs from legacy COBOL code. This work seeks to determine the viability of LLMs in accurately and comprehensively capturing business logic embedded within legacy COBOL systems. The research evaluates COBRAIN across three dimensions: (1) precision and recall in business rule extraction, using COBREX’s output as a benchmark; (2) accuracy, as measured by comparison to a manually curated ground-truth dataset; and (3) ease of comprehension and suitability for documentation, particularly for non-technical stakeholders, evaluated through a user-comprehension study. We use mixed-method study to evaluate the tool. COBRAIN achieved a precision of 1.0 and a recall of 0.746 when compared with COBREX. It achieved an F1 score of 0.73 when evaluated with ground truth, compared to COBREX’s F1 score of 0.59. In the comprehension study including 28 participants, over 80% chose COBRAIN over COBREX to have more understandable BRs.

Legacy modernization is a significant task in the software industry to maintain the relevance of legacy but critical software systems that are still widely used across various domains. COBOL, a programming language developed in the 1950s is tightly coupled to modern-day transactions and is the underlying base for the majority of these legacy systems. Researchers and industry have developed a range of approaches and tools to translate these systems to Java. On the other hand, despite the wide adoption of Python in AI and non-AI based applications over the last decade, there is limited research that focuses on Python, COBOL and legacy modernization. Hence, in this paper, we present COB2PY, one of the first tools that facilitates translation of COBOL to Python. COB2PY is a rulebased tool based on COBOL85 grammar for automatically converting procedurally-driven COBOL source code to objectoriented driven Python. It generates the Abstract Syntax Tree of the COBOL source code and translates it to Python code, while preserving the original COBOL code logic and functionality. The tool is evaluated using the Computational Accuracy (CA) on 103 COBOL programs from the CodeNet dataset, and achieved an accuracy of$\mathbf{9 8. 3 5 \%}$. To make translation from COBOL to Python reliable, we avoided Artificial Intelligence (AI) in this version, but a hybrid approach (rule-based + AI) could be explored as future work. We hope that our work could motivate researchers to leverage the best of non-AI and rulebased approaches for software engineering tasks before delving into AI or hybrid approaches. The tool and demo video can be found at https://rishalab.github.io/COB2PY/.

The paper introduces LLM2FedLLM, a tool designed for Software Engineering (SE) researchers to simulate fine-tuning Large Language Models (LLMs) within a federated learning (FL) framework. Unlike existing FL frameworks that facilitate real client collaboration, our simulator provides a controlled environment for experimenting with FL scenarios on a single machine. The LLM2FedLLM Simulator addresses SE code tasks, such as code summarization, code review, and code translation, within a federated learning framework by first partitioning the selected code dataset into heterogeneous subsets for multiple clients. It then fine-tunes the chosen LLM and evaluates its performance against vanilla, centralized, and individual client models using various metrics. The tool supports several federated aggregation methods and PEFT for supervised learning, with the flexibility to easily integrate additional techniques. The evaluation of our tool on Python code summarization showed that FedLLM performs comparably to centralized models and outperforms individual clients, particularly in low-data scenarios. Our tool aims to facilitate research advances in secure collaborative training simulations within the SE community. https://youtu.be/-byKkaiBchw.

ABSTRACT Context Developers often turn to readme files in GitHub repositories when they intend to contribute, reuse, or extend a project. These files act as a primary source of information, offering insights into various aspects of the repository. The content and organization of readme can have a significant impact on the project's popularity, its development progress, and the growth of its community. Objective We examine the growth of GitHub repositories through the lens of their meta‐characteristics, which encompass factors like popularity, community engagement, and development progress, to study the relationship of readme files with repository growth. To achieve this, we conduct a correlation analysis to assess the relationship between project meta‐characteristics and the content and organization of a readme file. Methods To conduct a correlation analysis between readme files and project meta‐characteristics, we compiled a data set of readme files from 2000 public GitHub repositories, encompassing 10 primary programming languages. We define metrics for popularity, progress, and community engagement meta‐characteristics and analyze the correlation of structural features and categorical content in readme files against these metrics using non‐parametric statistical tests. Results The results are presented from three distinct perspectives of project meta‐characteristics across 10 programming languages. The results reveal a positive and strong association of external reference links, contribution guidelines, and team details in readme files with better popularity and larger community size. However, the influence of contribution guidelines in readme files on rate of progress is not clearly evident. Conclusion The study was conducted to assess the correlation of readme file content on repository popularity, development progress, and community size. Our experiments revealed positive correlations between readme content and project meta‐characteristics. However, the extent of correlation varied between repositories across programming languages and meta‐characteristics. We discussed the implications of our findings for developers and researchers and have proposed recommendations for repository owners to organize readme files toward increasing the growth of the repositories with better meta‐characteristics.

Software Engineering (SE) researchers are extensively applying Large Language Models (LLMs) to address challenges in SE tasks such as code clone detection, code summarization, and program comprehension. Despite promising results, LLMs have to be fine-tuned and customized with specific datasets for optimal performance. However, the proprietary nature of SE data, and the lack of LLMs trained on non-open source data is an open problem. While there exists work on applying Federated Learning (FL) for SE, integration of FL with LLMs for SE is unexplored. Hence, we propose a FedLLM for “code summarization” as developers spend more time in comprehending code. We setup a federated learning architecture and fine-tune LLM (Llama2 with 6.7B parameters) using Parameter Efficient Fine-Tuning (PEFT) for code summarization. We conducted our experiments on 40GB RAM GPU in an A100 architecture. Results show that FL-trained LLM is as effective as a centrally-trained one. We envision that leveraging non-open source data using FedLLM for SE could be an interesting research direction.

In the dynamic landscape of contemporary data-driven technologies, software systems depend significantly on vast datasets and ongoing data center operations that utilize diverse database systems to facilitate computationally intensive tasks. The management of vast amounts of data also introduces challenges related to energy efficiency. With the growing concern over energy consumption in software systems, the selection of a Green database system for its energy efficiency becomes crucial. While various software components have been scrutinized for their energy consumption, there exists a gap in the software engineering literature concerning the energy efficiency of database management systems. To bridge this gap, we performed an empirical study to investigate the energy consumption of queries associated with popular database systems namely MySQL, PostgreSQL, MongoDB, and Couchbase. Our assessments, performed on three commonly used datasets, uncover substantial variations in the energy consumption of these database systems. The study suggests a potential need for optimizing energy usage in various database systems, enhancing developer awareness of the impact of running queries on energy consumption. This empowers them to make informed, sustainable choices, warranting further research in this area.

The developer community has witnessed an unprecedented surge in recent years, with over 100 million active developers on the GitHub platform in 2023. Along with it, there is a significant rise and adoption of new programming languages, frameworks and tools. The study aims to comprehend how developers perceive these fast-growing programming languages by performing emotion analysis of developer's comments posted in various software artifacts such as pull requests, issues and commits of GitHub repositories. In this regard, we employed a fine-tuned small 'Large Language Model' (sLLM) to detect emotions, leveraging a balanced dataset from existing literature complemented with additional manual annotations from our collected data. We have analyzed 10 fast-growing programming languages, examining 1.8 million comments from 4.1 million non-code artifacts. To further validate our findings, we have performed a qualitative survey and analysis with 28 developers. Our study reveals insights into the developers emotion associated with these fast-growing languages. Notably, "Surprise" is the predominant emotion associated with these languages.

Readme files and commit logs carry important and useful project information, corresponding to project dependencies, project functionalities, additions, deletions, and so on. These two artifacts have been analysed separately to obtain project specific information corresponding to contribution guidelines, bug prediction and localisation. Linking the readme files with associated commits and further querying the linked data could help in assessing time stamp specific changes made to the readme files. Utilizing knowledge graph representation of data is observed to largely support querying and integration and extraction of data from heterogeneous sources. To this end, we present a tool to generate readme specific temporal knowledge graph, as a first step towards integrating readme files and commit logs. As commits contain temporal information of the changes, we see that overlaying this information over the corresponding text in readme files could help in arriving at a temporal knowledge graph (TKG). We present a case study of querying the TKG for one repository and further evaluate the tool on 10 repositories spanning across 10 programming languages on GitHub. For demo video, visit - https://youtu.be/4YOCDngf4bY. For website of the tool, visit - https://akhilasrimanasa.github.io/rcgraph/

With the exponential growth of data, the demand for effective data analysis tools has increased significantly. R language, known for its statistical modeling and data analysis capabilities, has become one of the most popular programming languages among data scientists and researchers. As the importance of energy-aware software systems continues to rise, several studies investigate the impact of source code and different stages of machine learning model training on energy consumption. However, existing studies in this domain primarily focus on programming languages like Python and Java, resulting in a lack of energy measuring tools for other programming languages such as R. To address this gap, we propose “RJoules”, a tool designed to measure the energy consumption of R code snippets. We evaluate the correctness and performance of RJoules by applying it to four machine learning algorithms on three different systems. Our aim is to support developers and practitioners in building energy-aware systems in R. The demonstration of the tool is available at https://youtu.be/yMKFuvAM-DE and related artifacts at https://rishalab.github.io/RJoules/.

Learning effective representations of source code is critical for any Machine Learning for Software Engineering (ML4SE) system. Inspired by natural language processing, large language models (LLMs) like Codex and CodeGen treat code as generic sequences of text and are trained on huge corpora of code data, achieving state of the art performance on several software engineering (SE) tasks. However, valid source code, unlike natural language, follows a strict structure and pattern governed by the underlying grammar of the programming language. Current LLMs do not exploit this property of the source code as they treat code like a sequence of tokens and overlook key structural and semantic properties of code that can be extracted from code-views like the Control Flow Graph (CFG), Data Flow Graph (DFG), Abstract Syntax Tree (AST), etc. Unfortunately, the process of generating and integrating code-views for every programming language is cumbersome and time consuming. To overcome this barrier, we propose our tool COMEX - a framework that allows researchers and developers to create and combine multiple code-views which can be used by machine learning (ML) models for various SE tasks. Some salient features of our tool are: (i) it works directly on source code (which need not be compilable), (ii) it currently supports Java and C#, (iii) it can analyze both method-level snippets and program-level snippets by using both intra-procedural and inter-procedural analysis, and (iv) it is easily extendable to other languages as it is built on tree-sitter - a widely used incremental parser that supports over 40 languages. We believe this easy-to-use code-view generation and customization tool will give impetus to research in source code representation learning methods and ML4SE. The source code and demonstration of our tool can be found at https://github.com/IBM/tree-sitter-codeviews and https://youtu.be/GER6U87FVbU, respectively.

The energy consumption of machine learning applications and their impact on the environment has recently gained attention as a research area, focusing on the model creation and training/inference phases. The data-oriented stages of the machine learning pipeline, which involve pre-processing, cleaning, and exploratory analysis, are critical components. However, energy consumption during these stages has received limited attention. Dataframe processing libraries play a significant role in these stages, and optimizing their energy consumption is important for reducing environmental impact and operational costs. Therefore, as a first step towards studying their energy efficiency, we investigate and compare the energy consumption of three popular dataframe processing libraries, namely Pandas, Vaex, and Dask. We perform experiments across 21 dataframe processing operations within four categories, utilizing three distinct datasets. Our results indicate that no single library is the most energy-efficient for all tasks, and the choice of a library can have a significant impact on energy consumption based on the types and frequencies of operations performed. The findings of this study suggest the potential for optimization of the energy consumption of data-oriented stages in the machine learning pipeline and warrant further research in this area.

Software documentation is one of the critical aspects of a software project, that could support multiple tasks throughout the software development life-cycle. There is extensive research on understanding issues and challenges with existing documentation, which is typically available as readme files. In projects that support collaborative development, such as those on GitHub, other software artifacts such as commits, pull requests and issues, apart from the conventional readme files, wikis and source code comments, also contain useful information, that supports in understanding, using, extending and maintaining the project. However, we are not aware of any dataset that explicitly focuses on documentation-related information in multiple software artifacts such as readme files, commits and pull requests across a repository. To address this concern and to facilitate further research in software documentation, we present DocMine, as a dataset of documentation-related information, extracted from around 1.35M software artifacts in 950 GitHub repositories, spanning across four different programming languages. The dataset along with its documentation is made available in CSV and .sql formats at - https://doi.org/10.5281/zenodo.5195084.

Energy efficiency has become an important consideration in deep learning systems. However, it remains a largely under-emphasized aspect during the development. Despite the emergence of energy-efficient deep learning patterns, their adoption remains a challenge due to limited awareness. To address this gap, we present DENT (Deep Learning Energy Pattern Tagger, a Chrome extension used to add "energy pattern tags" to the deep learning related questions from Stack Overflow. The idea of DENT is to hint to the developers about the possible energy-saving opportunities associated with the Stack Overflow post through energy pattern labels. We hope this will increase awareness about energy patterns in deep learning and improve their adoption. A preliminary evaluation of DENT achieved an average precision of 0.74, recall of 0.66, and an F1-score of 0.65 with an accuracy of 66%. The demonstration of the tool is available at https://youtu.be/S0Wf_w0xajw and the related artifacts are available at https://rishalab.github.io/DENT/

Insecure code leading to software vulnerabilities can result in damages of the order of millions of dollars, and in critical systems, the loss of life. Hence, developing secure systems free of exploitable vulnerabilities has been a thrust area of research in recent years. Understanding developers’ approach towards vulnerabilities in their code can pave the way for improvements in insecure coding practices. Recent studies have explored online Q&A forums, open-source code repositories, and other code information sources to gain important insights into the pervasiveness of security vulnerabilities. However, to the best of our knowledge, competitive programming (CP) data, a rich source of information about coding practices, has not been explored from the perspective of insecure coding practices. The evaluation and assessment of coding practices used in CP is particularly intriguing because it has become a key player in developer recruitment in recent times. In this paper, we make one of the first attempts to draw the attention of the community to the emergent concern of insecure coding practices in CP. We use static analysis tools to identify the prevalence and nature of vulnerabilities in a large amount of CP data (6.1 million submissions) obtained from a top-rated CP platform, CodeChef, and find that 34.2% of submissions contain vulnerabilities. We observe that many programmers consistently follow insecure coding practices and most of the detected vulnerabilities are characterized by security standards (CWE, CVSS) based on real-world software.

The exponential rise of deep learning, aided by the availability of several frameworks and specialized hardware, has led to its application in a wide variety of domains. The availability of GPUs has made it easier to train networks with a huge number of parameters. However, this rise has come at the expense of ever-increasing energy requirements and carbon footprint. While the existing work tries to combat this issue by proposing optimizations in the hardware and the neural network architectures, there is an absence of general energy efficiency guidelines for deep learning developers. In this paper, we propose an initial catalog of 8 energy patterns for developing deep learning applications by analyzing 1361 posts from Stack Overflow. Our hope is that these energy patterns may help the developers adopt energy efficient practices in their deep learning projects. A survey with 14 deep learning developers showed us that the developers are largely in agreement with the usefulness of the catalog from an energy efficiency perspective. A detailed description of the catalog, along with the posts related to each energy pattern, is available at the following link: https://rishalab.github.io/dl_energy_patterns/

COBOL (Common Business-Oriented Language) has had a strong presence for the last five decades and is still prevalent in the finance and banking sectors and other organizations. The systems which were earlier written in COBOL have now become legacy systems. Therefore, it has become essential to maintain and migrate these legacy COBOL systems. These legacy systems on which companies rely consist of embedded logic to run their business rules and day-to-day operations. Due to ever-changing requirements, these business rules need to be revisited and updated regularly. Understanding the code that enforces the business rules is critical for system evolution. However, this is time-consuming, laborious, and error-prone. Also, the documentation of these systems is sometimes inadequate and may be inconsistent with current organizational policies. Furthermore, the number of current-age developers working on COBOL has been drastically reduced, and they are mainly unfamiliar with legacy systems. To aid this, we propose a tool called COBREX to extract COBOL business rules using a CFG-based approach. The tool’s main aim is to help the researchers and practitioners to understand COBOL source code by extracting and comprehending the business rules. The demo of the tool can be found here - https://youtu.be/3QODmOkISL0 and the details of the tool can be found here -https://rishalab.github.io/COBREXdoc/.

Given the drastic rise of repositories on GitHub, it is often hard for developers to find relevant projects meeting their requirements as analyzing source code and other artifacts is effort-intensive. In our prior work, we proposed Repo Reaper (or simply Reaper) that assesses GitHub projects based on seven metrics spanning across project collaboration, quality, and maintenance. Reaper identified 1.4 million projects out of nearly 1.8 million projects to have no purpose for collaboration or software development by classifying them into ‘engineered’ and ‘non-engineered’ software projects. While Reaper can be used to assess millions of repositories based on GHTorrent, it is not designed to be used by developers for standalone repositories on local machines and is dependent on GHTorrent. Hence, in this paper, we propose a re-engineered and extended command-line tool named RepoQuester that aims to assist developers in evaluating GitHub projects on their local machines. RepoQuester computes metrics for projects and does not classify projects into ‘engineered’ and ‘non-engineered’ ones. However, to demonstrate the correctness of metric scores produced by RepoQuester, we have performed the project classification on the Reaper’s training and validation datasets by updating them with the latest metric scores (as reported by RepoQuester). These datasets have their ground truth manually established. During the analysis, we observed that the machine learning classifiers built on the updated datasets produced an F1 score of 72%. During the evaluation, for each project, we found that RepoQuester can analyze metric scores in less than 10 seconds. A demo video explaining the tool highlights and usage is available at https://youtu.be/Q8OdmNzUfN0, and source code at https://github.com/Kowndinya2000/Repoquester.

Open-source repositories have facilitated developers to reuse existing software artifacts to develop and maintain new or similar kinds of software. However, finding similar repositories is a challenging task as the notion of similarity varies depending on multiple contexts, and most of the existing approaches tend to find similar repositories by comparing similar software artifacts. This paper aims to determine "whether dissimilar artifacts can be used as one of the criteria to find similar repositories?" Even though, there could be dissimilarity between two similar artifacts, there could also be similarities between two dissimilar artifacts. We define the notion of similarity by defining two categories of similar repositories. Four text-based artifacts are selected for the experiment, i.e., pull-requests, issues, commits, and readme files. The textual similarity is computed between different artifacts. The results show that similarity does exist in dissimilar artifacts. We observed that 10-20% of dissimilar artifact pairs could be used in searching similar repositories. The preliminary results show promising directions where dissimilar artifacts can also be considered while searching for similar repositories motivating the need for further research.

Energy efficiency is an essential consideration in mobile application development, given that these apps run on battery-powered devices. This has led the researchers to develop a set of energy design patterns that can help the developers improve the energy efficiency of their applications. However, the adoption of these energy patterns in projects remains a challenge, given the lack of awareness about these patterns among the developers. To bridge this gap, we propose our tool eTagger, a Google Chrome extension that tags GitHub issues from Android repositories with associated energy patterns. eTagger works based on the embeddings generated by Sentence-BERT. We believe that labeling the GitHub issues with energy patterns may help towards their larger adoption as GitHub is a prominent platform in collaborative software development. A preliminary evaluation of eTagger achieved an AUC-ROC of 0.73 with a precision of 0.58, recall of 0.53 and an F1-score of 0.5. The demonstration of the tool is available at https://youtu.be/hP4pWJ4AKxE and related artifacts at https://rishalab.github.io/eTagger/.

GitHub hosts millions of software repositories, facilitating developers to contribute to many projects in multiple ways. Most of the information about the repositories is text-based in the form of stars, forks, commits, and so on. However, developers willing to contribute to projects on GitHub often find it challenging to select appropriate projects to contribute to or reuse due to the large number of repositories present on GitHub. Further, obtaining this required information often becomes a tedious process, as one has to carefully mine information hidden inside the repository. To alleviate the effort intensive mining procedures, researchers have proposed npm-badges to outline information relating to build status of a project. However, these badges are static and limit their usage to package dependency and build details. Adding visual cues such as badges, (see PDF) to the repositories might reduce the search space for developers. Hence, we present GitQ, to automatically augment GitHub repositories with badges representing information about source code and project maintenance. Presenting GitQ as a browser plugin to GitHub could make it easily accessible to developers using GitHub. GitQ is evaluated with 15 developers based on the UTAUT model to understand developer perception towards its usefulness. We observed that 11 out of 15 developers perceived GitQ to be useful in identifying the right set of repositories using visual cues such as (see PDF) generated by GitQ. The source code and tool are available for download on GitHub at https://github.com/gitq-for-github/plugin, and the demo can be found at https://youtu.be/c0yohmIat3A.

Given the limited tool support for energy-saving strategies during the design phase of android applications, developing battery-aware, location-based android applications is a non-trivial task for developers. To this end, we propose eGEN, consisting of (1) a Domain-Specific Modeling Language (DSML) and (2) a code generator to specify and create native battery-aware, location-based mobile applications. We evaluated eGEN by instrumenting the generated battery-aware code in five location-based, open-source android applications and compared the energy consumption with non-eGEN versions. The experimental results show 188 mA (8.34% of battery per hour) of average reduction in battery consumption while showing only 97 meters of degradation in location accuracy over three kilometers of a cycling path. Hence, we see this tool as a first step in helping developers write battery-aware code in location-based android applications. The GitHub repository with source code and all artifacts is available at https://github.com/Kowndinya2000/egen, and the tool demo video at https://youtu.be/Iadfh4cCw8I.

The availability of open source projects on platforms like GitHub has led to the wide use of the artifacts from these projects in software engineering research. These publicly available artifacts have been used to train artificial intelligence models used in various empirical studies and the development of tools. However, these advancements have missed out on the artifacts from non-open source projects due to the unavailability of the data. A major cause for the unavailability of the data from non-open source repositories is the issue concerning data privacy. In this paper, we propose using federated learning to address the issue of data privacy to enable the use of data from non-open source to train AI models used in software engineering research. We believe that this can potentially enable industries to collaborate with software engineering researchers without concerns about privacy. We present the preliminary evaluation of the use of federated learning to train a classifier to label bug-fix commits from an existing study to demonstrate its feasibility. The federated approach achieved an F1 score of 0.83 compared to a score of 0.84 using the centralized approach. We also present our vision of the potential implications of the use of federated learning in software engineering research.

Covid-19 has been causing severe loss to the human race. Considering the mode of spread and severity, it is essential to make it a habit to follow various safety precautions such as using sanitizers and masks and maintaining social distancing to prevent the spread of Covid-19. Individuals are widely educated about the safety measures against the disease through various modes such as announcements through online or physical awareness campaigns, advertisements in the media, and so on. The younger generations today spend considerably more time on mobile phones and games. However, there are very few applications or games aimed to help in practicing safety measures against a pandemic, which is much lesser in the case of Covid-19. Hence, we propose a 2D survival-based game, SurviveCovid-19, aimed to educate people about safety precautions to be taken for Covid-19 outside their homes by incorporating social distancing and usage of masks and sanitizers in the game. SurviveCovid-19 has been designed as an Android-based mobile game, along with a desktop (browser) version and has been evaluated through a remote quantitative user survey, with 30 volunteers using the questionnaire based on the MEEGA+ model. The survey results are promising, with all the survey questions having a mean value greater than 3.5. The game’s quality factor was 69.3, indicating that the game could be classified as excellent quality, according to the MEEGA+ model.

Efficient representation of source code is essential for various software engineering tasks such as code classification and code clone detection. Most recent approaches for representing source code still use AST and do not leverage semantic graphs such as CFG and PDG. One effective technique for representing source code involves extracting paths from the AST and using a learning model to capture program properties. Code2vec is one such path-based approach that uses an attention-based neural network to learn code embeddings which can then be used for various downstream tasks. However, this approach uses only AST and does not leverage CFG and PDG. Even though an integrated graph approach (Code Property Graph) exists for representing source code, it has only been explored in the domain of software security. Moreover, it does not leverage the paths from the individual graphs. Our idea is to extend the path-based approach code2vec to include the semantic graphs CFG and PDG with AST, which is largely unexplored in software engineering. We evaluate our approach on the task of METHODNAMING using a C dataset of 730K methods collected from GitHub. In comparison to code2vec, our approach improves the F1 score by 11% on the full dataset and up to 100% with individual projects. We show that semantic features from the CFG and PDG paths drastically improve the performance of the software engineering tasks. We envision that looking at a mocktail of source code representations for various software engineering tasks can lay the foundation for a new line of research and a re-haul of existing research.

Game engines, are frameworks that provide a platform for developers to build games with an interface tailored to handle the complexity of game development. Though there is extensive empirical research on software frameworks, there is a need for empirical studies on game engines, as they differ from traditional software frameworks. Thus, to aid research and development in the area of game engines, we present GE526, a curated dataset of 526 game engine repositories mined from GitHub, which can help researchers to analyze game engines in terms of the release cycles, code quality, API usability and so on. To the best of our knowledge, we are not aware of any curated dataset that caters to game engines in the literature. The dataset contains metadata of all the mined repositories, including 582,079 commits, 20,138 pull requests, 30,287 issues reports and 2,111 releases. The dataset along with its documentation is made available at - https://bit.ly/3pyexnc.

Open source projects are adopting faster release cycles that reflect various changes in the software. Therefore, comprehending the effects of these changes as software architecture evolves over multiple releases becomes necessary. However, it is challenging to keep architecture in-check and add new changes simultaneously for every release. To this end, we propose a visualization tool called AC2, which allows users to examine the alterations in the architecture at both higher and lower levels of abstraction for Python projects. AC2 uses call graphs and collaboration graphs to show the interaction between different architectural components. The tool provides four different views to see the architectural changes. Users can examine two releases at a time to comprehend architectural changes between them. AC2 can support the maintainers and developers, observing changes in the project and their influence on the architecture, which allows them to examine its increasing complexity over many releases at component level. AC2 can be downloaded from https://github.com/rishalab/AC2 and the demo can be seen at https://www.youtube.com/watch?v=GNrJfZ0RCVI.

Many novice programmers visit Stack Overflow for purposes that include posing questions and finding answers for issues they come across in the process of programming. Many questions have more than one correct answer on Stack Overflow, which are accompanied by number of comments from the users. Comments help developers in identifying the answer that better fits their purpose. However, it is difficult to navigate through all the comments to select an answer. Adding relevant visual cues to comments could help developers in prioritizing the comments to be read. Comments logged generally include sentiments of users, which, when depicted visually, could motivate users in reading through the comments and also help them in prioritizing the comments. However, the sentiment of comments is not being explicitly depicted on the current Stack Overflow platform. While there exist many tools that augment or annotate Stack Overflow platform for developers, we are not aware of tools that annotate visual representations of sentiments to the posts. In this paper, we propose StackEmo as a Google Chrome plugin to augment comments on Stack Overflow with emojis, based on the sentiment of the comments posted. We evaluated StackEmo through an in-user likert scale based survey with 30 university students to understand user perception towards StackEmo. The results of the survey provided us insights on improving StackEmo, with 83% of the participants willing to recommend the plugin to their peers. The source code and tool are available for download on GitHub at: https://github.com/rishalab/StackEmo, and the demo can be found here on youtube: https://youtu.be/BCFlqvMhTMA.

Abstract There is an increasing interest shown by researchers and developers in reducing the battery consumption of Android applications. Recently, the battery optimization features such as doze mode, app standby, background execution limits, and background location limits were introduced in the form of API changes. According to the API changes, application developers have to change their source code to manage the behavioral changes caused by operating system limitations. These battery optimization features are evolving rapidly, and the apps show unexpected behaviors until updating the source code. Also, developers find it difficult to cope with the changes. Therefore, there is a need to understand the behavioral changes, application developer's perceptions, and response patterns on the API changes to plan upcoming battery optimization features. In this article, we have collected the relevant GitHub issues from 225 open‐source Android repositories and performed a thematic analysis of collected data. This study analyzes the 391 related issues to answer three research questions. This study's important finding is that developers often post issues related to delayed app notifications, inconsistent background location updates, and suspended background tasks, and so on. We found that library developers are showing a quick response to API changes compared with application developers.

Abstract Extensive development of games for various purposes including education and entertainment has resulted in increased development of game engines. Game engines are being used on a large scale as they support and simplify game development to a greater extent. Game developers using game engines are often compelled to use various application programming interfaces (APIs) of game engines in the process of game development. Thus, both quality and ease of development of games are greatly influenced by APIs defined in game engines. Hence, understanding API usability in game engines could greatly help in choosing better game engines among the ones that are available for game development and also could help developers in designing better game engines. In this article, we thus aim to evaluate API usability of 95 publicly available game engine repositories on GitHub, written primarily in C++ programming language. We test API usability of these game engines against the eight structural API usability metrics—AMNOI, AMNCI, AMGI, APXI, APLCI, AESI, ATSI, and ADI. We see this research as a first step toward the direction of improving usability of APIs in game engines. We present the results of the study, which indicate that about 25% of the game engines considered have minimal API usability, with respect to the considered metrics. It was observed that none of the considered repositories have ideal (all metric scores equal to 1) API usability, indicating the need for developers to consider API usability metrics while designing game engines.

Lambda expressions are anonymous functions in Python. It is one of the alternatives to write a function definition. Syntactically, it is a single expression and defined using the keyword lambda. Lambda expression is a functional programming feature, currently in use, in many mainstream programming languages such as Python, Java8, C++11. There are few studies in C++ and Java to understand the impact of lambda expressions on programmers. These studies are focusing on the developer's adaptability to use a functional style of construct and the benefit they gain from using it. However, we are not aware of any literature on the use of lambda expressions in Python. Thus, there is a need to study lambda expressions in Python projects. In this paper, we examine 15 GitHub repositories out of 760 from our dataset, that are using Python as their primary language. In this study, we are classifying the uses of lambda expressions based on varying scenarios. We identified 13 different usages of lambda expressions from these Python repositories. This catalog is an attempt to support programmers to use lambda expressions more effectively and efficiently.

Comprehending arrays in programming is considered as one of the difficult tasks for novice programmers because of the complexity involved in their definition, declaration, and operations. Visualization of data structures and algorithms is a valuable learning aid for novice programmers. However, existing techniques show the visualization of code after compiling the program, rather than during the development process. To address this, we present SupportArr, a tool that helps in the visualization of arrays in C/C++ programming languages. The core idea is to provide an in-built IDE support for novice programmers to visualize the statements in code without executing the program. We conducted a preliminary experiment with 23 novice programmers and got a promising result from 84% of the participants.

Language Learning can lead to the development of one's communication abilities and helps individuals to express, read, write, and think. Many tools and technologies have been proposed to make language learning an easy and enjoyable process. Games are one of the ways that aid in an informative, exciting, and fun learning experience. Thus, we propose L2to help novice language learners to grasp the Indian language vocabulary based on the clues of object images. L2is a 3D game where the player is provided with a cloud of letters and an image of object to interpret. Observing and understanding the image, the player chooses a set of letters that would form a word corresponding to it. On choosing the right set of letters, the player gets promoted to the next level; otherwise, the player is asked to restart the level. We implemented L2for two Indian languages, namely Hindi and Telugu, using Unity 3D. We evaluated this game with 22 participants and got a favourable response from 89% of the users.

Augmented Reality (AR) is one of the emerging technologies which helps in enhancing user experience by providing a composite view of the real-world objects. It supports the user with superimposed information on top of the object, thus creating a live experience. Besides, coding is pervasive in today's world, and there is a strong need for well-equipped developers with thorough theoretical and practical knowledge. Data Structures and Abstract Syntax Trees are two of the fundamental topics of the computer science domain. Data structures help in the organization of data, whereas, Abstract Syntax Trees (ASTs) enable better comprehension of source code by syntactically analyzing it. In this paper, we propose an augmented reality-based software application AST[AR] to teach data structures with the help of ASTs. We conducted a user experience study with 30 volunteers and got positive feedback from 80.6% of the participants. We believe that this software application will help in bifold learning of data structures as well as ASTs with exciting and enjoyable user experience.

There is a significant rise in the availability, development and size of software projects in the present day. Many open source projects are reused or updated for various purposes that include fixing bugs in existing projects, development and maintenance of project extensions. Developers who interact with the projects might require documentation for better comprehension of the project and to develop extensions. Most of the software projects currently do not have sufficient documentation or it is not updated along with the project. If some projects have reasonably sufficient documentation, it is usually difficult to comprehend it either for maintenance or for reuse purposes. Considering the usefulness of Augmented Reality (AR) towards comprehension, we propose the vision of integrating the domains of augmented reality and software documentation, and specifically, visualization of software documentation using AR. In this paper, we present some of the directions that could be explored towards this vision and also present an example visualization scenario for API documentation using neural system metaphor. We see this paper as a basis for the future research direction of leveraging AR towards making documentation as a primary artifact in the software development process.

Museums act as a vehicle to collect, preserve and demonstrate historical, cultural and scientific heritage to a larger community of end users. However, there is neither increase in the number of physical visitors nor visitors to online museum, despite their availability on the web. On the other hand, Augmented Reality has emerged as a potential technology to support and enhance experience of end users in different communities especially in digital heritage. In this paper, we propose Augmented Reality Museum (ARM) as an application that can enhance online museum visitor experience. Augmented Reality can be integrated as a mobile application that provides 3D view of an artifact, along with information about its historic, artistic and/or scientific importance. We present the design and development of ARM and demonstrate it for the case study of Online British Museum. Our user experience study conducted with 21 volunteers shows that ARM is potentially a good way to enhance user experience.

There is a tremendous increase in the use of online coding platforms, courses and walkthrough tutorials to learn programming today. Stack Overflow, a Q&A website of crowd-sourced knowledge on programming is one of the popular platforms that developers and learners use to ask and answer Q&As related to programming. However, novice programmers often face difficulties in understanding the answers as they may contain new terminologies, function calls and attributes of certain technology or programming language. Researchers have proposed different ways to augment Stack Overflow in the literature, but to the best of our knowledge, there is no work that exists to augment Stack Overflow posts with definitions of API calls and relevant examples. To this end, we propose StackDoc, a prototype plug-in that augments Stack Overflow with definitions and examples of API calls in the questions and answers with the goal of helping novice programmers. We did a preliminary survey with 20 students of various universities, novice to Java and 85% of the users reported positive experience with the plugin.

In the recent years, there has been a surge in the adoption of agile development model and continuous integration (CI) in software development. Recent trends have reduced average release cycle lengths to as low as 1-2 weeks, leading to an extensive number of studies in release engineering. Open-source development (OSD) has also witnessed a rapid increase in release rates, however, no large dataset of open-source projects exists which features high release rates. In this paper, we introduce the RapidRelease dataset, a data showcase of high release frequency open-source projects. The dataset hosts 994 projects from Github, with over 2 million issue reports. To the best of our knowledge, this is the first dataset that can facilitate researchers to empirically study release engineering and agile software development in open-source projects with rapid releases.

There is an ever increasing growth in the use of Q&A websites such as Stack Overflow (SO), so are the number of posts on them.These websites serve as knowledge sharing platforms where Subject Matter Experts (SMEs) and developers answer questions posted by other users.It is effort intensive for developers to navigate to right posts because of the large volume of posts on the platform, despite the presence of existing tags, that are based on technologies.Tagging these posts based on their context and purpose might help developers and SMEs in easily identifying questions they wish to answer and also in identifying contextually similar posts.To support this idea, we propose SOTagger as a prototype plug-in for Stack Overflow to tag questions contextually.We have considered SO data provided on SOTorrent and automated the identification of 6 categories of questions using Latent Dirichlet Allocation.We have also manually verified relevance of these categories.Using these categories and dataset, we have built a classification model to classify a post into one of these six categories using Support Vector Machine.We have evaluated SOTagger by conducting a user survey with 32 developers.The preliminary results are promising with about 80% developers recommending the plugin to others.

Recursion is a fundamental concept in several courses in computer science but is often one of the most confusing concepts for beginners. On the other hand, music is universal and appeals to most people. This paper is a novel attempt to understand and utilize the synergy between music and computer science to teach recursion to freshman students. The paper presents the retrograde strategy and collaboration techniques used during the composition of music and explains how these ideas can be used to learn recursion and stack data structure. We taught recursion to 30 first year undergraduate students in computer science using the normal approach and then demonstrated the control flow using the retrograde strategy. We found that around 81.2% preferred correlation with music. We see this as an initial step towards a deeper correlation of composing music and composing code.

Ontologies have emerged as a common way of representing knowledge.Recently, people with minimal domain background or ontology engineering are developing ontologies, leading to a corpus of informal and under-evaluated ontologies.Existing ontology evaluation approaches require rigorous application of formal methods and knowledge of domain experts that can be cumbersome or tedious.We propose a lightweight approach for evaluating sufficiency of ontologies based on Natural Language Processing techniques.The approach consists of verifying the extent of coverage of concepts and relationships of ontologies against words in domain corpus.As a case study, we applied our approach to evaluate sufficiency of ontology in two example domains -Education (Curriculum) and Security (Phishing).We show that our approach yields promising results, is less effort intensive and is comparable with existing evaluation methods.

The core idea of patterns and pattern languages is the encapsulation, modeling and delivery of expert's knowledge and best practices to novices in a discipline. The use of such an approach is critical for modeling Instructional Design (ID) as it forms the basis for design of TEL systems (for e.g., eLearning Systems). While there is extensive work on patterns for ID from Pedagogy Patterns Project, E-LEN and so on, the focus has been on patterns at lower level of granularity rather than an approach that integrates patterns from ID and TEL perspectives. In addition, most of the researchers have focused either on domain patterns (ID) or TEL patterns, and not both. In this context, this paper presents a patterns-based approach to design of TEL systems based on ID. The crux of this approach is to model a solution in ID using patterns and integrate it with a solution in TEL. To this end, we present an approach that integrates Pattern-Oriented Instructional Design (POID) and Software Architecture for TEL Systems based on fundamental principles in software engineering (SE). We then illustrate our approach and ID patterns through adult literacy case study.

Today, software is being co-designed, co-developed, co-maintained and customized by professionals from a wide range of other disciplines and end users from varied and different backgrounds in addition to software engineers. While there is extensive research on facilitating and supporting end users to write better software, there is sparse research on better ways of educating them with software engineering (SE) knowledge. On the other hand, learning domain has recognized the need for adaptive and personalized learning (APL) and developed numerous approaches, methods and tools to address that need. The main purpose of this paper is firstly to expose some challenges of teaching SE to end users with an aim of understanding learning needs of end users. We then present a brief overview of APL domain and an ontology based framework for integrating APL with software engineering education (SEE). We then discuss a brief example of end users from adult literacy followed by some future directions towards delivering personalized SEE.

How can we design technology for 287 million adult illiterates in India spread across 22 Indian Languages? In this paper, we summarize our experience towards addressing this challenge over the last 6 years. We briefly present our journey of technology for adult literacy in India emphasizing the key shift in focus between different generations. We then present the design of technology for adult literacy from multiple perspectives of learning methodologies, learning technologies, software engineering and HCI. The main thrust of this paper is to present a holistic perspective of designing technology for supporting education in the context of mass scale and variety.

The significance of technology in today's education is inevitable for teachers to design interactive environments based on learning methodologies and for learners to interact, explore and create personal animations, stories and games to learn a topic. Even with rapid advances in the field of end-user programming and software engineering, teachers/learners often spend considerable effort for using technology to support their activities. While there are many end-user environments like Scratch, Alice and so on, their focus is on programming but our need is to design these kinds of environments to support adult literacy in India, which is our target group. In this paper, we present GURU, a prototype environment for both teachers/learners alike to enrich their teaching/learning experience. GURU has two unique aspects: It is designed for teachers with minimal technical expertise and it strongly aligns with learning methodologies. It is based on IDont framework that uses ontologies for capturing different aspects of adult literacy instructional design. In this short paper, we present the design of GURU as a teachers' environment. GURU is essentially a web based authoring environment for creating adult literacy eLearning content but points to the need for such kinds of environments for subjects other than programming.

It is inevitable to make use of technology to support 287 million adult illiterates of India spread across 22 Indian Languages and dialects. How to reduce the complexity during the creation and maintenance of adult literacy instructional design (goals, process, context, content and so on) while addressing large scale and variety? In this paper, we motivate the need for ontologies to address this inherent complexity in adult literacy problem. To this end, we present an ontology based educational modeling framework called IDont to capture different aspects of adult literacy instructional design. The core idea of this ontological framework is to systematize, separate and capture different aspects of adult literacy instructional design through several modular interrelated ontologies for context, goals, process, instructional material, role, evaluation and environment. Even though IDont is broadly applicable to all forms of educations in principle, we confine and present its application to adult literacy case study in this paper.

How can we reduce the enormous effort during development and maintenance of a large scale and variety of a family of eLearning Systems? The main thrust of this paper is to discuss software engineering aids to address this concern. Firstly, we brief the adult literacy case study and GAMBLE framework that form the basis for discussion in this paper. Then we present two major software engineering aids that we have devised during our experience (i) GAMBLE Platform that integrates multiple reasoning technologies to support modeling instructional material in the form of data (facts, cases, rules, models - fcrm) and an interactive environment GURU for both teachers and learners alike to enrich their teaching/learning experience (ii) Applying software product lines to address scale and variety challenges of educational technologies. Finally, we succinctly present Lean Software Product Lines as a potential future direction. The discussion in this paper is based on analyzing and improving a decade-long technology for adult literacy for over four and half years.

The tremendous potential of technology to support teaching/learning is being critically questioned today because of the significant decrease in quality of instruction and the massive effort of developing and maintaining educational technologies. In four and half years of our experience of analyzing and improving a decade long technology for adult literacy, we observed a strong need for (i) a unified modeling framework to organize instructional material in the form of data (ii) a technology platform to support the framework in (i) and an interactive environment based on the framework for both teachers and learners (iii) a methodology that accelerates the development and maintenance of educational technologies. In this paper, we briefly present our work that addresses some of the above needs through (i) GAMBLE, a unified modeling framework to improve quality of instruction by organizing instructional material in the form of data (facts, cases, rules, models-fcrm). Essentially, GAMBLE is a goal-driven model-based approach to teaching/learning based on fundamental learning methodologies (ii) We briefly discuss about our technology platform for modeling instructional material in the form of fcrm and present GURU, an integrated and interactive authoring and learning environment for both teachers and learners based on GAMBLE (iii) We expose the challenges of applying software product lines to accelerate educational technologies and suggest Lean Software Product Lines (SPLEAN) as a light-weight, integrated approach to address the scale and variety inherent in technology for education (T4E) domain. While (i) and (ii) are proposed specifically for adult literacy, we believe that they are also widely applicable to other areas like school and engineering education.

How can Software Engineering support Technology for Education (T4E) community to enable even non- technical users to rapidly develop quality instructional software (Technology for X) with minimal effort? The main thrust of this tutorial is to unveil and uncover the potential of Software Engineering to address the above concerns from multiple dimensions. We briefly discuss the state-of-art in educational technologies (ET) from a software engineering (SE) perspective and formulate significant research challenges for both the communities. We emphasize that developing and maintaining educational technologies is not just content and infrastructure management but has tremendous scope to apply the ideas of software engineering. SE is further required to address the scale and variety challenges that are inherent in T4E domain. We discuss the applicability of SE life cycles (iterative, agile) in the context of T4E domain. We then present a case study of applying software engineering ideas to accelerate the development and maintenance of a family of eLearning Systems. Finally, we briefly outline an integrated approach of Lean, Agile and Software Product Lines (SPL) with potential research agenda for next 5-10 years and uncover this approach as a significant value add for the T4E community.

Summary form only given. Tracking and identifying persons in videos are important building blocks in many applications. For interactive investigation of surveillance footage it is often not even necessary to uniquely identify a person. It rather suffices to find occurrences of a person indicated by the user with an exemplary image sequence. We present a system in which the search for a specific person can be initiated by a sample image sequence and then be further refined by interactive feedback by the operator. The demonstrated system will track people online in multiple cameras and make the sequences immediately searchable from a central station.

The exponential decrease in the quality of education despite innumerable number of learning systems has motivated us to design learning environments that ensure quality of education. We propose GAMBLE as a goal driven model based approach to teaching/learning that emphasizes on making goals of learners and instructors explicit and provides a platform for designing, refining and debugging models to achieve these goals. We also propose the idea of SPLEAN that integrates lean thinking and software product lines to significantly improve productivity. This paper also discusses construction of eLearning Systems that are of broader interest to society like adult literacy as a means of evaluating proposed approaches and ends with many possible future directions towards ensuring quality of education.

Developing and maintaining eLearning systems for multilingual requirements manually is difficult in terms of cost, quality and productivity because of the enormous number and huge variety of products. We propose an approach that emphasizes on standardization, tools and processes to enable automation in these kinds of systems. This differs from traditional approaches as it focuses on building systems that involve little or no computer programming. The approach and concepts are illustrated using a large scale industrial project. The lessons learned from this exercise are used to solve ldquoa class of problemsrdquo in eLearning systems.