Integration of a 1-D river model with object-oriented methodology

This article first details the development of an integrated modelling system (Flow And Solute Transport in Estuaries and Rivers), which is capable of predicting water elevations, velocities and solute and sediment concentration distributions in well-mixed rivers or narrow estuaries. The model comprises hydrodynamic and solute transport solvers, a user-friendly graphical interface—including data management and storage tools—and graphic and tabular reporting facilities. The program, initially written in Fortran, is a numerical modelling program which deploys highly accurate numerical schemes to solve the hydrodynamic and solute transport equations. This model has recently been modified to include a graphical user interface based on an object-oriented methodology, and implemented using the Visual Basic programming language. Details are given herein of the procedures used to combine the Fortran program with a Windows-based programming language, namely Visual Basic. Particular emphasis has been focused on the construction of the interface for unsteady free-surface flow problems. An example application of the model is cited to illustrate the data management capabilities and accuracy of the model when applied to real hydroenvironmental projects.     

The development of GRAMSKIL: A call grammar program for learners of English as a Second Language

To improve the grammatical skills of university-level students in an English as a Second Language (ESL) environment, the authors created a prototype software called GRAMSKIL. GRAM- SKIL differs from the current trend of software development in computer assisted language learning in two ways. Firstly, our program aims to develop grammatical competence instead of communicative competence in ESL learners. Secondly, it adopts the not-so-common approach of using a general purpose software tool—dBase III—to produce the program. GRAMSKIL uses the programming facility of dBase III to design menu-driven tasks which are user-friendly, and so computer novices can run the program without having to learn to run the database package. Moreover, GRAMSKIL allows teachers with little knowledge of database management systems to create their own database or modify the data to tailor them to the needs of their learners.     

How to Comprehend Queries Functionally

Compilers and optimizers for declarative query languages use some form of intermediate language to represent user-level queries. The advent of compositional query languages for orthogonal type systems (e.g., OQL) calls for internal query representations beyond extensions of relational algebra. This work adopts a view of query processing which is greatly influenced by ideas from the functional programming domain. A uniform formal framework is presented which covers all query translation phases, including user-level query language compilation, query optimization, and execution plan generation. We pursue the type-based design—based on initial algebras—of a core functional language which is then developed into an intermediate representation that fits the needs of advanced query processing. Based on the principle of structural recursion we extend the language by monad comprehensions (which provide us with a calculus-style sublanguage that proves to be useful during the optimization of nested queries) and combinators (abstractions of the query operators implemented by the underlying target query engine). Due to its functional nature, the language is susceptible to program transformation techniques that were developed by the functional programming as well as the functional data model communities. We show how database query processing can substantially benefit from these techniques.     

Programming Environment for Phase-Reconfigurable Parallel Programming on SuperNode

This paper presents a programming environment called C_—NET that we have developed for the reconfigurable SuperNode multiprocessor. It shows how one can take advantage of the environment to implement phase-reconfigurable programs. In the first stage a computing model is designed in relation with the capabilities of the hardware. Next, the entire programming environment is built upon this model. It is organized around a kernel language which has been extended in three separate directions so as to provide three specialized languages: PPL (phase programming language) for the development of phase-reconfigurable programs, GCL (graph-construction language) for the construction of processor graphs on which the phases are to be executed, and CPL (component programming language) for coding the software components that are to be executed on the processors within the phases. The second part of the paper provides an illustration of C_—NET. First, two implementations of the conjugate gradient algorithm within C_—NET are carried out: a phase-reconfigurable implementation and a fixed-topology one. Both have been developed on a 32-node machine. Next, a time model is built for both implementations. The time estimates yielded by the models are checked against time measurements issued from program runs. The time models are proved valid and are subsequently used for extrapolation purposes. The speed-up that could be achieved by executing the conjugate gradient algorithm on larger machines (up to 1024) is discussed ultimately.     

A Design for Type-Directed Programming in Java

