Abstract. In this paper, we describe an approach to boosting the performance of an XQuery engine by identifying and exploiting opportunities to share processing both within and across XML queries. We first explain where sharing opportunities arise in the world of XML query processing. We then describe an approach to shared XQuery processing based on memoization, providing details of an implementation that we built by extending the streaming XQuery processor that BEA Systems incorporates as part of their BEA WebLogic Integration 8.1 product. To explore the potential performance gains offered by our approach, we present results from an experimental study of its performance over a collection of use-case-inspired synthetic query workloads. The performance results show that significant overall gains are indeed available. 1

Interactive, modular, and object-oriented programming are three important programming paradigms. Interactive programming encourages experimental programming and fast prototyping and is most valuable for solving problems that are not well understood. Modular programming is indispensable for large-scale program development and is also useful for smaller programs. Object-oriented programming features classes, objects, and inheritance and is suitable for many real world applications. This dissertation describes an approach of merging interactive, modular, and object-oriented programming by presenting the definition, design, and implementation of the imp language, the IMP system, and the IMOOP system. The primary benefit of merging these three paradigms is that the programmer can use either paradigm where appropriate. In order to merge interactive and modular programming, the programmer must be allowed to modify variable bindings and module interfaces during program development. Furthermor...

and concrete predicates for Leaveok---design one s? P enrolled s? P ran (testlist nottested) ((testlist9 = testlist e {s?} ` nottested9 = nottested) ~ enrolled9 = enrolled\{s?} (testlist9 = testlist ` nottested 9 = nottested e {s?})) ((s? P tested ` tested9 = tested\{s?} ((s9 P ran testlist ` testlist9 = testlist e {s?} ` r! = cert) ` r! = cert) ~ (s? P/ tested ` tested9 = tested ~ (s? P/ ran testlist ` testlist9 = testlist ` r! = nocert)) ` r! = nocert)) of the Leave operation, Table I illustrates each of its predicates on both the abstract state Class and the concrete state ConClass. Schema CNotEnrolled appears below without explanation since its derivation is straightforward.

Abstract. Recently, researchers in GIScience argued about the benefits on using functional programming for geospatial application development and prototyping of novel ideas. This paper presents an application that interfaces a functional language with a spatial database. It enables developing GIS applications development in a functional language, while handling data are in a spatial database. We used this application develop a Map Algebra, that shows the benefits on using this paradigm in GIScience. Our work shows there are many gains in using a functional language, especially Haskell, to write concise and expressive GIS applications. The TerraHS application allows a good compromise between the expressive power of a functional language, and the data handling facilities of an imperative language.

As people reliance on computer systems increases, it is of primary importance for these systems to be dependable. This new dependability requirement increases the need for the development of fault tolerant software. Designing and implementing fault tolerant software is a difficult task, especially when implementing fault tolerant parallel software. Only few programming languages support fault tolerance and parallel programming. These languages are based on an imperative language paradigm. Most fault tolerance techniques are developed for such language paradigm. The imperative language paradigm increases system complexity. Novel fault tolerance techniques for the implementation of fault tolerant software based on a different language paradigm have to be developed in order to decrease system complexity and increase its performance. This dissertation presents a novel replication technique for implementing fault tolerant parallel software based on a declarative language paradigm. The repli...

> in a functional program, this would represent an equation with no finite solution (and would either be rejected by a compiler or result in a nonterminating computation), whereas in C this would increment the contents of the memory cell denoted by x. Function names are introduced in a similar way. The declaration let f~x, y! 5 x 1 y introduces the function f and states that f(x, y) and x 1 y are equal, for any x and y. The expression on the right-hand side, the body of f, cannot be a sequence of statements modifying the values of x and y (and perhaps other variables). As in mathematics, a function is a single-valued relation such that, given the same argument(s), it will return the same result. This is certainly not the case in the imperative programs.

One of the major overheads in implementing functional languages is the storage management overhead due to dynamic allocation and automatic reclamation of indefinite-extent storage. This dissertation investigates the problems of statically inferring lifetime information about dynamically-allocated objects in higher-order polymorphic functional languages, both strict and non-strict, and of applying that information to reduce the storage management overhead. We have developed a set of compile-time semantic analyses for a higher-order, monomorphic, strict functional language based on denotational semantics and abstract interpretation. They are 1) escape analysis, which provides information about the relative lifetimes of objects such as arguments and local objects defin...

Software metrics have been investigated for the assessment of programs written in a functional programming language. The external attribute of programs considered in this thesis is their comprehensibility to novice programmers. This attribute has been operationalized in a number of experiments. The internal attribute of software which is examined is the structure. Two models for the structure of software have been employed: callgraphs and flowgraphs. The proposed control-flow model captures the operational semantics of function definitions. The objective measurement of the attributes has been supported by tools. The validation of structure metrics has been addressed in certain experiments for programming-in-the-small. The structure of type expressions in functional programs has been analysed in a case study. A simple framework for software metrication proved to be useful. The validation of metrics has been linked with axioms from the representational measurement theory. The control-flow model for functional programs showed its value in the set-up of an

Programming high-performance server applications is challenging: it is both complicated and error-prone to write the concurrent code required to deliver high performance and scalability. Server performance bottlenecks are difficult to identify and correct. Finally, it is difficult to predict server performance prior to deployment. This paper presents Flux, a language that dramatically simplifies the construction of scalable high-performance server applications. Flux lets programmers compose off-the-shelf, sequential C, C++, or Java functions into concurrent servers. The Flux compiler type-checks programs and guarantees that they are deadlock-free. We have built a number of servers in Flux, including a web server with PHP support, an image-rendering server, a BitTorrent peer, and a game server. These Flux servers perform comparably to their counterparts written entirely in C. By tracking hot paths through a running server, Flux simplifies the identification of performance bottlenecks. The Flux compiler also automatically generates discrete event simulators that accurately predict actual server performance under load and with different hardware resources.

In the equivalent transformation (ET) computation model, a specification provides background knowledge in a problem domain and defines a set of queries of interest. A program is a set of prioritized transformation rules, and computation consists in successive reduction of queries using meaning-preserving transformation with respect to given background knowledge. We present a formalization of the ET model from the viewpoint of program synthesis, where not only computation but also program correctness and correctness relations are of central importance. The notion of program correctness defines “what it means for a program to be correct with respect to a specification,” and a correctness relation provides guidance on “how to obtain such a program. ” The correctness relation of the ET model is established, based on which how the basic structure of the ET model facilitates program synthesis is discussed together with program synthesis strategies in this model.