This paper studies the Time-Critical Cooperative Delivery with Unknown Demands (TCDUD) problem, developed from the well-studied Capacitated Vehicle Routing Problem with Stochastic Demands (CVRPSD), that corresponds to emergency situations requiring 1) time-critical delivery; 2) unknown demands; and 3) cooperative delivery. We formulate the problem as a multi-agent sequential decision problem with a Collaborative Semi-Markov Decision Process (CSMDP) model in which timecritical delivery is urged by the reward function that takes both the amount and the time of fulfilled demands into account. Unlike traditional CVRPSD, we do not include a priori information about a customer's demand in problem definition, and require vehicles to visit a customer before its demand is revealed. A Transformer-based multi-agent reinforcement learning approach, namely MAODN, is devised to learn online policies that direct the vehicles to visit the customers, and perform timely delivery in a cooperative manner. MAODN utilizes a demand updater to accommodate online updates about customers' demands from the vehicles during delivery. Vehicles then make cooperative decisions via individual policy networks, leveraging the fleet state provided by the state aggregator. Experiment results suggest that our approach outperforms the baseline by at least 27.8% and demonstrates better robustness.

This study addresses the Min-Max Multiple Traveling Salesmen Problem (m3-TSP), which aims to coordinate tours for multiple salesmen such that the length of the longest tour is minimized. Due to its NP-hard nature, exact solvers become impractical under the assumption that P ≠ NP. As a result, learning-based approaches have gained traction for their ability to rapidly generate high-quality approximate solutions. Among these, two-stage methods combine learning-based components with classical solvers, simplifying the learning objective. However, this decoupling often disrupts consistent optimization, potentially degrading solution quality. To address this issue, we propose a novel two-stage framework named Generate-and-Split (GaS), which integrates reinforcement learning (RL) with an optimal splitting algorithm in a joint training process. The splitting algorithm offers near-linear scalability with respect to the number of cities and guarantees optimal splitting in Euclidean space for any given path. To facilitate the joint optimization of the RL component with the algorithm, we adopt an LSTM-enhanced model architecture to address partial observability. Extensive experiments show that the proposed GaS framework significantly outperforms existing learning-based approaches in both solution quality and transferability.

Resolving issue reports is essential to the development of opensource software, which helps developers collaborate, communicate, and fix bugs, thereby ensuring the quality and functionality of the software.While previous studies focus on the static factors that impact the issue resolution time, few of them investigate the issue resolution patterns.In this paper, we propose an approach based on discriminative sequential pattern mining to discover the patterns in issue resolution processes with different efficiency.We devise an issue resolution process modeling method, which adds events' time interval values to the activity sequences, thus providing a richer understanding of the issue resolution.And we find that there are several typical patterns in the issue resolution process with different lifetimes.To guide developers in prioritizing issues and allocating resources, we propose a prediction model and a recommendation approach based on the mined patterns.We extract features from patterns and construct random forest classifier models to predict the resolution speed of issues (fast, normal or slow).The accuracy of our models reaches 70% or higher in most repositories and mixed repositories' data, indicating a great performance.Finally, we recommend actions to users participating in ongoing issues at an early stage based on the mined patterns, thus improving the efficiency of issue resolution process.

Abstract Due to the high cost of repairing defective programs, many researches focus on automatic program repair (APR). In recent years, the new trend of APR is to apply neural networks to mine the relations between defective programs and corresponding patches automatically, which is known as neural program repair (NPR). The community, however, ignores some important properties that could impact the applicability of NPR systems, such as robustness. For semantic‐identical buggy programs, NPR systems may produce totally different patches. In this paper, we propose an evaluation tool named RobustNPR, the first NPR robustness evaluation tool. RobustNPR employs several mutators to generate semantic‐identical mutants of defective programs. For an original defective program and its mutant, it checks two aspects of NPR: (a) Can NPR fix mutants when it can fix the original defective program? and (b) can NPR generate semantic‐identical patches for the original program and the mutant? Then, we evaluate four SOTA NPR models and analyze the results. From the results, we find that even for the best‐performing model, 20.16% of the repair success is unreliable, which indicates that the robustness of NPR is not perfect. In addition, we find that the robustness of NPR is correlated with model settings and other factors.

