Realistic Programming Research Articles

Combinatorial sketching for finite programs

Sketching is a software synthesis approach where the programmer develops a partial implementation - a sketch - and a separate specification of the desired functionality. The synthesizer then completes the sketch to behave like the specification. The correctness of the synthesized implementation is guaranteed by the compiler, which allows, among other benefits, rapid development of highly tuned implementations without the fear of introducing bugs.We develop SKETCH, a language for finite programs with linguistic support for sketching. Finite programs include many highperformance kernels, including cryptocodes. In contrast to prior synthesizers, which had to be equipped with domain-specific rules, SKETCH completes sketches by means of a combinatorial search based on generalized boolean satisfiability. Consequently, our combinatorial synthesizer is complete for the class of finite programs: it is guaranteed to complete any sketch in theory, and in practice has scaled to realistic programming problems.Freed from domain rules, we can now write sketches as simpleto-understand partial programs, which are regular programs in which difficult code fragments are replaced with holes to be filled by the synthesizer. Holes may stand for index expressions, lookup tables, or bitmasks, but the programmer can easily define new kinds of holes using a single versatile synthesis operator.We have used SKETCH to synthesize an efficient implementation of the AES cipher standard. The synthesizer produces the most complex part of the implementation and runs in about an hour.

Combinatorial sketching for finite programs

Sketching is a software synthesis approach where the programmer develops a partial implementation - a sketch - and a separate specification of the desired functionality. The synthesizer then completes the sketch to behave like the specification. The correctness of the synthesized implementation is guaranteed by the compiler, which allows, among other benefits, rapid development of highly tuned implementations without the fear of introducing bugs.We develop SKETCH, a language for finite programs with linguistic support for sketching. Finite programs include many highperformance kernels, including cryptocodes. In contrast to prior synthesizers, which had to be equipped with domain-specific rules, SKETCH completes sketches by means of a combinatorial search based on generalized boolean satisfiability. Consequently, our combinatorial synthesizer is complete for the class of finite programs: it is guaranteed to complete any sketch in theory, and in practice has scaled to realistic programming problems.Freed from domain rules, we can now write sketches as simpleto-understand partial programs, which are regular programs in which difficult code fragments are replaced with holes to be filled by the synthesizer. Holes may stand for index expressions, lookup tables, or bitmasks, but the programmer can easily define new kinds of holes using a single versatile synthesis operator.We have used SKETCH to synthesize an efficient implementation of the AES cipher standard. The synthesizer produces the most complex part of the implementation and runs in about an hour.

Combinatorial sketching for finite programs

Sketching is a software synthesis approach where the programmer develops a partial implementation - a sketch - and a separate specification of the desired functionality. The synthesizer then completes the sketch to behave like the specification. The correctness of the synthesized implementation is guaranteed by the compiler, which allows, among other benefits, rapid development of highly tuned implementations without the fear of introducing bugs.We develop SKETCH, a language for finite programs with linguistic support for sketching. Finite programs include many highperformance kernels, including cryptocodes. In contrast to prior synthesizers, which had to be equipped with domain-specific rules, SKETCH completes sketches by means of a combinatorial search based on generalized boolean satisfiability. Consequently, our combinatorial synthesizer is complete for the class of finite programs: it is guaranteed to complete any sketch in theory, and in practice has scaled to realistic programming problems.Freed from domain rules, we can now write sketches as simpleto-understand partial programs, which are regular programs in which difficult code fragments are replaced with holes to be filled by the synthesizer. Holes may stand for index expressions, lookup tables, or bitmasks, but the programmer can easily define new kinds of holes using a single versatile synthesis operator.We have used SKETCH to synthesize an efficient implementation of the AES cipher standard. The synthesizer produces the most complex part of the implementation and runs in about an hour.

Selectors Make Set-Based Analysis Too Hard

A set-based program analysis establishes constraints between sets of abstract values for all expressions in a program. Solving the system of constraints produces a conservative approximation to the program's runtime flow of values. Some practical set-based analyses use explicit selectors to extract the relevant values from an approximation set. For example, if the analysis needs to determine the possible return values of a procedure, it uses the appropriate selector to extract the relevant component from the abstract representation of the procedure. In this paper, we show that this selector-based approach complicates the constraint solving phase of the analysis too much and thus fails to scale up to realistic programming languages. We demonstrate this claim with a full-fledged value flow analysis for case-lambda, a multi-branched version of lambda. We show how both the theoretical underpinnings and the practical implementation become too complex. In response, we present a variant of set-based closure analysis that computes equivalent results in a much more efficient manner.

