Code search plays a role in bridging code and query. However, recent code search studies mainly rely on affinity-matrix-based cross-modal attention to learn the word alignments between code and query, which may lead to incorrect alignments. In this paper, we propose a Global Alignment Learning Model (GALM) to learn global alignments and demonstrate that better-learned correct alignments can significantly improve code search performance. Specifically, GALM characterizes the query and code embedding into an alignment graph to enhance the feature representation and further learns global alignments by a dense graph convolutional network. To evaluate the performance of GALM, we compared it with several baseline models on two pop-ular datasets. The results demonstrate that GALM outperforms the best baseline models by 9.8% and 6.8% with the Top@1 accuracy of 0.601 and 0.671 on two datasets, respectively.

Software specification quality significantly influ-ences overall software quality. Ambiguity in natural language specifications has been identified as a major obstacle to achieving high quality. Formal methods have been proposed as a solution to mitigate this issue, but their adoption in software development remains limited. While previous studies have primarily focused on the challenges of introducing formal methods, few reports exist on the effects of applying formal methods in software development. To tackle this issue, this study analyzes the trends in OSS (open source software) with and without formal methods, based on issues collected from GitHub repositories. We employed BERTopic, a topic modeling technique, to extract topics associated with issues. Subsequently, we labeled the issues and statistically compared topics of issues in OSS with and without formal methods. The results indicate a significant difference in the tendency of issues between OSSs with formal methods and without formal methods, particularly in the frequency of reported errors. These findings suggest the existence of issues specific to OSSs with formal methods and highlight the potential benefits of formal methods in reducing errors during development.

Ambiguous words in software requirements specifications (SRSs) can cause serious misunderstanding, confusion and/or troubles between software purchasers and developers due to differences in interpretation of the words. This paper quantitatively analyzes existing SRSs to clarify (1) how many ambiguous words are actually included in SRSs and (2) how many these words require correction. This paper targets the Request For Proposals (RFPs), which describes initial requirements, of ten local government systems and ten library systems in Japan. As candidates of ambigous words, we analyzed ten Japanese words: (1) Ippanteki (common, commonly used, widely used), (2) Juudai (serious, seriously, critical, severe), (3) Juubun (sufficient, sufficiently), (4) Tekido (adequate, adequately, appropriate, reasonable), (5) Kouritsuteki (efficient, efficiently), (6) Juuyou (important), (7) Shunji (immediate, immediately), (8) Sugu (im-mediate, immediately), (9) Sokuji (immediate, immediately) and (10) Tadachi (immediate, immediately). As a result of the analysis, we found that among ten words, juubunnna (sufficient) was most frequently appeared in SRSs, and 43% of cases required correction when this word appeared. In addition, we also found that the number of ambiguous words varied greatly among the SRSs, and that larger SRSs did not necessarily contain more ambiguous words.

In recent years, desktop applications are often ported to the Web. This is because Web applications running in a cloud environment have many advantages, for example, they can be used by a wide variety of clients over the Internet and can dynamically allocate computing resources according to demand. Such porting is also very important in terms of effectively utilizing existing software assets in a modern environment. However, porting to the Web involves numerous considerations that are not easy for those without the knowledge and skills to perform. In this paper we describe in detail our experience of porting a desktop Python application, which uses the image processing library OpenCV and the GUI library PySimpleGUI, into a web application, which uses the web framework Django, the CSS framework Bootstrap, the database management system MySQL and phpMyAdmin. We also employed Docker and Docker Compose for flexible development and deployment. Through our experience, we have identified six key aspects to consider when porting a desktop application to the web. This paper will elaborate on these aspects and how to deal with them. This paper also reports which parts of source code could be reused, which parts had to be newly developed, and the size and time required to conduct reuse, modification, and additional development.

