Software engineers are faced with a dilemma. They want to write general and wellstructured programs that are flexible and easy to maintain. On the other hand, generality has a price: efficiency. A specialized program solving a particular problem is often significantly faster than a general program. However, the development of specialized software is time-consuming, and is likely to exceed the production of today’s programmers. New techniques are required to solve this so-called software crisis. Partial evaluation is a program specialization technique that reconciles the benefits of generality with efficiency. This thesis presents an automatic partial evaluator for the Ansi C programming language. The content of this thesis is analysis and transformation of C programs. We develop several analyses that support the transformation of a program into its generating extension. A generating extension is a program that produces specialized programs when executed on parts of the input. The thesis contains the following main results. • We develop a generating-extension transformation, and describe specialization of the various parts of C, including pointers and structures. • We develop constraint-based inter-procedural pointer and binding-time analysis. Both analyses are specified via non-standard type inference systems, and implemented by constraint solving. • We develop a side-effect and an in-use analysis. These analyses are developed in the classical monotone data-flow analysis framework. Some intriguing similarities with constraint-based analysis are observed. • We investigate separate and incremental program analysis and transformation. Realistic programs are structured into modules, which break down inter-procedural analyses that need global information about functions. • We prove that partial evaluation at most can accomplish linear speedup, and develop an automatic speedup analysis. • We study the stronger transformation technique driving, and initiate the development of generating super-extensions. The developments in this thesis are supported by an implementation. Throughout the chapters we present empirical results.

Program Analysis and Specialization for the C Programming Language

We give a deterministic algorithm for triangulating a simple polygon in linear time. The basic strategy is to build a coarse approximation of a triangulation in a bottom-up phase and then use the information computed along the way to refine the triangulation in a top-down phase. The main tools used are the polygon-cutting theorem, which provides us with a balancing scheme, and the planar separator theorem, whose role is essential in the discovery of new diagonals. Only elementary data structures are required by the algorithm. In particular, no dynamic search trees, of our algorithm.

Triangulating a simple polygon in linear time

Arthur Chickering is Distinguished Professor of Higher Education at Memphis State University. On leave from the Directorship of the Center for the Study of Higher Education at Memphis State, he is Visiting Professor at George Mason University. Zelda Gamson is a sociologist who holds appointments at the John W. McCormack Institute of Public Affairs at the University of Massachusetts-Boston and in the Center for the Study of Higher and Postsecondary Education at the University of Michigan.

Seven Principles for Good Practice in Undergraduate Education: Faculty Inventory. Institutional Inventory.

As computing becomes a mainstream discipline embedded in the school curriculum and acts as an enabler for an increasing range of academic disciplines in higher education, the literature on introductory programming is growing. Although there have been several reviews that focus on specific aspects of introductory programming, there has been no broad overview of the literature exploring recent trends across the breadth of introductory programming. This paper is the report of an ITiCSE working group that conducted a systematic review in order to gain an overview of the introductory programming literature. Partitioning the literature into papers addressing the student, teaching, the curriculum, and assessment, we explore trends, highlight advances in knowledge over the past 15 years, and indicate possible directions for future research.

/pdf/introductory-programming-a-systematic-literature-review-3yllvt7k18.pdf

Introductory programming: a systematic literature review

We describe a language for defining term rewriting strategies, and its application to the production of program optimizers. Valid transformations on program terms can be described by a set of rewrite rules; rewriting strategies are used to describe when and how the various rules should be applied in order to obtain the desired optimization effects. Separating rules from strategies in this fashion makes it easier to reason about the behavior of the optimizer as a whole, compared to traditional monolithic optimizer implementations. We illustrate the expressiveness of our language by using it to describe a simple optimizer for an ML-like intermediate representation.The basic strategy language uses operators such as sequential composition, choice, and recursion to build transformers from a set of labeled unconditional rewrite rules. We also define an extended language in which the side-conditions and contextual rules that arise in realistic optimizer specifications can themselves be expressed as strategy-driven rewrites. We show that the features of the basic and extended languages can be expressed by breaking down the rewrite rules into their primitive building blocks, namely matching and building terms in variable binding environments. This gives us a low-level core language which has a clear semantics, can be implemented straightforwardly and can itself be optimized. The current implementation generates C code from a strategy specification.

