This paper investigates the performance of reinforcement learning (RL)-based AI agents and large language model (LLM)-based AI agents in tackling the word-guessing game Wordle and its variant, Fibble, which introduces misleading feedback. We conducted experiments to compare a range of RL-based approaches and several LLM chatbots, revealing distinct performance differences, especially when confronted with deceptive clues. Our findings show that an RL algorithm specifically designed to handle misleading information outperformed others in Fibble, while a standard RL algorithm designed for the original Wordle excelled in that game but struggled with Fibble. LLM-based solvers demonstrated reasonable performance across both games but generally fell short of the effectiveness of RL-based solvers.

This demo paper11Demo Paper investigates the use of Large Language Models (LLMs) to enhance Wordle and its variant, Fibble. The program allows players to request hints from either a built-in rule-based solver or an LLM, ensuring consistent guesses based on previous feedback. A retry mechanism is employed to refine guesses, with up to five attempts per request. Experimental results show that advanced models like o1-preview achieve a${9 5. 7 4 \%}$win rate in Wordle, though performance drops in Fibble due to deceptive feedback. This work demonstrates the potential of LLMs for interactive problem-solving in gaming contexts.

The number of scientific publications increases tremendously over the past decades. Classifying papers to arXiv style categories makes it easier for individuals to find relevant papers and improves the overall efficiency in the research community. However, the majority of papers are not categorized and manually classifying hundreds of millions of papers is prohibitive. Recent advances in machine learning have paved a way for automatic paper classification. In this paper, we propose an approach to further improve the classification accuracy. Our approach takes advantage of the big-data nature of the problem and uses the publication trend to forecast the number of papers for each category. Then we use the forecasted label distribution to revise the classification results returned by base classifiers. A data-driven heuristic approach is introduced to address the label revision problem. Our experiments with a large publicly available dataset demonstrated that the proposed solution improves the accuracy of all existing approaches.

Autonomous driving systems have a rich and diverse set of sensors and collect a tremendous amount of data during their operations. This has significant implications for individual privacy and induces a new type of potential privacy risks - collateral privacy risks. It is important for the public and the developer community to be aware of the collateral privacy risk posed by current autonomous driving software systems. We performed data privacy analysis for the Apollo project, an open-source autonomous driving software system. We applied source code-based privacy auditing techniques tailored for this particular problem and produced preliminary results, although there were unresolved open issues remaining. As we performed auditing, Apollo was upgraded from version 3.0 to 3.5 with significant under-the-hood technology changes. It was a challenge to perform the analysis as the underlying software evolves and maintain a result that is up-to-date. To address this challenge, we developed and deployed a continuous source code privacy risk analysis tool to assist in the process. In this paper, we discuss our experience and lessons learned from this industrial case study.

Recently many information retrieval (IR)-based approaches have been proposed to help locate software defects automatically by using information from bug report contents. However, some bug reports that do not semantically related to the relevant code are not helpful to IR-based systems. Running an IR-based system on these reports may produce false positives. In this paper, we propose a classification model for classifying a bug report as either helpful or unhelpful using a LSTM-network. By filtering our unhelpful reports before running an IR-based bug locating system, our approach helps reduce false positives and improve the ranking performance. We test our model over 9,000 bug reports from three software projects. The evaluation result shows that our model helps improve a state-of-the-art IR-based system's ranking performance under a trade-off between the precision and the recall. Our comparison experiments show that the LSTM-network achieves the best trade-off between precision and recall than other classification models including CNN, multilayer perceptron, and a simple baseline approach that classifies a bug report based its length. In the situation that precision is more important than recall, our classification model helps for bug locating.

The application of information retrieval techniques to search tasks in software engineering is made difficult by the lexical gap between search queries, usually expressed in natural language (e.g. English), and retrieved documents, usually expressed in code (e.g. programming languages). This is often the case in bug and feature location, community question answering, or more generally the communication between technical personnel and non-technical stake holders in a software project. In this paper, we propose bridging the lexical gap by projecting natural language statements and code snippets as meaning vectors in a shared representation space. In the proposed architecture, word embeddings are first trained on API documents, tutorials, and reference documents, and then aggregated in order to estimate semantic similarities between documents. Empirical evaluations show that the learned vector space embeddings lead to improvements in a previously explored bug localization task and a newly defined task of linking API documents to computer programming questions.

