Background: Individual fairness testing aims to identify individual discriminatory instances (IDIs) to improve the fairness of machine learning classifiers through retraining. While prior studies have primarily evaluated fairness testing algorithms based on efficiency and retraining performance, emerging metrics such as the diversity of identified IDIs have recently been proposed. However, these alternative metrics have not yet been established as standard evaluation criteria. Aims: This study investigates the significance of IDI diversity as a metric for evaluating fairness testing algorithms. Specifically, we aim to validate its utility as a core evaluation metric by examining its correlation with both fairness improvement and accuracy degradation in retrained classifiers. Method: We conduct an empirical study using a newly developed framework called Redi. This framework generates multiple IDI sets with controlled variations in diversity, enabling systematic evaluation of their impact on retrained classifiers. We apply Redi to analyze the correlations between IDI diversity and retraining outcomes. The validity of the framework is further supported through auxiliary empirical analyses. Results: Our experiments confirm that IDI diversity exhibits a moderate correlation with fairness improvement, while showing only a weak correlation with accuracy degradation. Additionally, our regression analysis indicates that the actual impact of diversity on fairness improvement is substantial, whereas its impact on accuracy degradation is relatively negligible. Conclusions: These results show that higher IDI diversity substantially enhances fairness with minimal accuracy loss, suggesting that it should be adopted as a meaningful proxy metric for evaluating fairness testing algorithms, complementing the established metrics.

Machine learning–based classifiers have been used for text classification, such as sentiment analysis, news classification, and toxic comment classification. However, supervised machine learning models often require large amounts of labeled data for training, and manual annotation is both labor‐intensive and requires domain‐specific knowledge, leading to relatively high annotation costs. To address this issue, we propose an approach that integrates large language models (LLMs) into an active learning framework, achieving high cross‐task text classification performance without the need for any manually labeled data. Furthermore, compared to directly applying GPT for classification tasks, our approach retains over 93% of its classification performance while requiring only approximately 6% of the computational time and monetary cost, effectively balancing performance and resource efficiency. These findings provide new insights into the efficient utilization of LLMs and active learning algorithms in text classification tasks, paving the way for their broader application.

There have been various studies on the automation of mobile app testing.Typical methods for automated testing of mobile apps are based on random search and on building state transition models.But there are problems in terms of the efficiency of search and accuracy of model building.This paper focuses on applying reinforcement learning to testing of mobile apps, especially issues such as explosion of the number of states, fixed rewards for transitions, and difficulty in convergence of learning.We focus on state definition, reward function, and a learning method to solve these problems.Specifically, we define states using discrete values of UI (User Interface) information on the screen, define a dynamic reward function, and perform periodic learning by using the transition history.The proposed method is implemented and evaluated.Evaluation results show that our proposed approach shows 1.21 times higher coverage than an existing tool using reinforcement learning.

Many approaches have been proposed to detect code clones, which are basically similar code fragments.Most approaches are based on textual similarity.These approaches cannot detect semantic code clones, which are clones that have the same functionality but implemented with different syntax.Two functions can be considered to have the same functionality, when the output is the same given the same input.In order to appropriately generate inputs, we propose applying symbolic execution to semantic code clone detection.These functions are executed to obtain outputs, which are compared to determine if function pairs are clones.Our approach also does not limit output to return values; we also handle arrays and pointers as output, as the execution of the function may cause changes in their values.Furthermore, we classify types to enable cases where the types of inputs and/or outputs are not exactly the same.We evaluate our approach on SemanticCloneBench.

This special session will introduce the participants to the CC2020 Visualization Tool based on the Landscape of Computing Knowledge Table and its 34 topics areas. It will guide them through the process of assigning a minimum and maximum value to the discipline areas of their own degree programme, then enter them into the application and allow the participants to see where in the landscape of computing their own program fits. It will also allow participants to compare their own programme with any other programme entered into the application. We hope to populate the database with programmes from all over the world over the next few months to ensure a global reach for comparison. There has never been a tool to compare computing degrees and this tool not only allows for comparison with current approved curricula but also allows participants to compare their degree with each other. This tool also enables employers to develop a guideline for potential employees and compare with job definitions to help with alignment of qualifications and competencies.

With the increasing use of machine learning software in our daily life, software fairness has become a growing concern.In this paper, we propose an individual fairness testing technique called KOSEI.Individual fairness is one of the central concepts in software fairness.Testing individual fairness aims to detect individual discriminations included in the software.KOSEI is based on AEQUITAS by Udeshi et al., a landmark fairness testing technique featuring a two-step search strategy of global and local search.KOSEI improves the local search part of AEQUITAS, based on our insight to overcome the limitations of the local search of AEQUITAS.Our experiments show that KOSEI outperforms AEQUITAS by orders of magnitude.KOSEI, on average, detects 5,084.8%more discriminations than AEQUITAS, in just 7.5% of the execution time.

