Jian Zhai

An algebraic approach for managing inconsistencies in software processes

To produce quality software and evolve them in an economic and timely fashion, enactable software process models are used for regulating development activities with the support of Process-Centered Software Engineering Environments (PCSEEs). However, due to the dynamically changing development environment, the developers do not always follow the process model in presence of unforeseen situations. As human with creativity and variant nature, each developer has his or her own way of doing development that may not be allowed by the process model. As a result, various inconsistencies arise in software processes and then the authority of the process model will be undermined. In this paper, we propose an algebraic approach to promote the efficient management of inconsistencies. With the approach, potential inconsistencies can be precisely detected and valuable diagnostic information is available to help process designers efficiently locate the detected inconsistencies. The effectiveness of the approach is demonstrated by experimenting it on an example process.

A vertex centric parallel algorithm for linear temporal logic model checking in Pregel

Linear Temporal Logic (LTL) Model Checking is a very important and popular technique for the automatic verification of safety-critical hardware and software systems, aiming at ensuring their quality. However, it is well known that LTL model checking suffers from the state explosion problem, often leading to insurmountable scalability problems when applying it to real-world systems. While there has been work on distributed algorithms for explicit on-the-fly LTL model checking, these are not sufficiently scalable and capable of tolerating faults during computation, significantly limiting their usefulness in huge cluster environments. Moreover, implementing these algorithms is generally viewed as a very challenging, error-prone task. In this paper, we instead rely on Pregel, a simple yet powerful model for distributed computation on large graphs. Pregel has from the start been designed for efficient, scalable and fault tolerant operation on clusters of thousands of computers, including large cloud setups. To harness Pregels power, we propose a new vertex centric distributed algorithm for explicit LTL model checking of concurrent systems. Experimental results illustrate feasibility and scalability of the proposed algorithm. Compared with other distributed algorithms, our algorithm is more scalable, reliable and efficient. We propose a new vertex centric distributed algorithm for LTL model checking.Algorithm is designed for BSP model and can be implemented in Pregel.The whole model checking procedure can be highly paralleled by BFS.Our algorithm is more scalable, reliable, efficient and expressive.Our proposed algorithm opens the door to reliable model checking implementations.

On mobility of software processes

In this paper, the mobility of software processes is proposed as a novel concept. It is defined as the structural change in a software process resulting from interactions among linked process elements. The concept addresses the essential change in a software process which brings a high variability and unpredictability to process performance. Three categories of the mobility that lead to the structural change are identified and expounded upon. A reference model for describing the concept is put forward based on the polyadic π-calculus. With the mobility of software processes, it is possible to design a new PCSEE and associated PML with increased flexibilities.

Stochastic Process Algebra Based Software Process Simulation Modeling

In recent years, simulation techniques that have been widely used in many other disciplines are being increasingly used in analyzing software processes. However, researchers from software process simulation community tend to build a separate new model with various technologies from traditional software models. This is partially because that software process simulation might take a completely different approach to describe a process under certain circumstances, for instance, a process being modeled as an overall system. Another reason is that traditional software process modeling methods can not provide simulation functions. The gap between traditional software process modeling and software process simulation modeling confined a wider application of simulation approach in the software engineering community. In this paper, we show the possibility of a simulation model being automatically derived from a traditional descriptive process model and thus one does not necessarily need to build a separate simulation model. By doing so, all information in the descriptive models can be reused.

Attacking the dimensionality problem of parameterized systems via bounded reachability graphs

Parameterized systems are systems that involve numerous instantiations of finite-state processes, and depend on parameters which define their size. The verification of parameterized systems is to decide if a property holds in its every size instance, essentially a problem with an infinite state space, and thus poses a great challenge to the community. Starting with a set of undesired states represented by an upward-closed set, the backward reachability analysis will always terminate because of the well-quasi-orderingness. As a result, backward reachability analysis has been widely used in the verification of parameterized systems. However, many existing approaches are facing with the dimensionality problem, which describes the phenomenon that the memory used for storing the symbolic state space grows extremely fast when the number of states of the finite-state process increases, making the verification rather inefficient. Based on bounded backward reachability graphs, a novel abstraction for parameterized systems, we have developed an approach for building abstractions with incrementally increased dimensions and thus improving the precision until a property is proven or a counterexample is detected. The experiments show that the verification efficiencies have been significantly improved because conclusive results tend to be drawn on abstractions with much lower dimensions.

Automated Process Quality Assurance for Distributed Software Development

As required or implicated in many process improvement or assessment models, Process Quality Assurance (PQA) is introduced to objectively evaluate actual software processes against applicable processes descriptions, standards, and procedures and to identify potential noncompliance. In a Distributed Software Development (DSD) environment, PQA is also an absolute necessity to ensure that each development site behaves as expected and high quality software is collaboratively developed. However, several problems brought by the distribution nature of DSD, such as different interpretations of standard processes among development sites, inconsistent criteria for identifying noncompliance, visibility into development activities of all sites being challenging, hidden conflicts or noncompliance for political issues within a site, substantial investment in setting up PQA teams in each site etc., can undermine the objectivity and effectiveness of PQA activities. To alleviate these problems, we introduce an approach in this paper that automates PQA activities for some routine checking tasks in a DSD environment. In the approach, a process model describing the actual software process is automatically built from each site’s repository and, then, the model is checked against logic formulae derived from a common checklist to detect noncompliance. Experiment results show that the approach is helpful to ensure that PQA activities in each site can be conducted according to the same guideline and the objectivity of PQA results is guaranteed.