Studies on the OSS communities have shown that financial supports are critical to OSS developers and projects to maintain their progress and sustainability. However, there were few developers being paid directly for maintaining OSS projects in the past. The GitHub Sponsors program that brings financial supports to the general OSS developers in GitHub-the world's largest OSS platform may make a difference on this situation in the future. In this paper, we present a data set on GitHub Sponsors and conduct a data-driven study to analyze the participants of the program and the impact of sponsorships to developers' activities and their projects' outcomes and qualities. The results of our survey suggest that most developers state they will contribute more with sponsorships and provide some privilege for their sponsors. And through quantitative study, we find that developers make more contributions on GitHub after they got/offered sponsorships. Moreover, gaining sponsorship also has a weakly positive impact on developers' collaborators that did not get sponsorship. And not only developers, but their own or contributed projects also can be motivate by sponsorships. Our findings are useful to the community by understanding the impact of sponsorships on users' activities and projects' progress and sustainability, and helping the managers to improve the current financial support mechanism.

Existing studies in both psychology and software engineering have shown the importance of emotions in complex learning and programming tasks. For students who are learning to program, rich emotions are experienced which can provide valuable feedback to their teachers. To accurately model stu-dents' emotions, this paper adopts the well-recognized model of emotions during complex learning that involves four states: engaged, confused, frustrated, and bored. To perform continuous estimation of students' emotions in a non-intrusive manner, this paper proposes to track students' programming behavior and estimate their corresponding emotional states. Compare to the existing approaches on acquiring the students' emotional states with self-reports or bio-sensors, the proposed approach is more feasible in conducting real-world, and large-scale studies for not requiring extensive human interventions or additional devices. Evaluated using data collected from a real-world course project, the proposed approach is showed to be promising for achieving an estimation accuracy of 72.06 % for the above four emotional states. As an enabling technology, the proposed is potentially useful in supporting many applications and improve the quality of programming education in computer science.

As human beings take actions with a goal in mind, we could predict the following action of a person depending on his previous actions. Inspired by this, after collecting and analyzing more than 13,000 repositories with 441,290 Python source code files from the Internet, we find the actions expressed in code are in the developers’ high-level programming language statements.

Traceability recovery allows developers to extract and comprehend the trace links among software artifacts (e.g., requirements and code). These trace links can provide important support to software maintenance and evolution tasks. Information Retrieval (IR) is now widely accepted as the key technique of semi-automatic tools to recover candidate trace links based on textual similarities among artifacts. However, the vocabulary mismatch problem between different artifacts hinders the performance of these IR-based approaches. Thus, a growing body of enhancing strategies were proposed based on user feedback. They allow to adjust the textual similarities of candidate links after users accept or reject part of these links. Recently, several approaches successfully used this strategy to improve the performance of IR-based traceability recovery. However, these approaches require a large amount of user feedback, which is infeasible in practice. In this paper, we propose to improve IR-based traceability recovery by introducing only a small amount of user feedback into the closeness analysis on call and data dependencies in code. Specifically, our approach iteratively asks users to verify a chosen candidate link based on the quantified functional similarity for each code dependency (called closeness) and the generated IR values. The verified link is then used as the input to re-rank the unverified candidate links. An empirical evaluation based on five real-world systems shows that our approach can outperform four baseline approaches by using only a small amount of user feedback.