What Level of Mathematical Reasoning can Computer Science Demand of a Software Implementer?: Auf Deutsch: Welche Art mathematischer Argumentation darf die Informatikwissenschaft einem Softwareimplementierer auf jeden Fall zumuten?

The article starts out from the observation that software engineering splits in two large activity areas: Software specification with its verification and software implementation with its verification. To find answers to the question in the title the article studies a practical systems software engineering area where theory is better developed than compared to other areas: Compiler construction. Our answer is a conclusion from work in the DFG-project Verifix, U.Karlsruhe, U.Kiel, U.Ulm, 1995-2003. One very complex cooperational task has been construction of a so called initial correct compiler for a realistic high level programming (and compiler writing) language correctly implemented and executed on a real life host processor. The interface between compiling specification and compiler implementation is given by algebraic-style, conditional formula transformation or program term rewriting rules which the specifier figures out and must prove correct w. r. t. source program and target processor semantics and data and states representations.Intensive cooperation of compiling specifiers and compiler implementers has revealed that the implementer's mathematical reasoning is algebraic reasoning of moderate depth. The specifier overtakes semantical issues and does induction proofs, a field of much more intricate mathematical reasoning.

Behavioral programming of autonomous characters based on probabilistic automata and personality

This paper presents a system for realistic behavioral programming of virtual characters, based on personality and probabilistic automata. We describe personality by using the Five-Factor Model and ...

Behavioral programming of autonomous characters based on probabilistic automata and personality

AbstractThis paper presents a system for realistic behavioral programming of virtual characters, based on personality and probabilistic automata. We describe personality by using the Five‐Factor Model and achieve autonomy through a goal‐oriented approach. Each character perceives the surrounding world, decides how to behave and acts on the environment according to its personality and to its goals. The chief idea explored by the proposed approach is that personality has a probabilistic influence on behavior selection instead of a deterministic one. Different behavior sequences available to achieve a goal are modeled using probabilistic automata and making probability dependent on character personality. This leads to non‐repetitive behaviors, whose evolution is not foreseeable. The paper first motivates the approach in the context of cybertherapy. Then, it summarizes related work and illustrates in detail the proposed approach. Finally, it presents obtained results and discusses the main limitations of the implemented system. Copyright © 2004 John Wiley & Sons, Ltd.

Coverage-driven Automated Compiler Test Suite Generation

The paper presents a novel approach to automated compiler test suite generation based on the source level specification. Several coverage criteria are introduced. The application of the proposed methodology to testing the realistic programming language is discussed.

Television realism measures: The influence of program salience on global judgments

Five versions (four experimental and one control) of a questionnaire were randomly distributed to 190 participants as part of an experiment investigating whether judgments of global television realism are influence by the salience of program genre. Questionnaires contained items asking respondents how often they watch either 1) news programs, 2) reality‐based crime programs, 3) crime drama programs, or 4) day and evening soap operas, followed by perceived realism and demographic items. Global measures of television realism were influenced by the viewing questions that preceded them, such that questions about more realistic programming prompted judgments that television programming in general is more realistic. Except for one condition, questions measuring the perceived realism of a specific genre, rather than television in general, were not influenced by the salience manipulation. These results call into question the utility of global television realism items.

A Completely Verified Realistic Bootstrap Compiler

This paper reports on a large verification effort in constructing an initial fully trusted bootstrap compiler executable for a realistic system programming language and real target processor. The construction and verification process comprises three tasks: the verification of the compiling specification (a relation between abstract source and target programs) with respect to the language semantics and a realistic correctness criterion. This proof has been completely mechanized using the PVS verification system and is one of the largest case-studies in formal verification we are aware of. Second, the implementation of the specification in the high-level source language following a transformational approach, and finally, the implementation and verification of a binary executable written in the compiler's target language. For the latter task, a realistic technique has been developed, which is based on rigorous a-posteriori syntactic code inspection and which guarantees, for the first time, trusted execution of generated machine programs. The context of this work is the joint German research effort Verifix aiming at developing methods for the construction of correct compilers for realistic source languages and real target processors.

Implementing student ideas in CS2

