International Journal of Software Engineering and Knowledge Engineering

Resilience is the property that enables a system to continue operating properly when one or more faults occur. Nowadays, as software systems become more and more complex, their hardware execution platforms also become more heterogenous with larger scale. Software systems may fail due to some faults such as node breakdown, communication failure, or data processing failure. In this paper, we propose a ring-based resilience mechanism, which implements fault detection and recovery. (1) To solve the problem that the central server may have high burden of network traffic, we design a ring-based heartbeat algorithm for crash fault detection. (2) We also design a light-weight recovery mechanism to recover from crash faults as compared with the current system-specific mechanisms. To evaluate our mechanism, we use a 3D-online game system as a case study. By injecting faults, we test the effectiveness and overhead of the proposed mechanism. Compared with other mechanisms, the experimental results show that our mechanism can support resilience very well and is better at dealing with the crash fault caused by high cluster workload with acceptable overhead.

Due to the increasing accessibility of online data and the availability of thousands of documents on the Internet, it becomes very difficult for a human to review and analyze each document manually. The sheer size of such documents and data presents a significant challenge for users. Providing automatic summaries of specific topics helps the users to overcome this problem. Most of the current extractive multi-document summarization systems can successfully extract summary sentences; however, many limitations exist which include the degree of redundancy, inaccurate extraction of important sentences, low coverage and poor coherence among the selected sentences. This paper introduces an adaptive extractive multi-document generic (EMDG) methodology for automatic text summarization. The framework of this methodology relies on a novel approach for sentence similarity measure, a discriminative sentence selection method for sentence scoring and a reordering technique for the extracted sentences after removing the redundant ones. Extensive experiments are done on the summarization benchmark datasets DUC2005, DUC2006 and DUC2007. This proves that the proposed EMDG methodology is more effective than the current extractive multi-document summarization systems. Rouge evaluation for automatic summarization is used to validate the proposed EMDG methodology, and the experimental results showed that it is more effective and outperforms the baseline techniques, where the generated summary is characterized by high coverage and cohesion.

Software development is a continuous process that usually starts with analyzing the system requirements and proceeds with design, implementation, testing, and maintenance. Regardless of how good an initial design was achieved, quality of source code tends to decay throughout the development process as software evolves. One of the main contributing factors to this degradation of initial quality can be considered as maintenance operations, for instance to enhance performance or other attributes of the system or to fix newly discovered bugs. For such large software systems, development process also requires reusing existing components which may have been implemented by others. Hence, a comprehensible piece of source code, e.g. one that conveys its message about what it is trying to do easily with understandable and modular implementation, significantly reduces time and effort not only for the implementation phase of the development lifecycle; but also for testing and maintenance phases. In other words, while software decay is inevitable, software comprehension plays a determining role in the total cost and effectiveness of both implementation phase and maintenance phase. Therefore, developers should strive to create software components with modular structure and clearer implementation to reduce the development cost. In this paper, we are interested in finding ways to successfully decompose long methods (those with poor initial implementation and/or decayed overtime) into smaller, more comprehensible and readable ones. This decomposition process is known as extract method refactoring and helps to reduce the overall cost of development. Most of the existing refactoring tools require users to select the code fragments that need to be extracted. We introduce a novel technique for this refactoring. This technique seeks refactoring opportunities based on variable declarations and uses confining fully extractable code regions without any user intervention. We implemented this technique as an analysis and visualization tool to help a user identify candidate code fragments to be extracted as separate methods. With this automation tool, developers do not have to manually inspect a foreign code base to select code fragments for refactoring. Through the visual representations we provide, one can observe all suggested refactoring effectively on large scale software systems and decide whether a particular refactoring should be applied. To show the effectiveness of our techniques, we also provide some case studies conducted using this tool and technique both on our own project’s source code and other open-source projects.

With the popularity of social networks, privacy issues with regard to publishing social network data have gained intensive focus from academia. We analyzed the current privacy-preserving techniques for publishing social network data and defined a privacy-preserving model with privacy guarantee $k$. With our definitions, the existing privacy-preserving methods, $k$-anonymity and randomization can be combined together to protect data privacy. We also considered the privacy threat with label information and modify the $k$-anonymity technique of tabular data to protect the published data from being attacked by the combination of two types of background knowledge, the structural and label knowledge. We devised a partial $k$-anonymity algorithm and implemented it in Python and open source packages. We compared the algorithm with related $k$-anonymity and random techniques on three real-world datasets. The experimental results show that the partial $k$-anonymity algorithm preserves more data utilities than the $k$-anonymity and randomization algorithms.

Developers participating in an open source software (OSS) project make contributions to the project at different levels and aspects. Their underlying technical interests, expertise, and working habits are indirectly delineated by their personal contributions. This paper is to discover the individualized contribution features of developers by latent Dirichlet allocation (LDA) approach. Dominant latent topics of each developer and the corresponding topic coverage degree are extracted from the source codes committed to the project repository, and such topic model is validated to be feasible for representing the individualized contribution features by statistics tests. Four types of topic evolution patterns are observed from the commit history of a developer. Temporal locality is partially exhibited in the topic evolution but there usually exhibit drastic changes between time-adjacent contributions of a developer. Respective proportions of the four evolution patterns and the degree of temporal locality in the topic evolution delineate a developer’s individualized working habits in the time dimension. It is also proved that the correlation among the topic models of different developers is not equivalent to the real social collaborations among them. The outcome of this study would help OSS project coordinators get deep understanding on the work preferences and behavioral patterns of team members, thus facilitate project coordination activities such as task allocations.

This paper addresses the design problem of providing cognitive support for workflow systems in software development. Software development is demanding knowledge work that requires creativity and adaptability to changing requirements and situations. This type of work involves cognitive actions that require substantial support in several forms in order to address needs such as collaboration, communication, knowledge management, awareness and transparency, and the coordination and structuring of the development processes. The literature and our empirical results show that there is a lack of cognitive support in current workflow models. Hence, we identify the need for a design theory for cognitive workflow systems (CWS). In this paper, such a theory is presented. The proposed design theory for CWS is validated through an action research intervention. This design theory has important implications from both research and practical perspectives. The results will help developers in their daily work, enhance the efficiency of the development processes, and facilitate decision-making activities.