Cloud computing is a suitable platform to execute the deadline-constrained scientific workflows which are typical big data applications and often require many hours to finish. Moreover, the problem of energy consumption has become one of the major concerns in clouds. In this paper, we present a cost and energy aware scheduling (CEAS) algorithm for cloud scheduler to minimize the execution cost of workflow and reduce the energy consumption while meeting the deadline constraint. The CEAS algorithm consists of five sub-algorithms. First, we use the VM selection algorithm which applies the concept of cost utility to map tasks to their optimal virtual machine (VM) types by the sub-makespan constraint. Then, two tasks merging methods are employed to reduce execution cost and energy consumption of workflow. Further, In order to reuse the idle VM instances which have been leased, the VM reuse policy is also proposed. Finally, the scheme of slack time reclamation is utilized to save energy of leased VM instances. According to the time complexity analysis, we conclude that the time complexity of each sub-algorithm is polynomial. The CEAS algorithm is evaluated using Cloudsim and four real-world scientific workflow applications, which demonstrates that it outperforms the related well-known approaches.

The concept of complex event processing (CEP) and complex-event-aware service have been extensively studied to retrieve relevant information from massive amount of realtime streaming events. In mobile environment, the Mobilityaware CEP (MCEP) system was proposed to address the issue of synchronization problem between different query ranges and MCEP operators. We noticed that MCEP systems lack the ability to process event in parallel and scale out when system load is high. In this paper, we proposed a parallel architecture for MCEP. The architecture can handle the synchronization problem and guarantee the correctness of event processing result. We also proposed a scaling strategy that can automatically scale out operators while ensures semantic transparency. An empirical evaluation based on up to 10 ViMs demonstrated that our approach is able to achieve higher throughput while keeping the MCEP synchronization mechanism valid.

Software frameworks are widely used in application development. But APIs of a framework may change when it evolves to accommodate new feature requests or to fix bugs. Those changes may break existing client programs of the framework, so client programs need to be migrated to the updated release when the framework evolves. Some technologies (e.g. call dependency analysis) have been proposed to find replacement APIs between the old and new framework releases. However, existing approaches based on call dependency analysis take whole method body as an analysis unit. The context in which a method is called is ignored. In this paper, we present a fine-grained approach named AUC-Miner to infer API usage change rules between two releases of the framework. To take method invocation context into consideration, we propose an approach to get more precise call relationship changes by code splitting. We also analyze indirect method invocations to re-fine call dependency analysis. After elaborating API usage change transactions, we adopt frequent item-set mining to generate API replacement rules. Text similarity and some heuristics to identify evolution of root methods are also applied in the mining progress. The evaluation of AUC-Miner on three popular frameworks shows that its precision is higher than basic call dependency analysis and another API replacement recommendation tool named AURA.

Information Retrieval (IR) identifies trace links based on textual similarities among software artifacts. However, the vocabulary mismatch problem between different artifacts hinders the performance of IR-based approaches. A growing body of work addresses this issue by combining IR techniques with code dependency analysis such as method calls. However, so far the performance of combined approaches is highly dependent to the correctness of IR techniques and does not take full advantage of the code dependency analysis. In this paper, we combine IR techniques with closeness analysis to improve IR-based traceability recovery. Specifically, we quantify and utilize the “closeness” for each call and data dependency between two classes to improve rankings of traceability candidate lists. An empirical evaluation based on three real-world systems suggests that our approach outperforms three baseline approaches.

The aligning of event logs with process models is of great significance for process mining to enable conformance checking, process enhancement, performance analysis, and trace repairing. Since process models are increasingly complex and event logs may deviate from process models by exhibiting redundant, missing, and dislocated events, it is challenging to determine the optimal alignment for each event sequence in the log, as this problem is NP-hard. Existing approaches utilize the cost-based A* algorithm to address this problem. However, scalability is often not considered, which is especially important when dealing with industrial-sized problems. In this paper, by taking advantage of the structural and behavioral features of process models, we present an efficient approach which leverages effective heuristics and trace replaying to significantly reduce the overall search space for seeking the optimal alignment. We employ real-world business processes and their traces to evaluate the proposed approach. Experimental results demonstrate that our approach works well in most cases, and that it outperforms the state-of-the-art approach by up to 5 orders of magnitude in runtime efficiency.

