Host Programming Language Research Articles

AGL: Incorporating behavioral aspects into domain-driven design

Domain-driven design (DDD) aims to iteratively develop software around a realistic domain model. Recent research in DDD has been focusing on using annotation-based domain-specific languages (aDSLs) to build the domain model. However, within current approaches behavioral aspects, that are often represented using UML Activity and State machine diagrams, are not explicitly captured in the domain model. The focus of this paper is to introduce a new approach for incorporating behavioral aspects into domain models within the Domain-Driven Design (DDD) approach. The proposed approach involves using a new activity graph language (AGL) as an aDSL for representing behavioral aspects within a unified domain model. This integration of AGL and the previously developed aDSL (DCSLto represent domain models) aims to achieve three important features of DDD: feasibility, productivity, and understandability. Our approach involves building a unified class model in DCSLwithin a domain-driven architecture, which uses the annotation attachment feature of the host programming language (such as Java) to attach AGL activity graphs directly to the activity class of the unified class model, resulting in a unified domain model. In this work, we define the abstract and concrete syntax of AGL. To demonstrate our method, we use a Java framework called jDomainApp and evaluate AGL through a case study to show that it is expressive and practical for real-world software. This paper presents two contributions. Firstly, it proposes a mechanism to include behavioral aspects in a unified domain model by introducing a new aDSL called AGL to represent domain behaviors. Secondly, it presents a unified modeling method for domain-driven software development. Our method significantly extends the state-of-the-art in DDD in two important fronts: constructing a unified domain model for both structural and behavioral aspects of domain models and bridging the gaps between model and code.

Design and Simulation of a Multilayer Chemical Neural Network That Learns via Backpropagation.

The design and implementation of adaptive chemical reaction networks, capable of adjusting their behavior over time in response to experience, is a key goal for the fields of molecular computing and DNA nanotechnology. Mainstream machine learning research offers powerful tools for implementing learning behavior that could one day be realized in a wet chemistry system. Here we develop an abstract chemical reaction network model that implements the backpropagation learning algorithm for a feedforward neural network whose nodes employ the nonlinear "leaky rectified linear unit" transfer function. Our network directly implements the mathematics behind this well-studied learning algorithm, and we demonstrate its capabilities by training the system to learn a linearly inseparable decision surface, specifically, the XOR logic function. We show that this simulation quantitatively follows the definition of the underlying algorithm. To implement this system, we also report ProBioSim, a simulator that enables arbitrary training protocols for simulated chemical reaction networks to be straightforwardly defined using constructs from the host programming language. This work thus provides new insight into the capabilities of learning chemical reaction networks and also develops new computational tools to simulate their behavior, which could be applied in the design and implementations of adaptive artificial life.

Generating a fluent API with syntax checking from an LR grammar

This paper proposes a fluent API generator for Scala, Haskell, and C++. It receives a grammar definition and generates a code skeleton of the library in the host programming language. The generated library is accessed through a chain of method calls; this style of API is called a fluent API. The library uses the host-language type checker to detect an invalid chain of method calls. Each method call is regarded as a lexical token in the embedded domain specific language implemented by that library. A sequence of the lexical tokens is checked and, if the sequence is not acceptable by the grammar, a type error is reported during compilation time. A contribution of this paper is to present an algorithm for generating the code-skeleton for a fluent API that reports a type error when a chain of method calls to the library does not match the given LR grammar. Our algorithm works in Scala, Haskell, and C++. To encode LR parsing, it uses the method/function overloading available in those languages. It does not need an advanced type system, or exponential compilation time or memory consumption. This paper also presents our implementation of the proposed generator.

Context-Free Session Type Inference

Some interesting communication protocols can be precisely described only by context-free session types, an extension of conventional session types supporting a general form of sequential composition. The complex metatheory of context-free session types, however, hinders the definition of corresponding checking and inference algorithms. In this work, we study a new syntax-directed type system for context-free session types that is easy to embed into a host programming language. We also detail 2 OCaml embeddings that allow us to piggyback on OCaml’s type system to check and infer context-free session types.