When a new bug report is received, developers usually need to reproduce the bug and perform code reviews to find the cause, a process that can be tedious and time consuming. A tool for ranking all the source files with respect to how likely they are to contain the cause of the bug would enable developers to narrow down their search and improve productivity. This paper introduces an adaptive ranking approach that leverages project knowledge through functional decomposition of source code, API descriptions of library components, the bug-fixing history, the code change history, and the file dependency graph. Given a bug report, the ranking score of each source file is computed as a weighted combination of an array of features, where the weights are trained automatically on previously solved bug reports using a learning-to-rank technique. We evaluate the ranking system on six large scale open source Java projects, using the before-fix version of the project for every bug report. The experimental results show that the learning-to-rank approach outperforms three recent state-of-the-art methods. In particular, our method makes correct recommendations within the top 10 ranked source files for over 70 percent of the bug reports in the Eclipse Platform and Tomcat projects.

When a new bug report is received, developers usually need to reproduce the bug and perform code reviews to find the cause, a process that can be tedious and time consuming. A tool for ranking all the source files of a project with respect to how likely they are to contain the cause of the bug would enable developers to narrow down their search and potentially could lead to a substantial increase in productivity. This paper introduces an adaptive ranking approach that leverages domain knowledge through functional decompositions of source code files into methods, API descriptions of library components used in the code, the bug-fixing history, and the code change history. Given a bug report, the ranking score of each source file is computed as a weighted combination of an array of features encoding domain knowledge, where the weights are trained automatically on previously solved bug reports using a learning-to-rank technique. We evaluated our system on six large scale open source Java projects, using the before-fix version of the project for every bug report. The experimental results show that the newly introduced learning-to-rank approach significantly outperforms two recent state-of-the-art methods in recommending relevant files for bug reports. In particular, our method makes correct recommendations within the top 10 ranked source files for over 70% of the bug reports in the Eclipse Platform and Tomcat projects.

The need to manually specify temporal properties of software systems is a major barrier to wider adoption of software model checking, because the specification of software temporal properties is a difficult, time-consuming, and error-prone process. To address this problem, we propose to automatically extract software library usage rules, which are one type of temporal specifications. Our approach uses a model checker to check a set of software library usage rule candidates against known good programs using that library, and identifies valid rules based on model checking results. These valid rules can help programmers learn about common software library usage. They can also be used to check new programs using the same library. We have implemented our approach in an Eclipse plug-in named LtRules, which can extract software library usage rules from C programs using BLAST as the underlying model checker.

The need to manually specify temporal properties of software systems is a major barrier to wider adoption of software model checking, because the specification of software temporal properties is a difficult, time-consuming, and error-prone process. To address this problem, we propose to automatically extract software library usage patterns, which are one type of temporal specifications. Our approach uses a model checker to check a set of software library usage pattern candidates against existing programs using that library, and identifies valid patterns based on model checking results. These valid patterns can help programmers learn about common software library usage. They can also be used to check new programs using the same library. We applied our approach to C programs using the OpenSSL library and the C standard library, and extracted valid usage patterns using BLAST. We also successfully used the extracted valid usage patterns to detect an error in an open source project hosted by SourceForge.net

The technology of redundant arrays of independent components (RAIC) uses groups of similar or identical distributed components to provide dependable services (Liu and Richardson, 2002). RAIC allows components in the redundant array to be added or removed dynamically during run-time. This paper gives a brief overview of RAIC and discusses its special application for dependable on-line upgrading of distributed systems. A proof-of-concept example is given to illustrate how problems that occur during upgrading can be masked by RAIC and thus not affect smooth operations of the system-under-upgrade.

Algorithmic cost estimation in the context of software evolution is being addressed as part of the FEAST/2 project with encouraging results from an industrial case study.

In many computer system security incidents, attackers successfully intruded computer systems by exploiting known weaknesses. Those computer systems remained vulnerable even after the vulnerabilities were known because it requires constant attention to stay on top of security updates. It is often both time-consuming and error-prone to manually apply security patches to deployed systems. To solve this problem, we propose to develop a framework for automated security checking and patching. The framework, named Securibot, provides a self-operating mechanism for security checking and patching. Securibot performs security testing using security profiles and security updates. It can also detect compromised systems using attack signatures. Most important, the Securibot framework allows system vendors to publish recently discovered security weaknesses and new patches in a machine-readable form so that the Securibot system running on deployed systems can automatically check out security updates and apply the patches.

Impediments to software quality are exacerbated when applications-under-test are developed using component-based software engineering. Component misuse is one such impediment. Component misuse occurs when a component is used in a way that differs from the component producer's expectation. This paper explores the cause of the component misuse problem and proposes a technique to discover, specify, and verify component usage. This technique utilizes regular expressions as the formalism to deal with component usage. This research is part of the software retrospector effort, which aims at a better approach to software analysis and testing for component-based software.