ESOP

Hoare Type Theory (HTT) combines a dependently typed, higher-order language with monadically-encapsulated, stateful computations. The type system incorporates pre- and post-conditions, in a fashion similar to Hoare and Separation Logic, so that programmers can modularly specify the requirements and effects of computations within types. This paper extends HTT with quantification over abstract predicates (i.e., higher-order logic), thus embedding into HTT the Extended Calculus of Constructions. When combined with the Hoare-like specifications, abstract predicates provide a powerful way to define and encapsulate the invariants of private state that may be shared by several functions, but is not accessible to their clients. We demonstrate this power by sketching a number of abstract data types that demand ownership of mutable memory, including an idealized custom memory manager.

Types are often used to control and analyze computer programs. Intersection types give great flexibility, but have been difficult to implement. The ! operator, used to distinguish between linear and non-linear types, has good potential for better resource-usage tracking, but has not been as flexible as one might want and has been difficult to use in compositional analysis. We introduce System E, a type system with expansion variables, linear intersection types, and the ! type constructor for creating non-linear types. System E is designed for maximum flexibility in automatic type inference and for ease of automatic manipulation of type information. Expansion variables allow postponing the choice of which typing rules to use until later constraint solving gives enough information to allow making a good choice. System E removes many difficulties that expansion variables had in the earlier System I and extends expansion variables to work with ! in addition to the intersection type constructor. We present subject reduction for call-by-need evaluation and discuss program analysis in System E.

We describe the mechanisation of an SLR parser produced by a parser generator, covering background properties of context-free languages and grammars, as well as the construction of an SLR automaton. Among the various properties proved about the parser we show, in particular, soundness: if the parser results in a parse tree on a given input, then the parse tree is valid with respect to the grammar, and the leaves of the parse tree match the input; completeness: if the input is in the language of the grammar then the parser constructs the correct parse tree for the input with respect to the grammar; and non-ambiguity: grammars successfully converted to SLR automata are unambiguous.

We study the relationship between Concurrent Separation Logic (CSL) and the assume-guarantee (A-G) method (a.k.a. rely-guarantee method). We show in three steps that CSL can be treated as a specialization of the A-G method for well-synchronized concurrent programs. First, we present an A-G based program logic for a low-level language with built-in locking primitives. Then we extend the program logic with explicit separation of “private data” and “shared data”, which provides better memory modularity. Finally, we show that CSL (adapted for the low-level language) can be viewed as a specialization of the extended A-G logic by enforcing the invariant that “shared resources are well-formed outside of critical regions”. This work can also be viewed as a different approach (from Brookes’) to proving the soundness of CSL: our CSL inference rules are proved as lemmas in the A-G based logic, whose soundness is established following the syntactic approach to proving soundness of type systems.

We discuss the choice of programming primitives for set oriented programnung languages such as SETL For this purpose we introduce a mathematical model (hereditarily finite sets with urelements). In this model criteria for the choice of programming prknittves are defined. The criteria are complexity, independence and computational completeness of the basic constructs. "fie propose primitives satisfying our criteria and also discuss briefly the possibility of defining abstract data types within our mathematical model. We give a characterization of the data types whose objects are recognizable in NP. Our work is a synthesis of several approaches previously introduced in other frameworks, such as query languages, generalized recursion theory and high level program

Purpose -The purpose of this paper is to examine the impact on selected financial performance indicators of Indian firms adopting employee stock option (ESO) schemes, if they recognize expenses and adopting fair-value method of accounting pursuant to International Financial Reporting Standard (IFRS) 2. Design/methodology/approach -The CMIE Prowess database was searched for Indian firms having stock option schemes and issue of shares pursuant to that scheme during the years ended 31 March 2007 and 31 March 2008. The data on financial performance were hand picked from the annual report of the sample companies. The impact of expense recognition on financial performance indicators were computed by using memorandum disclosures in directors' reports on use of fair value methods for ESO accounting. A non-parametric Kruskal-Wallis test was employed to find out the statistical significance of the impact. The role of firm growth characteristics on impact of expense recognition was also investigated. Findings -The impact of recognizing expenses associated with stock option compensation varies considerably by entity and such recognition would have a material impact on key performance measure for at least 22 percent of the sample companies. Contrary to expectation, firm growth characteristics were found to have no statistical significance in explaining impact of expense recognition.

Abstract. A transaction defines a locus of computation that satisfies important concurrency and failure properties; these so-called ACID properties provide strong serialization guarantees that allow us to reason about concurrent and distributed programs in terms of higher-level units of computation (e.g., transactions) rather than lower-level data structures (e.g., mutual-exclusion locks). This paper presents a framework for specifying the semantics of a transaction facility integrated within a host programming language. The TFJ calculus supports nested and multi-threaded transactions. We give a semantics to TFJ that is parameterized by the definition of the transaction mechanism that permits the study of different transaction models. 1

Bargaining often occurs between parties with some shared interest. Partnerships, joint ventures, and cross ownership are examples. We extend standard bargaining models to allow for joint ownership. Joint ownership reduces costly bargaining disputes, as bargainers' interests are more aligned. We then test the theory with collective bargaining data, where employee stock ownership plans (ESOPs) are the source of joint ownership. The theory predicts that ESOPs will lead to a reduction in strike incidence and the fraction of labor disputes that involve a strike. We examine these predictions using U.S. bargaining data from 1970-1995. The data suggest that ESOPs do increase the efficiency of labor negotiations by shifting the composition of disputes away from costly strikes. Consistent with improved bargaining efficiency, we find that the announcement of a union ESOP leads to a 50% larger stock market reaction as compared to the announcement of a nonunion ESOP.