A continuation‐based task programming model for C++: design of the Causeway library

SummaryThere is a big class of problems that requires writing programs in an asynchronous manner. Cloud computing, service‐oriented architectures, multi‐core and heterogeneous systems all require programs to be written with asynchronous components. The necessity of concurrency and asynchronous execution brings in the added complexity of the inversion of control into the system, either through message passing or through event processing. In this paper, we introduce explicit programming language support for asynchronous programming that completely hides inversion of control. The presented programming model defines a common abstraction of the different types of tasks, both synchronous and asynchronous. It defines common imperative control constructs equivalent to those of the host programming language, along with a few more advanced ones for transactional and parallel execution that can universally work for any task type. It allows the programmer to implement the logic of an asynchronous system in a natural way by writing simple, seemingly, synchronous imperative code. We will show that the programs written using this approach are easier to understand by programmers. They are also easier to design automated tests for, and for performing computer‐based static analysis of the program logic. The principles behind this approach were tested in a couple of real‐world systems with worldwide user base. Our experience shows that it makes the complex code with a lot of interdependencies between asynchronously executed tasks easy to write and reason about. Copyright © 2016 John Wiley & Sons, Ltd.

Code generation for efficient query processing in managed runtimes

In this paper we examine opportunities arising from the convergence of two trends in data management: in-memory database systems (imdbs), which have received renewed attention following the availability of affordable, very large main memory systems; and language-integrated query, which transparently integrates database queries with programming languages (thus addressing the famous 'impedance mismatch' problem). Language-integrated query not only gives application developers a more convenient way to query external data sources like imdbs, but also to use the same querying language to query an application's in-memory collections. The latter offers further transparency to developers as the query language and all data is represented in the data model of the host programming language. However, compared to imdbs, this additional freedom comes at a higher cost for query evaluation. Our vision is to improve in-memory query processing of application objects by introducing database technologies to managed runtimes. We focus on querying and we leverage query compilation to improve query processing on application objects. We explore different query compilation strategies and study how they improve the performance of query processing over application data. We take C# as the host programming language as it supports language-integrated query through the linq framework. Our techniques deliver significant performance improvements over the default linq implementation. Our work makes important first steps towards a future where data processing applications will commonly run on machines that can store their entire datasets in-memory, and will be written in a single programming language employing language-integrated query and imdb-inspired runtimes to provide transparent and highly efficient querying.

Exception analysis in the Java Native Interface

A Foreign Function Interface (FFI) allows one host programming language to interoperate with another foreign language. It enables efficient software development by permitting developers to assemble components in different languages. One typical FFI is the Java Native Interface (JNI), through which Java programs can invoke native-code components developed in C, C++, or assembly code. Although FFIs bring convenience to software development, interface code developed in FFIs is often error prone because of the lack of safety and security enforcement. This paper introduces a static-analysis framework, TurboJet, which finds exception-related bugs in JNI applications. It finds bugs of inconsistent exception declarations and bugs of mishandling JNI exceptions. TurboJet is carefully engineered to achieve both high efficiency and accuracy. We have applied TurboJet on a set of benchmark programs and identified many errors. We have also implemented a practical Eclipse plug-in based on TurboJet that can be used by JNI programmers to find errors in their code.

Implicit dynamic frames

An important, challenging problem in the verification of imperative programs with shared, mutable state is the frame problem in the presence of data abstraction. That is, one must be able to specify and verify upper bounds on the set of memory locations a method can read and write without exposing that method's implementation. Separation logic is now widely considered the most promising solution to this problem. However, unlike conventional verification approaches, separation logic assertions cannot mention heap-dependent expressions from the host programming language, such as method calls familiar to many developers. Moreover, separation logic-based verifiers are often based on symbolic execution. These symbolic execution-based verifiers typically do not support non-separating conjunction, and some of them rely on the developer to explicitly fold and unfold predicate definitions. Furthermore, several researchers have wondered whether it is possible to use verification condition generation and standard first-order provers instead of symbolic execution to automatically verify conformance with a separation logic specification. In this article, we propose a variant of separation logic called implicit dynamic frames that supports heap-dependent expressions inside assertions. Conformance with an implicit dynamic frames specification can be checked by proving the validity of a number of first-order verification conditions. To show that these verification conditions can be discharged automatically by standard first-order provers, we have implemented our approach in a verifier prototype and have used this prototype to verify several challenging examples from related work. Our prototype automatically folds and unfolds predicate definitions, as required, during the proof and can reason about non-separating conjunction which is used in the specifications of some of these examples. Finally, we prove the soundness of the approach.