Event logs are of paramount significance for process mining and complex event processing. Yet, the quality of event logs remains a serious problem. Missing events of logs are usually caused by omitting manual recording, system failures, and hybrid storage of executions of different processes. It has been proved that the problem of minimum recovery based on a priori process specification is NP-hard. State-of-the-art approach is still lacking in efficiency because of the large search space. To address this issue, in this paper, we leverage the technique of process decomposition and present heuristics to efficiently prune the unqualified sub-processes that fail to generate the minimum recovery. We employ real-world processes and their incomplete sequences to evaluate our heuristic approach. The experimental results demonstrate that our approach achieves high accuracy as the state-of-the-art approach does, but it is more efficient.

Web service composition is the process of automatically arranging multiple services into workflow so as to supply complex user needs. With the rapid increase in the number of Web services, it's beyond the human ability to generate the composition result manually, which further indicates the importance of automatic service composition. Besides, it's essential that not only functional needs but also non-functional requirements need to be satisfied in the composition process. The QoS-aware automatic service composition has received considerable attention and made a lot of progress, but it's rare to consider the QoS correlations which are essential in actual application. Thus, in this paper, we take QoS correlations between services into account and propose a novel approach to address the QoS-aware automatic service composition problem. Evaluations show that, compared to the state of the art, our method can address QoS correlations between services and generate the service composition with optimal QoS values more efficiently.

Requirements traceability benefits many software engineering activities, such as change impact analysis and risk assessment. However, these activities require complete and correct traceability links which is not trivial, making traceability assessment an important field of study. In recent years, requirements traceability research has focused on using call dependencies within source code to understand how code properties contribute to the implementation of a requirement and to assess whether traceability links are correct and complete. These approaches largely ignore the role of existing data dependencies within the source code. That is, methods may never call each other, but may still depend upon another by sharing data. We identified five research questions and validated them on five software systems, covering 4 to 72 KLOC. We found that data dependencies are as relevant as call dependencies for assessing requirements traceability. Even more interesting, our analyses show that data dependencies complement call dependencies in the assessment. These findings have strong implications on code understanding, including trace capture, maintenance, and validation techniques. Copyright © 2015 John Wiley & Sons, Ltd.

It is common practice for requirements traceability research to consider method call dependencies within the source code (e.g., fan-in/fan-out analyses). However, current approaches largely ignore the role of data. The question this paper investigates is whether data dependencies have similar relationships to requirements as do call dependencies. For example, if two methods do not call one another, but do have access to the same data then is this information relevant? We formulated several research questions and validated them on three large software systems, covering about 120 KLOC. Our findings are that data relationships are roughly equally relevant to understanding the relationship to requirements traces than calling dependencies. However, most interestingly, our analyses show that data dependencies complement call dependencies. These findings have strong implications on all forms of code understanding, including trace capture, maintenance, and validation techniques (e.g., information retrieval).

The aim of process mining is to rediscover the process model from the event log which is recorded by the information system. Although the omnipresence of the event logs in information system, rarely part of them are considered to analyze the processes. In this paper, we present a new mining algorithm based on the event type we defined. This algorithm not only can detect all of the SWF-nets and short-loops, but also can directly detect the implicit dependency. Because we can obtain more task information from the event log, we can deal with a wider subclass of WF-nets with the algorithm we have presented.

WS-BPEL processes can facilitate service discovery when the services have multiple interfaces in certain order. Current approaches derive the abstract WS-BPEL processes directly from the corresponding executable ones by hiding or omitting the internal activities. However, these simple approaches may prevent the services from being found by valuable potential partners at service discovery stage. To address this problem, we propose a novel approach to refactoring the executable and abstract WS-BPEL processes for service discovery. We show the application of our approach through a typical travel agency service.