It is very hard for faculty members to create programming assignments that are simultaneously challenging, accessible, and practical for students year after year. In some advanced undergraduate courses, most notably software engineering courses, students may specify their own programming projects. We demonstrate here that it is also possible for beginning undergraduate students to have good ideas for realistic programming projects, specifically a simple IDE (Integrated Development Environment) program which lets the user generate a basic GUI. The program then produces as output a Java source file, with some event-handling code, which can reproduce the GUI. Of course, we can't and don't expect the program to have all the features of a professional IDE, but it could be useful for CS1/CS2 students.A freshman CS2 student conceived and implemented this assignment in the Spring 2001 semester as part of an honors contract. Honors students elect to do extra work in courses for credit toward graduation with honors. Such a student designs a contract, to be approved by the instructor, indicating the extra work and its effect on the final grade. Although an honors student developed this project, this project is suitable in general for CS2 students.We now describe the features of the project. A settings frame and a drawing frame appear first. The settings frame allows the user to name the Java output file. It also has a Save button, a text field to control the arrow keys, and checkboxes that allow the user to choose if a main method will appear in the output file, if the resulting application frame will be centered on the screen, and if window listener code will be generated for the application frame. The right mouse button is used to add a component. When the mouse is released, the user chooses the component's type and then the desired variable name and caption. Components appear as black unfilled rectangles. The component declarations (alphabetically by variable name) and skeleton code for handling button clicks will appear in the output file. Clicking the left mouse button in a rectangle turns the rectangle red. The shift key and the left mouse button move such a component. The arrow keys resize the component. Component sizes will be preserved in the output file. The component's properties are updated with the C key. The delete key removes the component.We believe that this project is a challenging (but not impossible) and useful application of CS2 concepts.

A General Schema for Constructing One-Point Bases in the Lambda Calculus

In this paper, we present a schema for constructing one-point bases for recursively enumerable sets of lambda terms. The novelty of the approach is that we make no assumptions about the terms for which the one-point basis is constructed: They need not be combinators and they may contain constants and free variables. The significance of the construction is twofold: In the context of the lambda calculus, it characterises one-point bases as ways of ``packaging'' sets of terms into a single term; And in the context of realistic programming languages, it implies that we can define a single procedure that generates any given recursively enumerable set of procedures, constants and free variables in a given programming language.

Operational Techniques in PVS — A Preliminary Evaluation

In this paper we present a preliminary analysis of the suitability of using PVS as a tool for developing operational semantics and programming logics in a semi-automatic fashion. To this end we present a formalized proof of the Church–Rosser theorem for a version of the call-by-value lambda calculus in the spirit of Landin's ISWIM. The proof is developed in the PVS system, and is used as a test bed or benchmark for evaluating the applicability of that system for carrying out more complex operational arguments. Our approach is relatively unusual in that it is based on the named variable approach, and concentrates on the call-by-value version of the β rule. Although there are numerous computer-based proofs of the Church–Rosser theorem in the literature, all of the existing proofs eliminate the need to treat α conversion. The novel aspects of our approach are that: we use the PVS system, especially its built-in abstract data types facility, to verify a version of the Church–Rosser theorem; we formalize a version of the λ-calculus, as it normally appears in textbooks, rather than tailoring it to suit the machine or system; we treat an ISWIM variation on the call-by-value version of the λ-calculus, rather than the simpler traditional call-by-name version. However the main aim of the work reported here was to evaluate PVS as a tool for developing, state of the art, operational based programming logics for realistic programming languages.

Intersection types and computational effects

We show that standard formulations of intersection type systems are unsound in the presence of computational effects, and propose a solution similar to the value restriction for polymorphism adopted in the revised definition of Standard ML. It differs in that it is not tied to let-expressions and requires an additional weakening of the usual subtyping rules. We also present a bi-directional type-checking algorithm for the resulting language that does not require an excessive amount of type annotations and illustrate it through some examples. We further show that the type assignment system can be extended to incorporate parametric polymorphism. Taken together, we see our system and associated type-checking algorithm as a significant step towards the introduction of intersection types into realistic programming languages. The added expressive power would allow many more properties of programs to be stated by the programmer and statically verified by a compiler.

A secure networked laboratory for kernel programming

Recently, several flavours of UNIX have appeared which run on inexpensive personal computers. Further, the source code for these operating systems is freely available. This makes offering courses that include realistic kernel programming feasible in an academic environment. However, root access is required in order to modify a system's kernel. This poses a potential security threat both to other systems on the network and to other users of a single machine. This paper presents a lab design which securely integrates machines with untrusted users acting as root into a secured network, and which securely allows multiple users root access to the same machine.

