Reviewerly/exHarmony huggingface dataset:
SCD-CA: Stable Concept Drift Learning Based on Correlation Alignment for Streaming Data Forecasting

In various real-world cases, the streaming data is sequentially collected over time. It means the distributions could change due to the non-stationary and uncertain environments over time, which is, the concept drift. To handle concept drift, in this paper, we propose a novel concept drift adaptation method SCD-CA, which conducts the adaption models from historical data to forecast the future unseen data. Our method can take a correlation alignment to alleviate the bias caused by fake correlations among variables. In particular, we design an analyzable optimization process to find optimal parameters for unseen streaming data forecasting. Experimental results validate the superiority of our method in wind field dataset, showing it is feasible and promising.
Multi-agent cooperative strategy learning method based on transfer Learning

Path planning is of great significance for industrial production and daily life, where various intelligent methods have been applied to it. Reinforcement learning (RL), as a popular area of machine learning, can effectively find the optimal path by interacting with the environment. Q-learning is one of the most popular algorithms among the reinforcement learning methods. Although Q-learning is simple and effective, its training time will rise sharply when the environment to be explored becomes complex. To solve this problem, this paper proposes a multi-agent cooperative strategy learning method by combining transfer learning (TL) and traditional Q-learning. The proposed method is applied to the maze game and the experiments show that the proposed method outperforms the existing Q-learning methods in both iterations and performance.
Experiment of Cooperative Transportation using Multi-Robots by Multi-agent Deep Deterministic Policy Gradient

Cooperative transportations using many robots are able to support various tasks as compared with a transportation using a robot. However, cooperative transportations have been used infrequently in industrial applications due to the complexity of a formation change considering the avoidance of other robots and environments. In this paper, a control system to search robots’ paths for a cooperative transportation using a multi-agent deep deterministic policy gradient (MADDPG) is proposed. MADDPG is a deep reinforcement learning method specialized for a multi-agent system to determine the effective path for making the formation. The feature of the system, each robot finds a trajectory and moves autonomously for a cooperative transportation. The effectiveness of MADDPG is evaluated by an experiment result of a formation change for a cooperative transportation using multi-robots.
Adaptive Multi-Feature Fusion Visual Target Tracking Based on Siamese Neural Network with Cross-Attention Mechanism

We present an adaptive multi-feature fusion visual object tracking algorithm based on Siamese neural network with cross-attention mechanism, SiamAtten for short, which can effectively deal with large appearance changes, complex back-ground and interference. The proposed network consists of two parts. One is the full convolution feature extraction network based on cross-attention mechanism and the other is the region proposal generation network based on adaptive multi-feature fusion. The cross-attention mechanism is used in the first part to improve the response ability of feature extraction of the target. The adaptive feature fusion method is used in the second part to infer the target location in a step-by-step process and to get the robust region proposal by regression. Meanwhile, network parameters are reduced by using the depth-wise separable convolution, and the cross-attention mechanism is proposed in this paper can effectively enhance the target identification ability and elevate the robustness. Extensive experiments are carried out on three benchmark datasets and much advanced tracking results are obtained.
Decentralized Allocation of Geo-distributed Edge Resources using Smart Contracts

In the Internet of Things (loT) era, edge computing is a promising paradigm to improve the quality of service for latency sensitive applications by filling gaps between the loT devices and the cloud infrastructure. Highly geo-distributed edge computing resources that are managed by independent and competing service providers pose new challenges in terms of resource allocation and effective resource sharing to achieve a globally efficient resource allocation. In this paper, we propose a novel blockchain-based model for allocating computing resources in an edge computing platform that allows service providers to establish resource sharing contracts with edge infrastructure providers apriori using smart contracts in Ethereum. The smart contract in the proposed model acts as the auctioneer and replaces the trusted third-party to handle the auction. The blockchain-based auctioning protocol increases the transparency of the auction-based resource allocation for the participating edge service and infrastructure providers. The design of sealed bids and bid revealing methods in the proposed protocol make it possible for the participating bidders to place their bids without revealing their true valuation of the goods. The truthful auction design and the utility-aware bidding strategies incorporated in the proposed model enables the edge service providers and edge infrastructure providers to maximize their utilities. We implement a prototype of the model on a real blockchain test bed and our extensive experiments demonstrate the effectiveness, scalability and performance efficiency of the proposed approach.
Nodeguard: A Virtualized Introspection Security Approach for the Modern Cloud Data Center