Implementing a normalizer using sized heterogeneous types

AbstractIn the simply typed λ-calculus, a hereditary substitution replaces a free variable in a normal formrby another normal formsof typea, removing freshly created redexes on the fly. It can be defined by lexicographic induction onaandr, thus giving rise to a structurally recursive normalizer for the simply typed λ-calculus. We implement hereditary substitutions in a functional programming language with sized heterogeneous inductive types$\Fhat$, arriving at an interpreter whose termination can be tracked by the type system of its host programming language.

A delegation-based approach for the unanticipated dynamic evolution of distributed objects

Large information systems are typically distributed and cater to several client programs, with different needs. Traditional approaches to software development and deployment cannot handle situations where (i) the needs of one client application evolve over time, diverging from the needs of others, and (ii) when the server application cannot be shutdown for maintenance. In this paper, we propose an experimental framework for the unanticipated dynamic evolution of distributed objects that enables us to: (i) extend the behavior of distributed objects during run-time, requiring no shutdown, and (ii) offer different functionalities to different applications simultaneously. In our approach, new client programs can invoke behavioral extensions to server objects that are visible only to them, while legacy applications may continue to use the non-extended versions of the server. Our approach has the advantage of: (i) requiring no changes to the host programming language or to the virtual machine, and (ii) providing a transparent programming model to the developer. In this paper, we describe the problem of unanticipated dynamic evolution of distributed objects, the principles underlying our approach, and our prototype implementations for Java and C#. We conclude by discussing related work, and the extent to which our approach can be used to support industrial strength unanticipated evolution.

Typed iterators for XML

XML transformations are very sensitive to types: XML types describe the tags and attributes of XML elements as well as the number, kind, and order of their sub-elements. Therefore, operations, even simple ones, that modify these features may affect the types of documents. Operations on XML documents are performed by iterators that, to be useful, need to be typed by a kind of polymorphism that goes beyond what currently exists. For this reason these iterators are not programmed but, rather, hard-coded in the languages. However, this approach soon reaches its limits, as the hard-coded iterators cannot cover fairly standard usage scenarios. As a solution to this problem we propose a generic language to define iterators for XML data. This language can either be used as a compilation target (e.g., for XPATH) or it can be grafted on any statically typed host programming language (as long as this has product types) to endow it with XML processing capabilities. We show that our language mostly offers the required degree of polymorphism, study its formal properties, and show its expressiveness and practical impact by providing several usage examples and encodings.

A transactional object calculus

A transaction defines a locus of computation that satisfies important concurrency and failure properties. These so-called ACID properties provide strong serialization guarantees that allow us to reason about concurrent and distributed programs in terms of higher-level units of computation (e.g., transactions) rather than lower-level data structures (e.g., mutual-exclusion locks). This paper presents a framework for specifying the semantics of a transactional facility integrated within a host programming language. The TFJ calculus, an object calculus derived from Featherweight Java, supports nested and multi-threaded transactions. We give a semantics to TFJ that is parametrized by the definition of the transactional mechanism that permits the study of different transaction models. We give two instantiations: one that defines transactions in terms of a versioning-based optimistic concurrency model, and the other which specifies transactions in terms of a pessimistic two-phase locking protocol, and present soundness and serializability properties for our semantics.

Reflective Relational Machines