A significant part of the recently published ACM and IEEE-CS report "Computing Curricula 2020: Paradigms for Global Computing Education" [1] was the development of visualizations of any computing degree and the comparison with the ACM and IEEE-CS approved curricula. This visualization covers discipline areas that have approved curricula: Computer Engineering, Computer Science, Software Engineering, Information Systems, Information Technology and Cyber Security. The CC2020 report developed a "Landscape of Computing Knowledge" table (see table 1) aggregating all the topic areas of all six approved curricula into 34 topic areas and then assigned a minimum and maximum value for each of topic areas. As part of the visualizations project an online application has been developed (see Figure 1) where stakeholders can assign a minimum and maximum value to each of the topic areas that are required in their degree program and then that program can be matched against the current ACM/IEEE-CS approved curricula and other degree programs globally. This will have significant importance for educators and other stakeholders of computing degree programs.

Today's software has a very complex structure with multiple components, making it difficult to identify the cause of a fault. The process of identifying the cause of a fault may include referring to the logs from the system if they exist. But large and complex systems may generate a huge amount of logs, making the task of finding the important log messages to be a tedious task. In the case of systems that require continuous operation, the cause of faults must be identified quickly in an efficient manner. In this paper, we propose a method that identifies the log messages that are key for finding faults in server-side applications that has a tiered structure, such as LAMP (Linux, Apache, MySQL, PHP), and outputs logs (including traces during operation). The key part of our proposed approach is the application of Spectrum-Based Fault Localization (SBFL) to log files.

With the spread of smartphones, the importance of automated testing of mobile applications has increased.However, many current approaches are inadequate, as they are not able to test functions that are available only on hard-to-reach GUI, which is a screen that can be reached only through a specific sequence of input events.To solve this problem, there has been an increase in testing research based on reinforcement learning, specifically Qlearning.Each research uses different learning targets and reward function.Testing research has also been done using Deep Q-Network, which extends reinforcement learning in a "deep" way.Although each work has conducted their own evaluation, it is not clear how the combination of learning algorithm, learning target, and reward function affects the result.To bridge this gap, we have conducted an empirical study comparing eight possible combinations.Our study found that the combination of Deep Q-Network as the learning algorithm, component as the learning target, and GUI change ratio as the reward function had the highest test quality in terms of code coverage.

The CC2020 project was charged with two main objectives, to produce a comprehensive report and a visualization tool to provide global guidance in an evolving computing environment as it affects computing baccalaureate degree programs worldwide. The report is now in draft form and has undergone four rounds of review. The other goal of the CC2020 project is to develop a set of visualization-based tools that will help users to explore questions they may have concerning curricular guidelines, as well as local computing curricula. A visualization tool has been scoped and a prototype built. This special session will unveil the prototype for the SIGCSE community who will have the opportunity to view and review the tool.

Since the big boom of smartphone and consequently of mobile applications, developers nowadays have many tools to help them create applications easier and faster.However, efficient automated testing tools are still missing, especially for GUI testing.We propose an automated GUI testing tool for Android applications using Deep Q-Network and semantic analysis of the GUI.We identify the semantic meanings of GUI elements and use them as an input to a neural network, which through training, approximates the behavioral model of the application under test.The neural network is trained using the Q-Learning algorithm of Reinforcement Learning.It guides the testing tool to explore more often functionalities that can only be accessed through a specific sequence of actions.The tool does not require access to the source code of the application under test.It obtains higher code coverage and is better at fault detection in comparison to state-of-the-art testing tools.

The ever increasing usage of Android devices and apps has created a demand for faster and reliable testing techniques.While the quality of test cases can be summed up based on the amount of code they cover, fault detection in applications is one of the main objectives for testing.We introduce an Android app testing approach which uses multiobjective genetic algorithm with elitism which finds optimal test cases by minimizing their length, maximizes the code coverage and fault detection capability, and minimizes the whole test suite for re-usability.In addition to that, we also incorporate a progress indicator which checks for improvements in test suite quality after subsequent generations and use it as a stopping criterion.The effectiveness of our approach is shown in our evaluation where it is able to perform better than the existing state-of-the-art tools.

Much work has been done on automating regression testing for applications. But most of them focus on test execution. Little work has been done on automatically determining if a test case passes or fails. This decision is often made by comparing the results of executing test cases on a base version of the application and post-modification version of the application. If the two results match, the test case passes, otherwise fails. However, to the best of our knowledge, there is no regression testing method for automatically deciding pass/fail of dynamic Web applications which use JavaScript or CSS. We propose a method that automatically decides if a dynamic Web application passes a regression test case. The basic idea is to obtain a screenshot each time the GUI of the Web application (i.e. Web page) changes its state, and then compare each corresponding screenshot to see if they match. The evaluation results showed that the accuracy rate of our approach is high and our approach can be considered as fast enough for practical use.