This paper presents Nodeguard, a security approach for detecting and isolating misbehaving Virtual Machines (VMs) in multi-tenant virtualized cloud data centers, based on the Virtual Machine Introspection (VMI) monitoring primitives. Nodeguard employs a divide-and-conquer strategy that checks logical groups of VMs to ensure the efficiency of the detection mechanisms which opportunistically approaches a complexity of <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$\mathcal{O}(\log_{2}(n))$</tex> when there is a relatively low number of hostile VMs. This greatly enhances the algorithmic time complexity of the pro-posed security system compared to the <tex xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">$\mathcal{O}(n)$</tex> complexity achieved by the traditional VMI inspection strategy that checks each VM separately. The approach has been evaluated in a virtualized cloud environment using the Mininet network emulator.
Implementing Reading to Learn (R2L) Pedagogy to Help Indonesian Junior High School Students Generate News Report Text

The Reading to Learn (R2L) pedagogy, which requires preparing for reading, detailed reading, joint construction, and independent construction steps, was invented in Australia to assist Australian indigenous secondary school students in reading texts and finding useful information inside the texts. This one group pre-test and post-test design was aimed at unfolding the effectiveness of R2L pedagogy in helping the students in constructing well-structured news report texts. A total of 51 ninth-grade students from a junior high school, Bandung, Indonesia participated in the research. The students received the R2L pedagogy in four meetings within a month, excluding the pre-test and post-test.
Effective Classroom Management in English as a Foreign Language Classroom

Classroom management is an essential element of the teaching and learning process which determines the quality of instruction. This research aims to investigate the elements of classroom management which can be effectively applied in EFL classrooms. This study is a review research study, where the data were collected from 43 previously published materials, restricted to books, dissertations, and articles published in academic journal. The data were analysed using data condensation, data display and conclusion drawing. The results of this study show that there are three elements of classroom management, i.e. seating arrangements, engagement, and participation. The seating arrangement has three effective components including u-shaped, sitting in a group, and orderly row. Further, student engagement consists of cognitive, behavioural, academic, emotional, social, intellectual, physiological, affective and relational engagement approaches. Meanwhile, participation includes classroom talk, teacher talk, collaborative talk, exploratory talk, disputational talk, and learner-managed talk. Therefore, it is recommended that teachers utilize effective classroom management components based on the results of this study to improve the quality of instruction.
Humans in Empirical Software Engineering Studies: An Experience Report

The use of human validation in software engineering methods, tools, and processes is crucial to understanding how these artifacts actually impact the people using them. In this paper, we report our experiences on two methods of data collection we have used in software engineering empirical studies, namely online questionnaire-based data collection and in-person eye tracking data collection using eye tracking equipment. The design and instrumentation challenges we faced are discussed with possible ways to mitigate them. We conclude with some guidelines and our vision for the future in human-centric studies in software engineering.
Kuber: Cost-Efficient Microservice Deployment Planner

The microservice-based architecture - a SOA-inspired principle of dividing backend systems into indepen-dently deployed components that communicate with each other using language-agnostic APIs - has gained increased popularity in industry. Realistic microservice-based applications contain hundreds of services deployed on a cloud. As cloud providers typically offer a variety of virtual machine (VM) types, each with its own hardware specification and cost, picking a proper cloud configuration for deploying all microservices in a way that satisfies performance targets while minimizing the deployment costs becomes challenging. Existing work focuses on identifying the best VM types for recurrent (mostly high-performance computing) jobs. Yet, identifying the best VM type for the myriad of all possible service combinations and further identifying the optimal subset of combinations that minimizes deployment cost is an intractable problem for applications with a large number of services. To address this problem, we propose an approach, called Kuber, which utilizes a set of strategies to efficiently sample the neces-sary subset of service combinations and VM types to explore. Comparing Kuber with baseline approaches shows that Kuber is able to find the best deployment with the lowest search cost.
A Tool to check the Ownership of Solana's Smart Contracts