Type-directed programming is an important and widely used paradigm in the design of software. With this form of programming, an application may analyze type information to determine its behavior. By analyzing the structure of data, many operations, such as serialization, cloning, adaptors and iterators may be defined once, for all types of data. That way, as the program evolves, these operations need not be updated—they will automatically adapt to new data forms. Otherwise, each of these operations must be individually redefined for each type of data, forcing programmers to revisit the same program logic many times during a program's lifetime.The Java language supports type directed programming with the instanceof operator and the Java Reflection API. These mechanisms allow Java programs to depend on the name and structure of the run-time classes of objects. However, the Java mechanisms for type-directed programming are difficult to use. They also do not integrate well with generics, an important new feature of the Java language.In this paper, we describe the design of several expressive new mechanisms for type-directed programming in Java, and show that these mechanisms are sound when included in a language similar to Featherweight Java. Basically, these new mechanisms pattern-match the name and structure of the type parameters of generic code, instead of the run-time classes of objects. Therefore, they naturally integrate with generics and provide strong guarantees about program correctness. As these mechanisms are based on pattern matching, they naturally and succinctly express many operations that depend on type information. Finally, they provide programmers with some degree of protection for their abstractions. Whereas instanceof and reflection can determine the exact run-time type of an object, our mechanisms allow any supertype to be supplied for analysis, hiding its precise structure.     

Mumbo: A Rule-Based Implementation of a Run-time Program Generation Language

We describe our efforts to use rule-based programming to produce a model of Jumbo, a run-time program generation (RTPG) system for Java. Jumbo incorporates RTPG following the simple principle that the regular compiler — or, rather, its back-end — can be used both for ordinary, static compilation and for run-time compilation. This tends to produce a run-time compiler that is inefficient but potentially subject to improvement by partial evaluation. However, the complexity of the language and compiler have made it difficult for us to achieve actual optimization. The model, written in Maude, preserves all the essential ingredients of Jumbo, but operates on a simplified language, called Mumbo. The simplification in the language together with Maude's support for code rewriting has allowed us to make rapid progress. We discuss the model in detail, the kinds of optimizations we have obtained, and the impact on the Jumbo project.     

First-order identities as a defining language

Summary Inverting the adage that a data type is just a simple programming language, we take the position that a programming language is, semantically, just a complex data type; evaluation of a program is just another operation in the data type. The algebraic approach to data types may then be applied. We make a distinction between specification and modelling, and we emphasize the use of first-order identities as a specification language rather than as a tool for model-building. Denotational and operational semantics are discussed. Techniques are introduced for proving the equivalence of specifications. Reynolds' lambda-calculus interpreter is analyzed as an example.     

Proving properties of Pascal programs in MIZAR 2

Summary In this paper we present the so called natural semantics for a subset of Pascal programming language. A set of sentences of first order predicate calculus defines the meaning of the Pascal language constructs. The meaning of a specific program is defined separately by another set of sentences which can be generated automatically. Both these sets together constitute axiomatics of a theory, called the theory of a specific program. The axiomatics is built in such a way that its logical consequences describe all the computational processes defined by the program. Proofs of properties for two small programs are discussed in detail. These properties and their proofs are recorded in the MIZAR 2 language — a computer formalization of predicate calculus. MIZAR 2 proof checker was used to verify the proofs.     

Modeling Reactive Multimedia: Events and Behaviors

This paper explores the idea of reactivity in multimedia, and proposes systems which can react to continuously-evolving behaviors as well as to more traditional discrete events. The idea is presented in a scenario as well as in a number of small programming examples.The illustrative examples are written in the Fran system. Fran provides a high-level programming model for animations, built in the Haskell functional programming language. Whilst we use Fran for illustration—and indeed we argue that the functional paradigm is a natural choice of host for such a system—we should stress that the notion of external behaviors within multimedia is independent of the programming environment chosen and could be incorporated into other systems such as SMIL.     

Leogo: An Equal Opportunity User Interface for Programming

Leogo is a novel programming environment supporting an ‘equal opportunity’ user interface which allows users to express their programming tasks through any mixture of three concurrently active programming paradigms: by direct-manipulation using ‘programming by demonstration’, by clicking buttons and dragging sliders in an iconic language and by typing commands in a normal text-based language. Equal opportunity ensures that the effects of any interface action are simultaneously displayed across each of the three paradigms—input expressions in one paradigm cause output of equivalent expressions in the other two paradigms. Leogo is designed to promote programming skills in primary and junior schools, but the interface properties it demonstrates are applicable to a wide range of novel programming environments. Leogo's motivation, design, development and preliminary usability study are described.     