Automated GUI testing based on behavioral model is one of the most efficient testing approaches.By mining user usage, test scenarios can be generated based on statistical models such as Markov chain.However, these works require static analysis before starting the exploration which requires too much prerequisites and time.In this work, we propose a behavioralbased GUI testing approach for mobile applications that achieves faster and higher coverage.Our approach does not conduct static analysis.It creates a behavioral model from usage logs by applying a statistical model.The events within the behavioral model is mapped to GUI components in a GUI tree.Finally, it updates the model dynamically to increase the probability of an event that rarely or never occurs when users use the application.We evaluated our approach on three open-source Android applications, and compared it with other approaches.Our approach showed the effectiveness of our tool.

Automated GUI testing based on behavioral model is one of the most efficient testing approaches. By mining user usage, test scenarios can be generated based on statistical models such as Markov chain. However, these works require static analysis before starting the exploration which requires too much prerequisites and time. To address these challenges, we propose a behavioral-based GUI testing approach for mobile applications that achieves faster and higher coverage. The proposed approach does not conduct static analysis. It creates a behavioral model from usage logs by applying a statistical model. The events within the behavioral model are mapped to GUI components in a GUI tree. Finally, it updates the model dynamically to increase the probability of an event that rarely or never occurs when users use the application. The proposed approach was evaluated on four open-source Android applications, and compared with the state-of-the-art tools and manual testing. The main evaluation criteria are code coverage and ability to find errors. The proposed approach performed better than the current state-of-the-art automated testing tools in most aspects.

Much work has been done on automating regression testing for Web applications, but most of them focus on test data generation or test execution.Little work has been done on automatically determining if a test passed or failed; testers would need to visually confirm the result which can be a tedious task.The difficulty is compounded by the fact that parts of a Web page (such as advertisements) may change each time the Web application is executed even though it has no bearing on the Web application function itself.We thus propose a test oracle for automatically determining the result of regression testing a Web application.The key point of our approach is the identification of parts that may change, which we call variable region.We first generate the expected result, by executing the original (premodification) Web application multiple times so that variable regions can be identified.Then, after the Web application is modified, regression testing is conducted by comparing the output of the modified Web application against the expected output.An evaluation confirmed the usefulness of our approach.

The selection of services is a key part of Service Oriented Architecture (SOA). Services are primarily selected based on function, but Quality of Service (QoS) is an important factor when choosing among several services with the same function. But current service selection approaches often takes time to unnecessarily recompute requests. Furthermore, if the same service is chosen as having the "best" QoS for multiple selections, this may result in that service having too much load. We thus propose the FASICA (FAst service selection for SImilar constraints with CAche) Framework which chooses a service with satisfactory QoS as quickly as possible. The key points are (1) to use a cache which stores previous search results, (2) to use K-Nearest Neighbor (K-NN) algorithm with K-d tree when a satisfactory service does not exist in the cache, and (3) to distribute the service request according to a distribution policy. Results of simulations show that our framework can rapidly select a service compared to a conventional approach.

Service Oriented Architecture (SOA) provides an application framework which integrates variety of technology services in a loosely coupled way. Mule Enterprise Service Bus (ESB) is a widely-used ESB product that provides important functions such as message routing, message transformation, protocol-mediation, and event handling. These functions enable Mule ESB to integrate services implemented on various platforms and technologies. However, Mule ESB does not support business logic at all. Another approach to integrate services is to use a business process language such as BPEL (Business Process Execution Language). BPEL is used to define activities along with control flow. It is limited to Web service connections. One major difference is that BPEL is capable of orchestrating a business process with programming constructs, whereas Mule ESB is capable of processing messages in many protocal connections. Both BPEL and Mule ESB have different advantages. Unfortunately, neither one is powerful enough to solve some classes of business problems. In this paper we present the COMBO framework, which merges the strengths of Mule ESB and BPEL. We develop a tool to translate an extended BPEL file to a Mule ESB configuration file. The configuration file is used within a Mule ESB to execute the process that has been described within the BPEL document. We add extension modules to the standard Mule ESB for supporting BPEL functions that Mule ESB does not provide. The extended ESB has capabilities for supporting variable assignment and conditional branches in complex business processes. Our translation can cover frequently used activities in business processes. We also present case studies that use many business activities to show how the COMBO framework supports various activity translation.