Solana is a blockchain platform with its own token, called SOL or Solana. As a blockchain network, Solana is a de-centralized public ledger for verifying and recording transactions. The Solana blockchain has smart contract capabilities. Unlike other blockchains, such as Ethereum, there is no repository or tool where to check for the source code of the smart contracts stored in the blockchain. These tools are crucial to increase the users&#x0027; trust in this type of technology. Indeed, one of the most important features of the blockchain is transparency, i.e. the possibility to see the source code of the program to use, or in which the users wish to invest. However, in the blockchains that support smart contracts, what is stored is not the source code of the smart contract written in a high-level program understandable to humans, but the bytecode, i.e. a low-level code made for the hardware to be executed. For some blockchains, such as Ethereum, there are different tools, such as integrated development environment (IDE), that allow to verify that the smart contracts&#x0027; source code corresponds to the bytecode installed on the nodes of the blockchain. Moreover, there are different repositories that collect smart contracts written in a high-level programming language and their corresponding bytecode. However, for the Solana blockchain, all these tools do not exist yet. The study proposes a web tool that allows verifying the ownership of a smart contract, i. e. the smart contracts&#x0027; source code written in a high-level programming language corresponds to the bytecode deployed in the Solana blockchain. Moreover, we have published smart contracts&#x0027; source code written in high-level programming via a public service that can be used by researchers, smart contract developers, and blockchain not-expert users.
Detect, Fix, and Verify TensorFlow API Misuses

The growing application of DL makes detecting and fixing defective DL programs of paramount importance. Recent studies on DL defects report that TensorFlow API misuses represent a common class of DL defects. However to effectively detect, fix, and verify them remains an understudied problem. This paper presents the TensorFlow API misuses Detector And Fixer (TADAF) technique, which relies on 11 common API misuses patterns and corresponding fixes that we extracted from StackOverftow. TADAF statically analyses a TensorFlow program for identifying matches of any of the 11 patterns. If it finds a match, it automatically generates a fixed version of the program. To verify that the misuse brings a tangible negative effect, TADAF reports functional, accuracy, or efficiency differences when training and testing (with the same data) the original and fixed versions of the program. Our preliminary evaluation on five GitHub projects shows that TADAF detected and fixed all the API misuses.
An Exploratory Study on Self-Fixed Software Vulnerabilities in OSS Projects

Remediation to a software vulnerability can be accomplished either by the developer who introduced it or by a different one. In this context, we refer to a self-fixed vulnerability when the fixing is carried out by the developer who introduced it. Previous research demonstrated that a developer who introduces a bug is also the best candidate to fix it. However, as vulnerabilities conceptually differ from non-security bugs and specific skills and knowledge are required for solving them, it is unclear if the previous finding also applies to vulnerabilities or specific vulnerability types. To fill this gap, in this paper, we investigate the diffusion of self-fixed vulnerabilities within software projects, the types of vulnerabilities that are more prone to self-fixing, and the time required to solve self-fixed vulnerabilities compared to non-self-fixed ones. Specifically, we analyzed 1,752 commits related to C and PHP open-source projects aimed at fixing (or self-fixing) vulnerabilities spanning 17 different types of software weaknesses. The results of our study show that 20.55&#x0025; of the considered vulnerabilities in C projects and 36.46&#x0025; of the considered vulnerabilities in PHP projects are self-fixed. In addition, the average remediation time of self-fixed vulnerabilities is generally shorter than non-self-fixed ones. In particular, in C projects, self-fixed integer overflow vulnerabilities are patched about 5 times shorter than non-self-fixed ones, while vulnerabilities related to improper calculation or conversion of numbers are generally fixed faster by other developers. Similarly, in PHP projects, CSRF vulnerabilities tend to be patched in a shorter time when they are self-fixed, while unauthorized access vulnerabilities are likely repaired faster by other developers. Our results can help both researchers and practitioners identifying the best candidates to solve specific vulnerability bugs.
What really is software design?

Software design has been considered an integral part of software development for over fifty years. Over this time, software developers have improved how software systems are designed and have determined which designs lead to different desired characteristics in the systems built. In parallel, software engineering researchers have studied the processes software developers use to design and have considered many aspects of software design, such as how to represent a design. Given all of the practical experience gained and all of the study about software design, you might expect that there is a sophisticated common understanding about what software design is and is not. Unfortunately, such a common understanding is not evident in the literature. To investigate how software design is perceived, we conducted an interview study involving 16 participants representing both academia and industry. Our analysis of the interview transcripts reveals five main themes: 1) design cuts across multiple development phases and involves multiple people, 2) design involved decision making, 3) design is impacted by context, 4) design involves communication and 5) good design requires experience. We discuss the implications of these themes and describe what can be done to reach a more commonly shared idea of what design represents.
How and Why Developers Migrate Python Tests

