Abstract In the correct-by-construction programming methodology, programs are incrementally derived from their formal specifications, by repeatedly applying transformations to partially derived programs. At an intermediate stage in a derivation, users may have to make certain assumptions to proceed further. To ensure that the assumptions hold true at that point in the program, certain other assumptions may need to be introduced upstream as loop invariants or preconditions. Typically these other assumptions are made in an ad hoc fashion and may result in unnecessary rework, or worse, complete exclusion of some of the alternative solutions. In this work, we present rules for propagating assumptions through annotated programs. We show how these rules can be integrated in a top-down derivation methodology to provide a systematic approach for propagating the assumptions, materializing them with executable statements at a place different from the place of introduction, and strengthening of loop invariants with minimal additional proof efforts.

Existing attempts towards including formal methods in introductory programming courses focus on introducing program verification tools. When using the verification tools, there is no structured help available to the students in the actual task of implementing the program, except for the hints provided by the failed proof obligations. In contrast, in the correct-by-construction programming methodology, programs are incrementally derived from their specifications. By restricting our attention to program derivation, we have identifed a small core of the formal method concepts that can easily be taught in the first two years of a computing curricula. Based on our learning from multiple years of paper and pencil based teaching, we have developed a programming assistant tool that addresses several of the issues faced by the students in the manual program derivation. The tool ensures that the most common students' error of performing incorrect proofs does not happen.

Two recent measures incorporate the notion of statistical significance in basic PMI formulation.In some tasks, we find that the new measures perform worse than the PMI.Our analysis shows that while the basic ideas in incorporating statistical significance in PMI are reasonable, they have been applied slightly inappropriately.By fixing this, we get new measures that improve performance over not just PMI but on other popular co-occurrence measures as well.In fact, the revised measures perform reasonably well compared with more resource intensive non co-occurrence based methods also.

Today, parallel corpus-based systems dominate the transliteration landscape. But the resource-scarce languages do not enjoy the luxury of large parallel transliteration corpus. For these languages, rule-based transliteration is the only viable option. In this article, we show that by properly harnessing the monolingual resources in conjunction with manually created rule base, one can achieve reasonable transliteration performance. We achieve this performance by exploiting the power of Character Sequence Modeling (CSM), which requires only monolingual resources. We present the results of our rule-based system for Hindi to English, English to Hindi, and Persian to English transliteration tasks. We also perform extrinsic evaluation of transliteration systems in the context of Cross Lingual Information Retrieval. Another important contribution of our work is to explain the widely varying accuracy numbers reported in transliteration literature, in terms of the entropy of the language pairs and the datasets involved.

We present an O(nlogn) algorithm to compute the coverage map of a given set of transmitters under interference constraints. That is, we compute the set of points that lie within the transmission range of one transmitter and lie outside the interference range of every other transmitter. To our knowledge, there is no existing satisfactory algorithm for this purpose. We assume that the transmission and interference ranges of each transmitter are circular disks.We show that for an appropriate choice of 'distance measure', coverage at each point can be computed by considering only certain 'proximate' transmitters. Hence, we partition the plane into proximity regions and the coverage in these proximity regions is computed considering only proximate transmitters. We use an extension of Voronoi diagrams, called 'Power' diagrams, to represent the proximity regions.

The problem of recovering distributed systems from crash failures has been widely studied in the context of traditional non-threaded processes. However, extending those solutions to the multi-threaded scenario presents new problems. We identify and address these problems for optimistic logging protocols. There are two natural extension to optimistic logging protocols in the multi-threaded scenario. The first extension is process-centric, where the points of internal non-determinism caused by threads are logged. The second extension is thread-centric, where each thread is treated as a separate process. The process-centric approach suffers from false causality while the thread-centric approach suffers from high causality tracking overhead. By observing that the granularity of failures can be different from the granularity of rollbacks, we design a new balanced approach which incurs low causality tracking overhead and also eliminates false causality.

Fault-tolerance techniques based on checkpointing and message logging have been increasingly used in real-world applications to reduce service downtime. Most industrial applications have chosen pessimistic logging because it allows fast and localized recovery. The price that they must pay, however, is the higher failure-free overhead. In this paper, we introduce the concept of K-optimistic logging where K is the degree of optimism that can be used to fine-tune the tradeoff between failure-free overhead and recovery efficiency. Traditional pessimistic logging and optimistic logging then become the two extremes in the entire spectrum spanned by K-optimistic logging. Our approach is to prove that only dependencies on those states that may be lost upon a failure need to be tracked on-line, and so transitive dependency tracking can be performed with a variable-size vector. The size of the vector piggybacked on a message then indicates the number of processes whose failures may revoke the message, and K corresponds to the system-imposed upper bound on the vector size.

We propose a new algorithm for recovering asynchronously from failures in a distributed computation. Our algorithm is based on two novel concepts-a fault-tolerant vector clock to maintain causality information in spite of failures, and a history mechanism to detect orphan states and obsolete messages. These two mechanisms together with checkpointing and message-logging are used to restore the system to a consistent state after a failure of one or more processes. Our algorithm is completely asynchronous. It handles multiple failures, does not assume any message ordering, causes the minimum amount of rollback and restores the maximum recoverable state with low overhead. Earlier optimistic protocols lack one or more of the above properties.