Separation logic is a recent approach to the analysis of pointer programs in which resource separation is expressed with a logical connective in assertions that describe the state at any given point in the program. We extend this approach to express properties of memory separation between different points in the program, and present an algorithm for determining independences between program statements which can be used for parallelization.

A transaction defines a locus of computation that satisfies important concurrency and failure properties; these so-called ACID properties provide strong serialization guarantees that allow us to reason about concurrent and distributed programs in terms of higher-level units of computation (e.g., transactions) rather than lower-level data structures (e.g., mutual-exclusion locks). This paper presents a framework for specifying the semantics of a transactional facility integrated within a host programming language. The TFJ calculus supports nested and multi-threaded transactions. We give a semantics to TFJ that is parameterized by the definition of the transactional mechanism that permits the study of different transaction models.

Environment classifiers were recently proposed as a new approach to typing multi-stage languages. Safety was established in the simply-typed and let-polymorphic settings. While the motivation for the classifier approach was the feasibility of inference, this was in fact not established. This paper starts with the observation that inference for the full classifier-based system fails. We then identify a subset of the original system for which inference is possible. This subset, which uses implicit classifiers, retains significant expressivity (e.g. it can embed the calculi of Davies and Pfenning) and eliminates the need for classifier names in terms. Implicit classifiers were implemented in MetaOCaml, and no changes were needed to make an existing test suite acceptable by the new type checker.

Dynamic linking supports flexible code deployment: partially linked code links further code on the fly, as needed; and thus, end-users receive updates automatically. On the down side, each program run may link different versions of the same code, possibly causing subtle errors which mystify end-users. Dynamic linking in Java and C# are similar: The same linking phases are involved, soundness is based on similar ideas, and executions which do not throw linking errors give the same result. They are, however, not identical: the linking phases are combined differently, and take place in different order. Thus, linking errors may be detected at different times in Java and C#. We develop a non-deterministic model, which includes the behaviour of Java and C#. The non-determinism allows us to describe the design space, to distill the similarities between the two languages, and to use one proof of soundness for both. We also prove that all execution strategies are equivalent in the sense that all terminating executions which do not involve a link error, give the same result. parts of the code. Conversely, in Java and C# if the components linked turn out to be "incompatible", link related exceptions are thrown, describing the nature of the problem. Thus, although Java and C# do not guarantee choice of compatible components, they guarantee type safety and give error messages that signal the source of the problem. Our study is concerned with how Java and C# tackle the second question, i.e., how they guarantee type safety. Dynamic linking in Java and C# are similar: The same linking phases are involved, i.e., loading, verification, offset calculation, and layout determination. Soundness is based on similar ideas: i.e., consistency of the layout and virtual tables, verifying intermediate code, and checking before calculating offsets. Executions which do not throw linking errors give the same result. However, dynamic linking in Java and C# have some differences: The linking phases have different granularity, are combined differently and take place in different order. Linking errors may be detected at different times in Java and C# executions. We develop a non-deterministic model, which includes the behaviour of Java and C#. We prove preservation properties (which, we consider, were prevalent in the design) prove soundness, and that all executions which do not throw link errors give the same results. Our model is concerned with the interplay of the phases rather than with the particular phases themselves. It is at a higher level than the Java bytecode or the .NET IL. It abstracts from Java multiple loaders and .NET assemblies, and describes the verifier as a type checker, disregarding type inference and data flow analysis issues. It models intermediate code as being interpreted, disregarding the difference between JVM bytecode interpretation, and .NET IL code jit-compilation. It represents dynamic linking not necessarily as is, but as perceived by the source language programmer. Section 2 introduces Java and C# dynamic linking with an example. Figure 9 lists the main concepts defined. Sections 3 and 4 outline and define the model. Section 5 states properties, soundness, and equivalence. Section 6 concludes. The appendix contains more examples, details for lemmas and proofs.

We present a practical algorithm for computing least solutions of systems of equations over the integers with addition, multiplication with positive constants, maximum and minimum. The algorithm is based on strategy iteration. Its run-time (w.r.t. the uniform cost measure) is independent of the sizes of occurring numbers. We apply our technique to solve systems of interval equations. In particular, we show how arbitrary intersections as well as full interval multiplication in interval equations can be dealt with precisely.

In this paper we present an alternative approach to interprocedurally inferring linear inequality relations. We propose an abstraction of the effects of procedures through convex sets of transition matrices. In the absence of conditional branching, this abstraction can be characterised precisely by means of the least solution of a constraint system. In order to handle conditionals, we introduce auxiliary variables and postpone checking them until after the procedure calls. In order to obtain an effective analysis, we approximate convex sets by means of polyhedra. Since our implementation of function composition uses the frame representation of polyhedra, we rely on the subclass of simplices to obtain an efficient implementation. We show that for this abstraction the basic operations can be implemented in polynomial time. First practical experiments indicate that the resulting analysis is quite efficient and provides reasonably precise results.

Iterated Register Coalescing (IRC) is a widely used heuristic for performing register allocation via graph coloring. Many implementations in existing compilers follow (more or less faithfully) the imperative algorithm published in 1996. Several mistakes have been found in some of these implementations. In this paper, we present a formal verification (in Coq) of the whole IRC algorithm. We detail a specification that can be used as a reference for IRC. We also define the theory of register-interference graphs; we implement a purely functional version of the IRC algorithm, and we prove the total correctness of our implementation. The automatic extraction of our IRC algorithm into Caml yields a program with competitive performance. This work has been integrated into the CompCert verified compiler.