Building program optimizers with rewriting strategies

Although code transformations are routinely applied to improve the performance of programs for both scalar and parallel machines, the properties of code-improving transformations are not well understood. In this article we present a framework that enables the exploration, both analytically and experimentally, of properties of code-improving transformations. The major component of the framework is a specification language, Gospel, for expressing the conditions needed to safely apply a transformation and the actions required to change the code to implement the transformation. The framework includes a technique that facilitates an analytical investigation of code-improving transformations using the Gospel specifications. It also contains a tool, Genesis, that automatically produces a transformer that implements the transformations specified in Gospel. We demonstrate the usefulness of the framework by exploring the enabling and disabling properties of transformations. We first present analytical results on the enabling and disabling properties of a set of code transformations, including both traditional and parallelizing transformations, and then describe experimental results showing the types of transformations and the enabling and disabling interactions actually found in a set of programs.

/pdf/an-approach-for-exploring-code-improving-transformations-3dwqzaof3v.pdf

An approach for exploring code improving transformations

As an approach to deriving an application order of optimizing transformations, a framework is developed for examining the interactions of the transformations. The framework is based on an axiomatic specification technique and includes both pre-conditions and post conditions that must exist before and after applying optimizations. For a selected set of optimizations, the framework is used to determine those interactions among the optimizations that can create conditions and those that can destroy conditions for applying other optimizations. From these interactions, an application order is derived to obtain the potential benefits of the optimizations that can be applied to a program. In some cases, the ordering of a pair of optimizations is unambiguous in that one optimization can either create or destroy the conditions for the other. In the few cases where there is a cyclic interaction, the ordering is resolved based on the perceived importance of the two optimizations.

An approach to ordering optimizing transformations

This paper describes how Alice 2.0 is being used in an introductory programming course, the first in a three course sequence that meets the description of the object-oriented sequence described in the CC2001 report. The modifications to the syllabi to accommodate an Alice-Java-Java sequence are described.. Issues caused by using Alice for an introduction programming in the first course for both computing majors and liberal studies students are explored. Retention data and percentage of women enrolled when using Alice for the first semester is compared to data for C++.

Using Alice 2.0 as a first language

This research has developed an optimizer generator that automatically produces optimizers from specifications. Code optimizations are expressed using a specification language designed for both traditional and parallelizing optimization, which require global dependence conditions. Numerous optimizers have been produced from a prototype implementation of the generator. The quality of code produced using the generated optimizers compares favorably with that produced by hand coded optimizers. The generator can be used as a phase in a compiler or as an experimental tool to determine the effects of various optimization and to tailor optimization. Experiments indicate that optimization interact in practice and that different orderings of optimization are needed for different code segments of the same program. Experiments found that the cost-benefit ratio of some optimizations is quite large and in some cases can be reduced by careful specifications of the optimizations or different implementations.

/pdf/automatic-generation-of-global-optimizers-51w8ewp8dn.pdf

Automatic generation of global optimizers

Program assessment of student learning includes the following steps: 1) involving all constituents to establish program goals, 2) developing measurable student learning outcomes for each of the goals, 3) developing measurable outcomes for each course that map to the student learning outcomes, 4) determining appropriate assessment methods in the courses, 5) creating assessment instruments (or rubrics) for each of the methods, 6) establishing benchmarks, 7) analyzing the data, and 8) using the results to improve student learning. This paper focuses on the last four steps by beginning with a generalized assessment plan for an undergraduate computer science program. A generalized rubric for computer programs is presented that measures selected student learning outcomes. This paper demonstrates how to apply the generalized rubric to two specific computer programming assignments. Benchmarks associated with the rubrics are suggested. Sample results are analyzed to identify problems and propose solutions---"closing the loop."

Deborah Whitfield

Papers

An approach for exploring code improving transformations

An approach to ordering optimizing transformations

Using Alice 2.0 as a first language

Automatic generation of global optimizers

How rubrics that measure outcomes can complete the assessment loop