Virtual time and virtual space

Simulation models involve the concepts oftime andspace. In designing a distribution simulation programming system, introducing a temporal construct results in a specification language for describing a changing world, introducing a spatial construct makes it possible to coordinate multiple, simultaneous, nondeterministic activities.In this paper, we present a new distributed logic programming model and discuss its implementation. A distributed program is represented by avirtual space—a set of process which are logical representations of system objects, and is evaluated with respect tovirtual time—a temporal coordinate which is used to measure computational progress and specify synchronization. The major focus of the implemention is the ability to accomplish global backtracking. The proposed implementation collects global knowledge through interprocess communication, controls global backtracking distributedly according tovirtual time anddependency relations, and capture heuristics in that earlier synchronizations may make subsequent synchronizations more likely to succeed.As compared with other distributed logic programming systems, our system provides a simpler syntax, well-defined semantics, and an efficient implementation.     

Conversation rebuilding: From the foreign language classroom to implementation in an intelligent tutoring system

This paper shows how an innovative “communicative” technique in teaching foreign languages—Conversation Rebuilding (CR)—readily lends itself to implementation in an Intelligent Tutoring System (ITS). Classroom language teachers using CR get students to formulate acceptable utterances in a foreign idiom by starting from rough approximations (using words the students know) and gradually zeroing in on the utterance which a native speaker of that idiom might produce in a similar setting. The ITS presented here helps students do the “zeroing in” optimally. It lets them express themselves temporarily in an “interlingua” (i.e., in their own kind of French or English or whatever they are studying), as long as they make something of their communicative intent clear, that is, as long as the System can find a semantic starting point on which to build. The ITS then prods the students to express themselves more intelligibly, starting from the “key” elements (determined by a heuristic based on how expert classroom teachers proceed) and taking into consideration the students' past successful or unsuccessful attempts at communication. To simplify system design and programming, however, conversations are “constrained”: students playact characters in set dialogs and aim at coming up with what the characters actually say (not what they could possibly say). While most Intelligent Computer Assisted Language Learning (ICALL) focuses the attention of students on norms to acquire, the ICALL implementation of CR presented in this paper focuses the attention of students on saying something—indeed, almost anything—to keep the conversation going and get some kind of meaning across to the other party. It sees successful language acquisition primarily as the association of forms with intent, not simply as the conditioning of appropriate reflexes or the elaboration/recall of conceptualized rules (which are the by-products of successful communication). Thus, in espousing this hard-line communicative approach, the present paper makes a first, non-trivial point: ICALL researchers might usefully begin by investigating what the more able teachers are doing in the classroom, rather than by building elaborate computer simulations of out-dated practices, as happens all too often. The paper then goes on to describe the architecture of a prototype ITS based on CR—one that the authors have actually implemented and tested—for the acquisition of English as a foreign language. A sample learning session is transcribed to illustrate the man-machine interaction. Concluding remarks show how the present-day limits of ICALL (and Artificial Intelligence in general) can be partially circumvented by the strategy implemented in the program, i.e. by making the students feel they are creatively piloting an interaction rather than being tested by an unimaginative machine.     

Avoiding Knotty Structures in Design: Schematic Functional Programming

Designers in general have used diagrams and sketches to help in the process of creation. This is particularly so for system designers whose output is a set of programs. It would seem reasonable that the conversion of diagrams directly into a program would be desirable and yet the work of Green and Petre [3–4, 13] and Citrin [2] has placed doubt on the viability of graphical programming notations. Some of this work is reviewed in this paper. The use of secondary notation and the matc–mismatch hypothesis is reconsidered in the light of functional programming. It is proposed that much of the criticism of graphical notation is due to the imperative (or process orientated) nature of programming. Many of the limitations observed in using graphical notation are lifted when functional programming is used. Eight engineering dimensions and four engineering relationships (coherences) are proposed to describe programming environments (including notation). The source of ‘knotty structures’ is identified as embedded ‘if then else’ or ‘if’ statements. On analysing both imperative and functional programs it was found that imperative programs used an order of magnitude larger number of ‘if’s than functional programs. The key to the success of a functional language as a general representation as well as its coherence with a graphical notation comes from its unique extensibility. Support for these arguments is drawn from examples of a schematic programming language used for industrial scale projects. It is concluded that the marriage between a functional language and its graphical representation overcomes most of the original criticisms of graphical programming. It is demonstrated that this combination makes a viable and expressive tool for industrial-sized applications.     

