Pankaj Jalote

A formal framework for on-line software version change

The usual way of installing a new version of a software system is to shut down the running program and then install the new version. This necessitates a sometimes unacceptable delay during which service is denied to the users of the software. An online software replacement system replaces parts of the software while it is in execution, thus eliminating the shutdown. While a number of implementations of online version change systems have been described in the literature, little investigation has been done on its theoretical aspects. We describe a formal framework for studying online software version change. We give a general definition of validity of an online change, show that it is in general undecidable and then develop sufficient conditions for ensuring validity for a procedural language.

On line software version change using state transfer between processes

The usual way of installing a new version of a piece of software is to shut down the running program and then install the new version. This necessitates a sometimes unacceptable delay during which service is denied to the users of the software. An on‐line software replacement system replaces parts of the software while it is in execution, thus eliminating the shutdown. In this paper, we describe a system for on‐line software version change for software written in the C language. When the change is initiated by the user, the system instantiates a new process with the new version of the software, transfers state from the old process to the new one at an appropriate time, and transfers the control to the new process. The user sees a minimal delay in this switchover.

An Experimental Evaluation of the Effectiveness and Efficiency of the Test Driven Development

Test driven development (TDD) is an approach for developing programs incrementally by first writing tests and then writing enough code to satisfy them. Though there have been some experiments for evaluating TDD on smaller scope, its impact on a larger scope of program development activities needs to be investigated. In this work, we evaluate the impact of TDD on various program development activities like designing, coding, and testing, through a controlled experiment where we compare it with the conventional way of developing the code. In a single-factor block design, two groups of students developed two moderately sized programs following the two development-styles under study. Our results suggest that TDD helps in reducing overall development effort and improving developers productivity whereas the code quality seems to be affected by the actual testing efforts applied during a development-style.

Assigning tasks in a 24-hour software development model

With the advent of globalization and the Internet, the concept of global software development is gaining ground. The global development model opens up the possibility of 24-hour software development by effectively utilizing the time zone differences. To harness the potential of the 24-hour software development model for reducing the overall development time, a key issue is the allocation of project tasks to the resources in the distributed team. In this paper, we examine this issue of task allocation in order to minimize the completion time of a project. We discuss a model for distributed team across time-zones and propose a task allocation algorithm for the same. We apply the approach on tasks of a few synthetic projects and two real projects and show that there is a potential to reduce the project duration as well as improve the resource utilization through 24-hour development.

Timeboxing: a process model for iterative software development

In todays business where speed is of essence, an iterative development approach that allows the functionality to be delivered in parts has become a necessity and an effective way to manage risks. In this paper we propose the timeboxing model for iterative software development in which each iteration is done in a time box of fixed duration, and the functionality to be built is adjusted to fit the time box. By dividing the time box into stages, pipelining concepts are employed to have multiple time boxes executing concurrently, leading to a reduction in the delivery time for product releases. We illustrate the use of this process model through an example of a commercial project that was successfully executed using the proposed model.

Functional refinement and nested objects for object-oriented design

An extended object-oriented design methodology is proposed which incorporates a top-down, stepwise refinement approach in a coherent fashion. The extended object-oriented design methodology also includes a phase of progressive object refinement to support the nesting of objects, which would allow entities in real life that are composed of subentities to be modeled. A design example is included, and experiences encountered using this methodology in a course are described. >

Atomic actions for fault-tolerance using CSP

Two complementary techniques have evolved for providing fault-tolerance in software: forward error recovery and backward error recovery. Few implementations permit both approaches to be combined within a particular application. Fewer techniques are available for the construction of fault-tolerant software for systems involving concurrent processes and multiple processors. Many schemes for supporting forward or backward recovery are based on some concept of an atomic action. The authors propose a mechanism for supporting an atomic action in a system of communicating sequential processes (CSP). The atomic action is used as the basic unit for providing fault-tolerance. The atomic action is called an FT-action, and both forward and backward error recovery are performed in the context of an FT-action.

Testing the completeness of specifications

A system is described that tests for the completeness of axiomatic specifications of abstract data types. For testing, the system generates a set of test cases and an implementation of the data type from the specifications. The generated implementation is such that if the specifications are not complete, the implementation is not complete, and the behavior of all of the sequences of valid operations on the data type is not defined. This implementation is tested with the generated test cases to detect the incompleteness of specifications. The system is implemented on a VAX system running Unix. >

Determining QoS of WS-BPEL Compositions

With a large number of web services offering the same functionality, the Quality of Service (QoS) rendered by a web service becomes a key differentiator. WS-BPEL has emerged as the de facto industry standard for composing web services. Thus, determining the QoS of a composite web service expressed in BPEL can be extremely beneficial. While there has been much work on QoS computation of structured workflows, there exists no tool to ascertain QoS for BPEL processes, which are semantically richer than conventional workflows. We propose a model for estimating three key QoS parameters - Response Time, Cost and Reliability - of an executable BPEL process from the QoS information of its partner services and certain control flow parameters. We have built a tool to compute QoS of a WS-BPEL process that accounts for most workflow patterns that may be expressed by standard WS-BPEL. Another feature of our QoS approach and the tool is that it allows a designer to explore the impact on QoS of using different software fault tolerance techniques like Recovery blocks, N-version programming etc., thereby provisioning QoS computation of mission critical applications that may employ these techniques to achieve high reliability and/or performance.

Using defect analysis feedback for improving quality and productivity in iterative software development

In todays business where speed is of essence, an iterative development approach that allows the functionality to be delivered in parts has become a necessity and an effective way to manage risks. Iterative development allows feedback from an iteration to influence decisions in future iterations, thereby making software development more responsive to changing user and business needs. In this paper we discuss the role of defect analysis as a feedback mechanism to improve the quality and productivity in an iteratively developed software project. We discuss how analysis of defects found in one iteration can provide feedback for defect prevention in later iterations, leading to quality and productivity improvement. We give an example of its use and benefits on a commercial project