Models and languages for parallel computation

We survey parallel programming models and languages using six criteria to assess their suitability for realistic portable parallel programming. We argue that an ideal model should by easy to program, should have a software development methodology, should be architecture-independent, should be easy to understand, should guarantee performance, and should provide accurate information about the cost of programs. These criteria reflect our belief that developments in parallelism must be driven by a parallel software industry based on portability and efficiency. We consider programming models in six categories, depending on the level of abstraction they provide. Those that are very abstract conceal even the presence of parallelism at the software level. Such models make software easy to build and port, but efficient and predictable performance is usually hard to achieve. At the other end of the spectrum, low-level models make all of the messy issues of parallel programming explicit (how many threads, how to place them, how to express communication, and how to schedule communication), so that software is hard to build and not very portable, but is usually efficient. Most recent models are near the center of this spectrum, exploring the best tradeoffs between expressiveness and performance. A few models have achieved both abstractness and efficiency. Both kinds of models raise the possibility of parallelism as part of the mainstream of computing.

Prototyping realistic programming languages based on formal specifications

The specification of realistic programming languages is difficult and expensive. One approach to make language specification more attractive is the development of techniques and systems for the generation of language–specific software from specifications. To contribute to this approach, a tool–based framework with the following features is presented: It supports new techniques to specify more language aspects in a static fashion. This improves the efficiency of generated software. It provides powerful interfaces to generated software components. This facilitates the use of these components as parts of language–specific software. It has a rather simple formal semantics. In the framework, static semantics is defined by a very general attribution technique enabling e.g. the specification of flow graphs. The dynamic semantics is defined by evolving algebra rules, a technique that has been successfully applied to realistic programming languages. After providing the formal background of the framework, an object–oriented programming language is specified to illustrate the central specification features. In particular, it is shown how parallelism can be handled. The relationship to attribute grammar extensions is discussed using a non-trivial compiler problem. Finally, the paper describes new techniques for implementing the framework and reports on experiences made so far with the implemented system.

Theory and Practice of Action Semantics

Action Semantics is a framework for the formal description<br />of programming languages. Its main advantage over other frameworks<br />is pragmatic: action-semantic descriptions (ASDs) scale up smoothly to<br />realistic programming languages. This is due to the inherent extensibility<br />and modifiability of ASDs, ensuring that extensions and changes to<br />the described language require only proportionate changes in its description.<br />(In denotational or operational semantics, adding an unforeseen<br />construct to a language may require a reformulation of the entire description.)<br />After sketching the background for the development of action semantics,<br />we summarize the main ideas of the framework, and provide a simple<br />illustrative example of an ASD. We identify which features of ASDs<br />are crucial for good pragmatics. Then we explain the foundations of<br />action semantics, and survey recent advances in its theory and practical<br />applications. Finally, we assess the prospects for further development<br />and use of action semantics.<br />The action semantics framework was initially developed at the University<br />of Aarhus by the present author, in collaboration with David Watt<br />(University of Glasgow). Groups and individuals scattered around five<br />continents have since contributed to its theory and practice.

Gigaflops in linear programming

This paper describes the parallelization of an “industrial strength” linear programming package. Our parallel version of CPLEX Barrier, running on a Silicon Graphics Power Challenge shared-memory multiprocessor, provides dramatic performance improvements over sequential methods on a wide range of practical, realistic linear programming problems. The resulting software/hardware combination can provide sustained performance of as much as 2.4 Gflops.

Parallel Branch-and-Bound Algorithms for General Mixed Integer Programming on the CM-5

This “proof of concept” paper describes parallel solution of general mixed integer programs by a branch-and-bound algorithm on the CM-5 multiprocessing system. It goes beyond prior parallel branch-and-bound work by implementing a reasonably realistic general-purpose mixed integer programming algorithm, as opposed to a specialized method for a narrow class of problems. It shows how to use the capabilities of the CM-5 to produce an efficient parallel implementation employing centrally controlled search, achieving near-linear speedups using 64–128 processors on a variety of difficult problems derived from real applications. In concrete terms, a problem requiring half an hour to solve on a SPARC-2 workstation might be solved in 15–20 seconds, and a problem originally taking a week might be reduced to about an hour. Central search control does have limitations, and some final computational experiments begin to address the merits of more decentralized options.