We propose a model of database programming with reflection (dynamic generation of queries within the host programming language), called the reflective relational machine , and characterize the power of this machine in terms of known complexity classes. In particular, the polynomial time restriction of the reflective relational machine is shown to express PSPACE, and to correspond precisely to uniform circuits of polynomial depth and exponential size. This provides an alternative, logic based formulation of the uniform circuit model, which may be more convenient for problems naturally formulated in logic terms, and establishes that reflection allows for more “intense” parallelism, which is not attainable otherwise (unless P=PSPACE). We also explore the power of the reflective relational machine subject to restrictions on the number of variables used, emphasizing the case of sublinear bounds.

Implementing generalized operator overloading

This paper presents a practical method of adding problem-specific notation to an established computer language. Our idea is to use unrestricted operator overloading as a tool to map the problem domain notation directly into an existing programming language. Our method introduces new operator symbols and function names into a host language by overloading existing usage. We extend the host programming language syntax to an augmented language which is mapped to the host language by a programmable preprocessor. The preprocessor uses a programmer-modifiable symbolic language grammar to translate an augmented program into a standard program. This process gives a natural extension to any computer language without modifying the host language. Direct use of problem notation can improve program legibility and code comprehension within the problem domain. The preprocessor provides a useful research tool for exploring language issues without the need to write a compiler for a new language. It can also be used to provide a domain specific language for a programming group at lower cost than new language development. This paper presents several working examples which illustrate our work. We redefine many of the standard C operators to alleviate some of the more common programming errors, thus creating a ‘cleaner’ C. As a more esoteric example, we encode a subset of APL vector operators as an algebraic extension to the C language. A curious application of our method shows its success in an arbitrary problem domain by compiling and executing poetry. Our final example introduces standard symbolic logic notation into C for tautology verification. © 1998 John Wiley & Sons, Ltd.

Computing with infinitary logic

Most recursive extensions of the first-order queries converge around two central classes of queries: fixpoint and while. Infinitary logic (with finitely many variables) is a very powerful extension of these languages which provides an elegant unifying formalism for a wide variety of query languages. However, neither the syntax nor the semantics of infinitary logic are effective, and its connection to practical query languages has been largely unexplored. We relate infinitary logic to another powerful extension of fixpoint and while, called relational machine, which highlights the computational style of these languages. Relational machines capture the kind of computation occurring when a query language is embedded in a host programming language, as in C+SQL. The main result of this paper is that relational machines correspond to the natural effective fragment of infinitary logic. Other well-known query languages are related to infinitary logic using syntactic restrictions formulated in language-theoretic terms. For example, it is shown that while corresponds to infinitary logic formulas which can be described by a regular language. As a side effect to these results, we obtain interesting normal forms for effective infinitary logic formulas.

SIRIO

This paper presents the SIRIO project, a commercial experience within Spanish industry, developed for Tecnatom S.A. by the Data and Knowledge Bases Research Group at the Technical University of Madrid. SIRIO runs over a heterogeneous local area network, with a client-server architecture, using the following tools: Oracle as RDBMS, running over a Unix server, TCP/IP as a communication protocol, Ethernet TOOLKIT for the distributed client-server architecture, and C as the host programming language for the distributed applications (every one of them is rather complex and very different from the rest). The system uses computers with MS-DOS, connected to the server over the LAN. SIRIO is mainly based on the conceptual design of an Rdb, upon which several distributed applications are operational as big software modules. These applications are: 1.- The inspection programs, the management of their corresponding criteria and the automatic generation of queries. 2.- Graphics processing and interface definition. 3.- Interactive Rdb updating. 4.- Historical db management. 5.- Massive load of on-field obtained data. 6.- Report and query application. The approach of the SIRIO integrated information system presented here is a pioneering one. There are about two dozen companies worldwide in this field and none has developed such an advanced system to this day. From 1992, SIRIO is totally operational in the Tecnatom S.A. industry. It constitutes an important tool to obtain the reports (from different plants) for the clients, for the State control organizations, and for the specialized analyst staff.

Principles for persistent object access