In recent software development, which has become increasingly large and complex, a huge number of issues including bugs, improvements, new feature requests are reported on a daily basis, and there is a risk of missing urgent bugs. Security bugs are particularly urgent because they can cause serious problems such as mal ware infections, and must be resolved quickly. Therefore, it is important to develop a technique to automatically identify security bugs in a large number of issue reports. The goal of this study is to empirically evaluate recent machine learning methods to identify security bugs using issue report text written in natural language as input. Specifically, this paper focuses on the two-class classification model using BERT, a language model based on the Transformer architecture. The model is constructed by fine-tuning a pre-trained model of BERT with the text of issue reports. In our experiment, we performed classification of issue reports obtained from four open source software projects. As a comparison method, we employ a classification model using features obtained by N -gram IDF, which is an extension of the conventional Bag-of- Words approach. We also employ ChatGPT, which is a general-purpose chatbot that utilizes a large-scale language model (LLM). As a result of our experiment, the BERT-based model showed the best classification performance in terms of F1 score. ChatGPT was better than the N-gram IDF based model, but far behind the BERT.

Association rule mining is a highly effective approach to data analysis for datasets of varying sizes, accommodating diverse feature values. Nevertheless, deriving practical rules from datasets with numerical variables presents a challenge, as these variables must be discretized beforehand. Quantitative association rule mining addresses this issue, allowing the extraction of valuable rules. This paper introduces an extension to quantitative association rules, incorporating a two-variable function in their consequent part. The use of correlation functions, statistical test functions, and error functions is also introduced. We illustrate the utility of this extension through three case studies employing software engineering datasets. In case study 1, we successfully pinpointed the conditions that result in either a high or low correlation between effort and software size, offering valuable insights for software project managers. In case study 2, we effectively identified the conditions that lead to a high or low correlation between the number of bugs and source lines of code, aiding in the formulation of software test planning strategies. In case study 3, we applied our approach to the two-step software effort estimation process, uncovering the conditions most likely to yield low effort estimation errors.

Abstract Faulty Interaction Localization (FIL) is a process to identify which combination of input parameter values induced test failures in combinatorial testing. An accurate and fast FIL provides helpful information to fix defects causing the test failure. One type of conventional FIL approach, which analyzes test results of whole test cases and estimates the suspiciousness of each combination, has two main concerns; (1) the accuracy is not enough, (2) the huge time cost is sometimes needed. In this paper, we propose two novel approaches to improve those concerns. attempts to estimate suspiciousness more accurately using logistic regression analysis. attempts to estimate failure-inducing combinations at high speed by estimating the subsets of them using logistic regression analysis and exploring just their supersets. Through evaluation experiments using a large number of artificial test results based on several real software systems, we observed that has very high accuracy, and can drastically reduce time cost for targets that have been difficult to complete by the conventional method.

GitHub is a huge publicly available development platform for hosting a version control system based on Git; software developers prefer to host their various software projects in GitHub. Therefore researchers who are interested in mining software repository frequently use GitHub to collect software projects as datasets. GitHub provides us with repository metrics such as popularity, contribution, and interest. We believe that such metrics are related to the quality of software; we use them to opt for studied repositories according to our research purpose. However, to the best of our knowledge, nobody has any evidence to support this assumption.Our main purpose is to provide researchers who study software quality, especially issue management, with repository metrics to select appropriate repositories for their studies. In this paper, we study the relationship between the characteristics of the issue pages of repositories that are selected by repository metrics in order to figure out the best repository metric to select proper repositories. The following findings are the highlights of our study: (1) The number of contributors that indicates the number of developers who contribute to a GitHub repository can be used to select the repositories having issue pages that are well-maintained. More specifically, such issue pages include more issues and in which developers use the labels more frequently rather than those that are selected by other metrics. (2) The number of dependencies opts for the repositories that have fewer issues and in which developers use the labels less often rather than those that are selected by other metrics.

Combinatorial testing is a widely used technique to detect failures caused by interactions of system under test (SUT) parameters. Faulty interaction localization (FIL) is a problem to locate parameter-value combinations that trigger failures from combinatorial test cases and their testing results. FIL is important for debugging, but is expensive for large test suites and SUTs since the number of candidates of faulty interactions increases exponentially with the number of parameters and the size of interactions. To address this problem, this paper proposes a method employing logistic regression. The proposed FIL based on Regression coefficients Of loGistic regression analysis (called FROG) computes the suspiciousness of each parameter-value combination to be included in a faulty interaction from its corresponding regression coefficient. We evaluate the proposed method by applying FROG to combinatorial t-way test cases (2 ≤ t ≤ 4) for real application SUT models, e.g. TCAS, GCC, and Apache. Our experiment results show that FROG can effectively locate faulty interactions injected while efficiently reducing the number of candidates of potential faulty interactions to be checked.