The concept of aspect-orientation allows for modularizing crosscutting concerns as aspect modules. Aspect-orientation originally has emerged at the programming level, now it stretches over other development phases such as design phase. Aspect-oriented modeling is important for the aspect-oriented design, since the inaccuracies inherent in aspect-oriented design can be detected by the model, which can help the designers correct the software design. This paper presents a Petri net-based approach to support aspect-oriented modeling, for Petri net is a good formalism which can provide the foundations for modeling software and simulating its execution. First, software systems are modeled as aspect nets and base net, then woven mechanism is given to compose the aspect nets and base net. There are order constraints and aspect dependencies among the aspects that supposed on the same join point, and there also may exist conflict relations. The above problems are considered in our approach, and a solution is given by analyzing the structure of the woven net to detect such conflicts.

The value-based software process (VBSP) is gaining more and more attention. However, the quantitative analysis techniques for VBSPs could not closely follow up the fast developing paces of the modeling techniques. In this paper, we proposes a decision-based stochastic extension of object petri nets (OPN) to resolve the issues. OPNs are well suited for modeling VBSPs and stochastic object petri nets (SOPN) combine the benefits of OPNs and the stochastic theory. The decision-based stochastic object petri net (DB-SOPN) model is economics driven and links value creation with decision making, multi-stakeholder satisfying, and risk management. It includes two levels: the high level models the guideline of the software process life cycle; and the low-level represents the different stakeholder's perspectives of the process. Some activities of a process have candidate policies that will produce different value reward. Our model simulates the entire software process, and compares various combinations of candidate policies to make the value reward of the process maximum.

Commercial organizations increasingly need software processes sensitive to business value, quick to apply, and capable of early analysis for subprocess consistency and compatibility. This paper presents experience in applying a lightweight synthesis of a Value-Based Software Quality Achievement (VBSQA) process and an Object-Petri-Net-based process model (called VBSQA-OPN) to achieve a manager-satisfactory process for software quality achievement in an on-going ERP software project in China. The results confirmed that 1) the application of value-based approaches was inherently better than value-neutral approaches adopted by most ERP software projects; 2) the VBSQA-OPN model provided project managers with a synchronization and stabilization framework for process activities, success-critical stakeholders and their value propositions; 3) process visualization and simulation tools significantly increased management visibility and controllability for the success of software project.

PSEE (Process-centered Software Engineering Environment) can manage and monitor software process. Software process modeling language is a core element in PSEE system. Due to the particularity and the complexity, software process model includes multi-views: activity view, product view and role view, which should be considered in modeling software process. Based on the similarity between multi-view software process modeling and object Petri nets, this paper proposes the MOPN-SP-net model which is a multi-view software process model based on multi-object Petri nets. The model includes twolevel models: system net and object net. A multi-view paradigm including activity views and product views is provided. Activity views are described by system nets and product views are described by object nets. MOPN-SP-net includes multi-views of software process model, which is characterized with clearer hierarchy, simpler structure, and more extendibility.

Open service gateway initiative (OSGi), a service-oriented component model which follows the concepts of service-oriented programming, significantly reduces the time and complexity to construct applications by registering and discovering services. However, this mechanism focusing on the interfaces and static properties of related services, ignores the behavior of the services, let alone the runtime errors caused by behavior inconsistency. In addition to the related theory of service behavior model and behavior consistency relation of single services in service discovery and substitution, this article defines coordination protocol, composite service and behavior consistent service coordination to handle the applications built on multiple services. On the top of OSGi, we propose a feasible middleware architecture called SOBECA, which includes a runtime environment and a development toolkit to facilitate the development of service behavior consistent applications.

Software coordination is central to the construction of large-scale high-performance distributed applications with software services scattered over the decentralized Internet. In this paper, a new mobile-agent-based architecture is proposed for the utilization and coordination of geographically distributed computing resources. Under this architecture, a user application is built with a set of software agents that can travel across the network autonomously. These agents utilize the distributed resources and coordinate with each other to complete their task. This approach’s advantages include the natural expression and flexible deployment of the coordination logic, the dynamic adaptation to the network environment and the potential of better application performance. This coordination architecture, together with an object-oriented hierarchical parallel application framework and a graphical application construction tool, is implemented in the HOOPE environment, which provides a systematic support for the development and execution of Internet-based distributed and parallel applications in the petroleum exploration industry.