Mechanisms for implementing persistent object access are described. Criteria and opportunities for standardization are identified. Principles are suggested for the development of an object-oriented database. These principles constrain the interaction of embedded DBMS constructs within the host programming language and indicate the appropriate use of existing language features vs. extension of the host language with new features to support persistence.

GESTALT

Many new database applications require computational and data modelling power simply not present in conventional database management systems. Developers are forced to design complex encodings of complex data into a limited set of database types, and to embed DML commands into a host programming language, a notoriously tricky and error-prone enterprise. In this paper, we describe the design and implementation of GESTALT, a system and methodology for organizing and interfacing to multiple heterogeneous, existing database systems. Application programs are written in a supported programming language (currently C and Lisp) using high-level data and control abstractions native to the language. The system is flexible in that the underlying database systems can easily be replaced/upgraded/augmented without affecting existing application programs. We also describe our experience with the system: GESTALT has been in daily operational use at MIT for over a year, supporting an information system for CAF, a research facility for the automation of semiconductor fabrication.

Designing SENSE (a software environment for social science rEsearch)

In most general purpose computer systems there is a wide variety of software available to users. Such software is usually provided in one of three organisational forms - routines in a library; collections of related functions grouped in a package with a common interface; independent programs called through operating system commands. This interdependent tripartite structure creates problems for non-sophisticated users as it involves different levels of user interface complexity.At the routine level a user must write programs in an appropriate host programming language to use the software. If he wishes to use a selection of routines written in incompatible languages then he may have to familiarise himself with more than one host language. In each language he must be aware of the calling conventions for routines, the possible representations of various types of data, the methods of passing parameters and the ways of inputting and outputting data to and from the external environment. This type of interface occurs with libraries like NAG and IMSL. In the case of packages the imperative user interface is usually somewhat simpler, consisting essentially of a name identifying the function required and some associated parameters which identify variables, labels, files, options, control and code values, etc as appropriate. However, function calls of this form must normally be preceded by a non-trivial amount of declarative and other "red tape" information expressed in the package interface language. Also, package environments can be restrictive in that the user is constrained to the types of data structure and analysis supported by the chosen package unless he is prepared to write programs to transform his data for other packages or to analyse it independently. SPSS is typical of this kind of package. When software facilities are provided at the program level, the user interface often consists simply of one-line program invocation commands written in the local operating system's command language, with program options and data files identified by command parameters. Common examples of such facilities are sort and archiving programs. A program level interface becomes even simpler, and at the same time more powerful, if command sequences can be formed into parameterised command procedures and if programs are enabled to conmlunicate directly with one another without the need for explicit intermediate files. In the latter type of environment the application software user generally finds that there are analytic program tools available to meet only some of his requirements. Consequently he has to embrace either or both of the other levels in addition in order to increase the analytic power available to him. Transfer between levels is not easily accomplished in most systems as facilities do not normally exist to help the user move data between levels. This difficulty comes on top of the obvious problem of having to master more than one interface and more than one level of complexity. In the SENSE project (11), which is funded by the U.K. Social Science Research Council, we are creating a prototype computing environment for social science researchers which can accommodate non-sophisticated users. The aim is to provide an integrated environment where such users will have a complete range of application software available (packages, routines and programs) through a single, simple user interface. We believe that this can be achieved by exploiting and extending the concept of software tools propounded by Kernighan and Plauger (19), so that as far as possible all software can be used through a program level interface, with its attendant advantages. Following Kernighan and Plauger we believe that software tools "can be used to create a comfortable and effective interface to existing programs", as well as providing an ideal model for the structuring of brand new application software. This paper will consider various aspects of the initial design of the SENSE software environment with particular reference to the importance of software tools in that design.

Protocol design for interactive raster scan graphic displays

The requirements of a protocol for use with raster scan graphic terminals in an interactive environment are given, the principal requirement being that the terminal should work with any host computer system and programming language. A protocol fulfilling these requirements is described, with particular reference to cursor interrogation facilities, transmission resilience and cadence control. The protocol, by being used for a considerable period in graphics terminals in a wide variety of applications, has proved to have fulfilled the requirements.