The reverse execution of programs is a function where pro-grams are executed backward in time. A reversible debugger is a debugger that provides such a functionality. In this pa-per, we propose a novel reversible debugger that enables reverse execution of programs written in the C language. Our approach takes the virtual machine based approach. In this approach, the target program is executed on a special virtual machine. Our contribution in this paper is two-fold. First, we propose an approach that can address problems of (1) compatibility and (2) efficiency that exist in previous works. By compatibility, we mean that previous debuggers are not generic, i.e., they support only a special language or special intermediate code. Second, our approach provides two execution modes: the native mode, where the debuggee is directly executed on a real CPU, and the virtual ma-chine mode, where the debuggee is executed on a virtual machine. Currently, our debugger provides four types of trade-off settings (designated by unit and optimization) to consider trade-offs between granularity, accuracy, overhead and memory requirement. The user can choose the appro-priate setting flexibly during debugging without finishing and restarting the debuggee.

Regression testing is testing applied to software that has been modified. It basically entails re-testing the software with previous test cases to confirm that the modifications made to the software do not have an adverse effect. But re-executing all test cases is normally cost prohibitive, and thus much research has been done on selecting test cases from a test suite without compromising the reliability of the software. These regression test selection techniques find test cases that will not detect any bugs in the modified software, and delete those from the next regression test suite. However, these techniques are based on analysis of source code. Recent programming environments have seen a proliferation of virtual machines. For example, programs written in Java and with the Microsoft .Net Framework are compiled into a platform-independent intermediate code which is executed. Such code could also be used for regression test selection. This especially holds for the Microsoft .Net Framework which handles various programming languages, such as Visual Basic and C++. Thus, this paper presents a safe regression test selection technique for virtual machine based programs. We especially target the Microsoft .Net Framework. Evaluation on 10 different examples resulted in an average of a 40.4% decrease in the cost of regression testing.

Two pilot studies in CASE radically changed the way in which data was to be gathered and interpreted i.e. the pilot studies were strongly rather than weakly formative. We report on these two pilot studies, focussing on the key lessons learnt for empirical software engineering which include new ways of thinking about productivity and quality issues.

We suggest that empirical studies of maintenance are difficult to understand unless the context of the study is fully defined. We developed a preliminary ontology to identify a number of factors that influence maintenance. The purpose of the ontology is to identify factors that would affect the results of empirical studies. We present the ontology in the form of a UML model. Using the maintenance factors included in the ontology, we define two common maintenance scenarios and consider the industrial issues associated with them. Copyright © 1999 John Wiley & Sons, Ltd.

Empirical software engineering can be viewed as a series of actions to obtain knowledge and a better understanding about some aspects of software development, given a set of problem statements in the form of issues, questions or hypotheses. Experience has made us aware of the criticality of integrating the various types of data that are collected and analyzed as well as the criticality of integrating the various types of activities that take place, such as experiment design and the experiment itself. This has led us to develop a Computer-Aided Empirical Software Engineering (CAESE) framework to support the empirical software engineering lifecycle. The paper first presents the CAESE framework that consists of three elements: (1) a process model for the "lifecycle" of empirical software engineering studies, including needs analysis, experiment design, actual experimentation, and analyzing and packaging results; (2) a model that helps empirical software engineers decide how to look at the "world" to be studied in a coherent manner; (3) an architecture, based on which CAESE environments can be built, consisting of tool sets for each phase of the process model, a process management mechanism, and the two types of integration mechanism that are vital for handling multiple types of data: data integration and control integration. Next, the paper describes the Ginger2 environment as an instantiation of our framework. It concludes with reports on case studies using Ginger2, which dealt with a variety of empirical data types including mouse and keystrokes, eye traces, 3D movement, skin resistance level, and videotaped data.

Although object oriented languages can help make software more reusable, class libraries can be difficult to use unless the programmer knows the library well. In particular, it can be hard to find and understand components that a programmer may want to reuse. The article focuses on novice programmers solving programming tasks which require the reuse of components. We take an in-depth look at how the programmers find the necessary components, and identify strategies that they use to achieve it. We also comment on the type of tool that is necessary from the viewpoint of the strategies.

We describe an experiment investigating the distribution of failure intensity in software reliability growth models.We found that the assumption of conventional models that the failure intensity follows a gamma distribution is not always true.Our new software reliability model does not make this assumption; rather, the failure intensity is calculated from failure data.We show that our new model predicts more accurately the number of detected faults for our study project than the conventional models.

The augmented encrypted key exchange (A-EKE) uses a shared secret key for encryption. The A-EKE uses the hash of sender's password as the shared secret key. By using Simmon's attack the sender's password can be broken. If this is accomplished, the attacker is able to know the communicating parties session key used after authentication as well as in the authentication of the sender. Furthermore, using the broken session key and the password, the attacker can impersonate the real sender. To prevent this from happening, we propose a method to keep the session key and sender's password secret even if the attacker can break the shared secret key. This is accomplished by using RSA encryption. In our proposed scheme we use public keys which will be kept by the communicating parties and will be exchanged indirectly, i.e. instead of sending the whole public key the two parties will send the number which determines their public key, along with the shared key.