Nowadays, Python developers can rely on two major testing frameworks: unittest and pytest. Due to the benefits of pytest (e.g., fixture reuse), several relevant projects in the Python ecosystem have migrated from unittest to pytest. Despite being performed by the Python community, we are not yet aware of how systems are migrated from unittest to pytest nor the major reasons behind the migration. In this paper, we provide the first empirical study to assess testing framework migration. We analyze how and why developers migrate from unittest to pytest. We mine 100 popular Python systems and assess their migration status. We find that 34&#x0025; of the systems rely on both testing frameworks and that Python projects are moving to pytest. While some systems have fully migrated, others are still migrating after a long period, suggesting that the migration is not always straightforward. Overall, the migrated test code is smaller than the original one. Furthermore, developers migrate to pytest due to several reasons, such as the easier syntax, interoperability, easier maintenance, and fixture flexibility/reuse, however, the implicit mechanics of pytest is a concern. We conclude by discussing practical implications for practitioners and researchers.
Flexible semi-automatic support for type migration of primitives for C/C++ programs

Type systems are crucial tools in the hands of developers to ensure an increased level of soundness to their programs, make them safer, and guard against bugs. However, in practice, the type system is not always used to its full capability, and trade-offs are made. The effects range from hindered code comprehension and wasted development effort to financial damages and even the risk of loss of life. Various widely used programming languages, such as C++, Java, Python, and Rust, are yet to implement constrained types as a language feature. While the usage of user-defined types is common in modern languages that support such elements, developers often resort to having their variables use the most common, fundamental, built-in or library types, such as int or string, and not encode invariants into the type system. In this paper, we describe a flexible, incremental, semi-automated type migration approach that allows transitioning from the use of fundamental coarse types to strong types. Previously, well-scaling type migration methods were restricted and required the existence of an already well-defined destination type. In our case, the new strong type to be created is not yet defined, but the required interface is discovered via static analysis. As refactoring tools would cease to function if the code is changed textually to a version that refers undefined symbols, a more granular approach was needed. In addition, our proposed method allows us to discover the mixing of conceptually distinct types during development while the original program continues to function.
ClusterCommit: A Just-in-Time Defect Prediction Approach Using Clusters of Projects

Existing Just-in-Time (JIT) bug prediction techniques are designed to work on single projects. In this paper, we present ClusterCommit, a JIT bug prediction approach geared towards clusters of projects that share common libraries and functionalities. Unlike existing techniques, ClusterCommit trains a machine learning model by combining commits from a set of projects that are part of a larger cluster. Once this model is built, ClusterCommit can be used to detect buggy commits in each of these projects. When applying ClusterCommits to 16 projects that revolve around the Hadoop ecosystem and 10 projects of the Hive ecosystem, the results show that ClusterCommit achieves an F1-score of 73&#x0025; and MCC of 0.44 for both clusters. These preliminary results are very promising and may lead to new JIT bug prediction techniques geared towards projects that are part of a large cluster.
Identifying Software Engineering Challenges in Software SMEs: A Case Study in Thailand

Small and medium-sized software enterprises (SSMEs) are a vital part of emerging markets. Due to their size, they are not capable of adopting advanced software engineering techniques or automated software engineering tools in the same way large and ultra-large companies are. We study the software engineering challenges in SSMEs in Thailand, an emerging market in software development, using semi-structured interviews with four SSMEs. After performing a thematic analysis of the interview transcripts, we found a number of common challenges such as lack of testing, code-related issues, and inaccurate effort estimation. We observed that in order to introduce advanced automated software engineering tools and techniques, SSMEs need to adopt contemporary best practices in software engineering like automated testing, continuous integration and automated code review. Moreover, we suggest that software engineering research engage with SSMEs to enable them to improve their knowledge and adopt more advanced software engineering practices.
Extracting Vulnerabilities from GitHub Commits

Open-source libraries save developers time and effort by providing them access to pre-written functions, objects, and methods. The adoption of such libraries follows the current trend of more widespread use of open-source software and components. However, like proprietary software, open-source software can also suffer from defects that can be exploited by attackers. Many of these vulnerabilities have been identified and documented and are stored in Common Vulnerabilities and Exposures (CVE) databases maintained by entities such as NIST. Developers of these open-source components have a responsibility to inform their users of the vulnerabilities that exist in their releases and of the patches that fix these vulnerabilities. Consistent documentation of CVEs is a prerequisite for mitigating these vulnerabilities, especially if an automated approach is taken. This study investigates how well-documented are the patches both in the CVE database, and within the Github commits of C language open-source libraries. The results show that a significant number of CVEs in the NIST database do not mention the existence of patches and that only a small subset of the libraries looked at document CVEs in their commits. This paper comes to the conclusion that mutually agreed upon standards when it comes to CVE documentation should be adopted by both developers of open-source software and the entities that update and maintain CVE databases.