ion. ACM Transactions on Programming Languages and Systems, 16(5):1512--1542, September 1994. Bibliography 401 [Che80] B. F. Chellas. Modal Logic -- an Introduction. Cambridge University Press, 1980. [Dam96] D. R. Dams. Abstract Interpretation and Partition Refinement for Model Checking. PhD thesis, Institute for Programming research and Algorithmics. Eindhoven University of Technology, July 1996. [Dij76] E. W. Dijkstra. A Discipline of Programming. Prentice Hall, 1976. [DP96] R. Davies and F. Pfenning. A Modal Analysis of Staged Computation. In 23rd Annual ACM Symposium on Principles of Programming Languages. ACM Press, January 1996. [EN94] R. Elmasri and S. B. Navathe. Fundamentals of Database Systems. Benjamin/Cummings, 1994. [FHMV95] Ronald Fagin, Joseph Y. Halpern, Yoram Moses, and Moshe Y. Vardi. Reasoning about Knowledge. MIT Press, Cambridge, 1995. [Fit93] M. Fitting. Basic modal logic. In D. Gabbay, C. Hogger, and J. Robinson, editors, Handbook of Logic in Artificial In...

A typed model of strategic term rewriting is developed. The key innovation is that generic. The calculus traversal is covered. To this end, we define a typed rewriting calculus S ′ γ employs a many-sorted type system extended by designated generic strategy types γ. We consider two generic strategy types, namely the types of type-preserving and type-unifying strategies. S ′ γ offers traversal combinators to construct traversals or schemes thereof from many-sorted and generic strategies. The traversal combinators model different forms of one-step traversal, that is, they process the immediate subterms of a given term without anticipating any scheme of recursion into terms. To inhabit generic types, we need to add a fundamental combinator to lift a many-sorted strategy s to a generic type γ. This step is called strategy extension. The semantics of the corresponding combinator states that s is only applied if the type of the term at hand fits, otherwise the extended strategy fails. This approach dictates that the semantics of strategy application must be type-dependent to a certain extent. Typed strategic term rewriting with coverage of generic term traversal is a simple but expressive model of generic programming. It has applications in program

This thesis presents a formal analysis of the core of C++, the method binding mechanism. The analysis will include features such as inheritance, overloading, overriding, hiding, and conversions. Our model will clearly explain method binding under all these features, without the ambiguity that colloquial descriptions can introduce. Many of the intricacies of our formal model will demonstrate that the informal descriptions used to explain the language are not sophisticated enough to explain certain examples. The type rules and operational semantics we present should provide the basis for a more accurate conceptual model of the language. Contents 1 Background 5 1.1 Programming Languages: Between Industry and Research : : : : 5 1.2 The Object-Oriented Paradigm : : : : : : : : : : : : : : : : : : : 6 1.3 The Demand for Object-Oriented Methodology : : : : : : : : : : 7 1.4 The Birth of C++ : : : : : : : : : : : : : : : : : : : : : : : : : : 7 1.4.1 In the Beginning: Abstraction, Encapsulat...

The exploration of requirements is as complex as it is important in ensuring a successful software production and software life cycle. Increasingly, tool-support is available for aiding such explorations. We use a toy example and a case study of modelling and analysing some requirements of the global assembly cache of.NET to illustrate the opportunities and challenges that mathematically founded exploration of requirements brings to the computer science and software engineering curricula.

This paper describes a high level operational semantics for a simple programming language, called K O R E L , together with a parser, interpreter and pretty printer which are implemented in the (pure) functional programming language Haskell. The syntax of K O R E L is presented via BNF grammars, and the operational semantics is specied via structured, inductive rules. The paper outlines the broad ideas behind the Haskell implementation, with a more detailed explication of the key techniques. A code listing can be found in [Cro97]. 1 Introduction This paper presents a high level operational semantics for a simple programming language, together with a parser, interpreter and pretty printer which are implemented in the (pure) functional programming language Haskell. Our programming language is called K O R E L , so called because it can be considered to represent the core programming features of a language combining imperative and functional constructs, and has both an eager and a laz...

In this paper, we address some issues in the multiple dispatch language Tuple. Specifically, the purpose and basic ideas of the language Tuple, our implementation in Haskell of the dynamic semantics and type checking, and the soundness proof of it's static type system are presented. The program for the dynamic semantics looks like the denotional semantics of the language. And the program for type checking resembles the type inference rules in logic. 1 Introduction An object-oriented programming language has single dispatch when only the dynamic class of the message's receiver, a single object, is used to select the method to execute in response to the message. Here, a message consists of the name of method being invoked and the actual arguments. The receiver of the message is the object instance that support the corresponding method. For example, in a function call o:g(x), the message is g(x), the receiver is o. Multiple dispatch, on the other hand, selects a method based on the dy...

A functor is a parameterized program module i.e. a function that takes modules as arguments and returns a module as its result. A higher-order functor deals in the same way with modules whose components are functors themselves. We propose to develop a generic compilation system for the construction of high-performance mathematical software libraries for scientific and technical application domains. This system has the following features: 1. It is based on a powerful higher-order functor language. 2. It is an open library that can be retargeted to any core language. 3. It is able to resolve functor instantiation at compile-time. The functor language is expressive enough to build all types and type constructors without referring to the core language (thus maximizing flexibility) and to express all interactions between modules by parameterization (thus maximizing reusability). By compile-time instantiation, genericity does not cause any execution overhead; by automatically sharing instant...

. A language for composing separately compiled components has been defined. It may be of practical interest if a compiled component is considered a merchandise. A formal semantics for this kind of language must handle the components abstractly. For the defined language this is feasible in a straightforward way. The language completely lacks facilities for defining data structures or operations. It depends on descriptions, called signatures, of external components and a general syntax, so that the set of signatures from one point of view can be considered the grammar of one of several languages. Types are important in signatures that may describe parametric polymorphism, not restricted to shallow polymorphism. Compositions are type checked based on automatic type completion. The formal semantics explains how do type completion based on typed command descriptions. Keywords: component composition, polymorphism, type completion, formal semantics. 1 Copyright c fl1997 by J. Steensgaard-Ma...

Abstract not found

Writing correct and efficient concurrent programs still remains a challenge. Explicit concurrency is difficult, error prone, and creates code which is hard to maintain and debug. This type of concurrency also treats modular program design and concurrency as separate goals, where modularity often suffers. To solve these problems, we are designing a new language that we call Panini. In this paper, we focus on Panini's asynchronous, typed events which reconcile the modularity goal promoted by the implicit invocation design style with the concurrency goal of exposing potential concurrency between the execution of subjects and observers. Since modularity is improved and concurrency is implicit in Panini, programs are easier to reason about and maintain. Furthermore, races and deadlocks are avoided entirely, yielding programs with a guaranteed sequential semantics. To evaluate our language design and implementation we show several examples of its usage as well as an empirical study of program performance. We found that not only is developing and understanding Panini programs significantly easier compared to standard concurrent object-oriented programs, but performance of Panini programs is comparable to their equivalent hand-tuned versions written using Java's fork-join framework.