Towards a Programming Language for Interaction Nets

Interaction nets were introduced almost 15 years ago. Since then they have been put forward as both a graphical programming paradigm and as an intermediate language into which we can compile other languages. Whichever way we use interaction nets, a problem remains in that the language is very primitive. Drawing an analogy with functional programming, we have the λ-calculus but we are missing the functional programming language: syntactic sugar, language constructs, data-structures, etc. The purpose of this paper is to make a first step towards defining such a programming language for interaction nets.     

DWAM — A WAM model extension for disjunctive logic programming

Answering queries in disjunctive logic programming requires the use of ancestry-resolution. The resulting complication makes it difficult to implement a Prolog-type query answering procedure for disjunctive logic programs. However, SLO-resolution provides a mechanism which is similar to SLD-resolution and hence offers a solution to this problem. The Warren Abstract Machine has been a very effective model for implementing Prolog. In this paper, we extend the WAM model of Prolog and adapt it for DISLOG — a language for disjunctive logic programming. We describe the extensions and additional instructions needed to make WAM viable for modeling and executing DISLOG. The extension is made in such a way that the original architecture is not disturbed and a Prolog program will execute as efficiently as it does in the original WAM.This work was done while the author was at the University of Kentucky.     

Fundamental Concepts in Programming Languages

This paper forms the substance of a course of lectures given at the International Summer School in Computer Programming at Copenhagen in August, 1967. The lectures were originally given from notes and the paper was written after the course was finished. In spite of this, and only partly because of the shortage of time, the paper still retains many of the shortcomings of a lecture course. The chief of these are an uncertainty of aim—it is never quite clear what sort of audience there will be for such lectures—and an associated switching from formal to informal modes of presentation which may well be less acceptable in print than it is natural in the lecture room. For these (and other) faults, I apologise to the reader.There are numerous references throughout the course to CPL [1–3]. This is a programming language which has been under development since 1962 at Cambridge and London and Oxford. It has served as a vehicle for research into both programming languages and the design of compilers. Partial implementations exist at Cambridge and London. The language is still evolving so that there is no definitive manual available yet. We hope to reach another resting point in its evolution quite soon and to produce a compiler and reference manuals for this version. The compiler will probably be written in such a way that it is relatively easyto transfer it to another machine, and in the first instance we hope to establish it on three or four machines more or less at the same time.The lack of a precise formulation for CPL should not cause much difficulty in this course, as we are primarily concerned with the ideas and concepts involved rather than with their precise representation in a programming language.     

An empirical study of COBOL programs via a style analyzer: The benefits of good programming style

Despite its prominence as the most widely used programming language in industry, there are only a small number of publications on software metrics applied to COBOL [1]. COBSTYLE, a one-pass, line-by-line style analyzer, written in PL/I, is used to analyze 638 COBOL programs. COBSTYLE differs from other style analyzers [2–4] in that it assesses penalty points for abuses in style, and considers to a larger degree, overall program structure. Mean style scores for 23 style characteristics are obtained. The data produced by COBSTYLE, together with programmer efficiency data, are statistically analyzed, yielding results which empirically demonstrate the benefits of good programming style. COBSTYLE scores are shown to have statistically significant correlations with the following:

1. (a) overall performance (as measured by students' final course grade)—at the 0.005 significance level;

2. (b) program correctness—at the 0.01 significance level;

3. (c) total debugging time—at the 0.05 significance level. An important aspect of this study is the “after-the-fact” nature of the methodology; i.e., none of the participants in this experiment were aware that the programs were to be submitted to a style analyzer for analysis.