Abstract. The use of class libraries increases programmer productivity by allowing programmers to focus on the functionality unique to their application. However, library classes are generally designed with some typical usage pattern in mind, and performance may be suboptimal if the actual usage differs. We present an approach for rewriting applications to use customized versions of library classes that are generated using a combination of static analysis and profile information. Type constraints are used to determine where customized classes may be used, and profile information is used to determine where customization is likely to be profitable. We applied this approach to a number of Java applications by customizing various standard container classes and the omnipresent StringBuffer class, and measured speedups up to 78 % and memory footprint reductions up to 46%. The increase in application size due to the added custom classes is limited to 12 % for all but the smallest programs. 1

This case study applies techniques of formal program development by specification refinement and composition to the problem of concurrent garbage collection. The specification formalism is mainly based on declarative programming paradigms, the imperative aspect is dealt with by using monads. We also sketch the use of temporal logic in connection with monadic specifications.

Abstract. We extend CASL architectural specifications with a simple refinement language that allows the formalization of developments as refinement trees. The essence of the extension is to allow refinements of unit specifications in CASL architectural specifications. 1 Introduction The standard development paradigm of algebraic specification [1] postulates thatthe development begins with a formal requirement specification SP 0 (extractedfrom a software project's informal requirements) that fixes only expected properties but ideally says nothing about implementation issues; this is to be followedby a number of refinement steps that fix more and more details of the design, until a specification SP n is obtained that is detailed enough that its conversioninto a program

Exact pointer analysis is an intractable problem, so numerous pointer analysis algorithms have been developed that approximate the exact solution with varying levels of precision. These algorithms employ a variety of algorithmic strategies to describe how to approximate the exact solution. However, there is no formal description of the precision that these algorithms compute. This paper presents a unifying framework for specifying the precision of almost all existing pointer analysis algorithms. We show how the approximations computed by existing algorithms can be described by combining three basic semantic transformations that remove distinctions among program paths, among statements, or among variables. The transformations can be tuned at a fine granularity to specify a wide range of approximations. The framework permits a unified, formal description of pointer analysis approximations. 1.

Exact pointer analysis is an intractable problem, so numerous pointer analysis algorithms have been developed that approximate the exact solution with varying levels of precision. These algorithms employ a variety of algorithmic strategies to describe how to approximate the exact solution. However, there is no formal description of the precision that these algorithms compute. This paper presents a unifying framework for specifying the precision of almost all existing pointer analysis algorithms. We show how the approximations computed by existing algorithms can be described by combining three basic semantic transformations that remove distinctions among program paths, among statements, or among variables. The transformations can be tuned at a fine granularity to specify a wide range of approximations. The framework permits a unified, formal description of pointer analysis approximations. 1.

We present two algebras that unify the disparate software composition models of Feature-Oriented Programming and Aspect-Oriented Programming. In one algebra, a finite map space underlies program synthesis, where adding finite maps and modifying their contents are fundamental operations. A second and more general algebra uses quarks, a construct that represents both expressions and their transformations. Special cases of our algebras correspond to existing systems and languages, and thus can serve as a foundation for next-generation tools

Abstract not found

Abstract. Program verification is the task of automatically generating proofs for a program’s compliance with a given specification. Program synthesis is the task of automatically generating a program that meets a given specification. Both program verification and program synthesis can be viewed as search problems, for proofs and programs, respectively. For these search problems, we present approaches based on user-provided insights in the form of templates. Templates are hints about the syntactic forms of the invariants and programs, and help guide the search for solutions. We show how to reduce the template-based search problem to satisfiability solving, which permits the use of off-the-shelf solvers to efficiently explore the search space. Template-based approaches have allowed us to verify and synthesize programs outside the abilities of previous verifiers and synthesizers. Our approach can verify and synthesize difficult algorithmic textbook programs (e.g., sorting, and dynamic programming-based algorithms, etc.), and difficult arithmetic programs. 1

Abstract—We present a fault-tolerant ordered broadcast service that is correct-by-construction. Our broadcast service allows for diversity in space, whereby the participants in the broadcast protocol run different code, as well as in time, whereby the protocol itself is changed periodically. We use the Nuprl proof assistant to specify the service, prove correctness, and synthesize the code. The paper includes initial performance results. I.