Akinori Yonezawa

Abstracting Object Interactions Using Composition Filters

It is generally claimed that object-based models are very suitable for building distributed system architectures since object interactions follow the client-server model. To cope with the complexity of todays distributed systems, however, we think that high-level linguistic mechanisms are needed to effectively structure, abstract and reuse object interactions. For example, the conventional object-oriented model does not provide high-level language mechanisms to model layered system architectures. Moreover, we consider the message passing model of the conventional object-oriented model as being too low-level because it can only specify object interactions that involve two partner objects at a time and its semantics cannot be extended easily. This paper introduces Abstract Communication Types (ACTs), which are objects that abstract interactions among objects. ACTs make it easier to model layered communication architectures, to enforce the invariant behavior among objects, to reduce the complexity of programs by hiding the interaction details in separate modules and to improve reusability through the application of object-oriented principles to ACT classes. We illustrate the concept of ACTs using the composition filters model.

Object-oriented concurrent programming in ABCL/1

An object-oriented computation model is presented which is designed for modelling and describing a wide variety of concurrent systems. In this model, three types of message passing are incorporated. An overview of a programming language called ABCL/1, whose semantics faithfully reflects this computation model, is also presented. Using ABCL/1, a simple scheme of distributed problem solving is illustrated. Furthermore, we discuss the reply destination mechanism and its applications. A distributed “same fringe” algorithm is presented as an illustration of both the reply destination mechanism and the future type message passing which is one of the three message passing types in our computation model.

Reflection in an object-oriented concurrent language

Our work is along the line of the work of B. Smith and P. Maes. We first discuss our notion of reflection in object-oriented concurrent computation and then present a reflective object-oriented concurrent language ABCL/R. We give several illustrative examples of reflective programming such as (1) dynamic concurrent acquisition of “methods” from other objects, (2) monitoring the behavior of concurrently running objects, and (3) augmentation of the time warp mechanism to a concurrent system. Also the definition of a meta-circular interpreter of this language is given as the definition of a meta-object. The language ABCL/R has been implemented. All the examples given in this paper are running on our ABCL/R system.

Bytecode Transformation for Portable Thread Migration in Java

This paper proposes a Java bytecode transformation algorithm for realizing transparent thread migration in a portable and efficient manner. In contrast to previous studies, our approach does not need extended virtual machines nor source code of target programs. The whole state of stack frames is saved, and then restored at a remote site. To accomplish this goal, a type system for Java bytecode is used to correctly determine valid frame variables and valid entries in the operand stack. A target program is transformed based on the type information into a form so that it can perform transparent thread migration. We have also measured execution efficiency of transformed programs and growth in bytecode size, and obtained better results compared to previous studies.

A Simple Extension of Java Language for Controllable Transparent Migration and Its Portable Implementation

A scheme has been developed that enables a Java program to be migrated across computers while preserving its execution state, such as the values of local variables and the dynamic extents of try-and-catch blocks. This scheme provides the programmer with flexible control of migration, including transparent migration. It is based on source-code-level transformation. The translator takes as input code a Java program written in a Java language extended with language constructs for migration, and outputs pure Java source code that uses JavaRMI. The translated code can run on any Java interpreter and can be compiled by any just-in-time compiler. We have measured some execution performance for several application programs, and found that the translated programs are only about 20% slower than the original programs. Because migration is completely controlled by using only three language constructs added to the Java language (go, undock and migratory), the programmer can write programs to be migrated easily and succinctly. Our system is available in the public domain.

Metalevel Architectures and Separation of Crosscutting Concerns

Since version 1.1 of the Java Development Kit, the Java reflective facilities have been successively extended. However, they still prove to be limited. A number of systems (e.g. MetaXa, Guaraná, Kava, Javassist) have addressed this limitation by providing reflective extensions of Java with richer MetaObject Protocols (MOPs). All these extensions provide a particular, monolithic, infrastructure that reflects the commitment of the designer to particular trade-offs between efficiency, portability, expressiveness and flexibility. Unfortunately, these trade-offs are not satisfactory for all applications, since different applications may have different needs. This calls for breaking down the building of a reflective extension into different components that can be specialized in order to fit specific needs. We qualify such a reflective extension as open. In this paper, we present Reflex, a prototype open reflective extension of Java. Reflex can be seen both as a reflective extension of Java and as a first step towards a framework for building such extensions.

Hybrid Group Reflective Architecture for Object-Oriented Concurrent Reflective Programming

The benefits of computational reflection are the abilities to reason and alter the dynamic behavior of computation from within the language framework. This is more beneficial in concurrent/distributed computing, where the complexity of the system is much greater compared to sequential computing; we have demonstrated various benefits in our past research of Object-Oriented Concurrent Reflective (OOCR) architectures. Unfortunately, attempts to formulate reflective features provided in practical reflective systems, such as resource management, have led to some difficulties in maintaining the linguistic lucidity necessary in computational reflection. The primary reason is that previous OOCR architectures lack the ingredients for group-wide object coordination. We present a new OOCR language with a hybrid group reflective architecture, ABCL/R2, whose key features are the notion of heterogeneous object groups and coordinated management of group shared resources. We describe and give examples of how such management can be effectively modeled and adaptively modified/controlled with the reflective features of ABCL/R2. We also identify that this architecture embodies two kinds of reflective towers, individual and group.

Aspectual Caml: an aspect-oriented functional language

We propose an aspect-oriented programming (AOP) language called Aspectual Caml based on a strongly-typed functional language Objective Caml with two AOP mechanisms similar to those in AspectJ language. This paper describes the design and implementation issues of those AOP mechanisms that give us insights into the interaction between AOP features and common features in strongly-typed functional languages such as type inference, polymorphic types and curried functions. We implemented a prototype compiler of the language and used the language for separating crosscutting concerns in application programs, including for separating descriptions of a type system from compiler descriptions.

The Genia Event and Protein Coreference tasks of the BioNLP Shared Task 2011

BackgroundThe Genia task, when it was introduced in 2009, was the first community-wide effort to address a fine-grained, structural information extraction from biomedical literature. Arranged for the second time as one of the main tasks of BioNLP Shared Task 2011, it aimed to measure the progress of the community since 2009, and to evaluate generalization of the technology to full text papers. The Protein Coreference task was arranged as one of the supporting tasks, motivated from one of the lessons of the 2009 task that the abundance of coreference structures in natural language text hinders further improvement with the Genia task.ResultsThe Genia task received final submissions from 15 teams. The results show that the community has made a significant progress, marking 74% of the best F-score in extracting bio-molecular events of simple structure, e.g., gene expressions, and 45% ~ 48% in extracting those of complex structure, e.g., regulations. The Protein Coreference task received 6 final submissions. The results show that the coreference resolution performance in biomedical domain is lagging behind that in newswire domain, cf. 50% vs. 66% in MUC score. Particularly, in terms of protein coreference resolution the best system achieved 34% in F-score.ConclusionsDetailed analysis performed on the results improves our insight into the problem and suggests the directions for further improvements.

Phoenix: a parallel programming model for accommodating dynamically joining/leaving resources

This paper proposes Phoenix, a programming model for writing parallel and distributed applications that accommodate dynamically joining/leaving compute resources. In the proposed model, nodes involved in an application see a large and fixed virtual node name space. They communicate via messages, whose destinations are specified by virtual node names, rather than names bound to a physical resource. We describe Phoenix API and show how it allows a transparent migration of application states, as well as dynamically joining/leaving nodes as its by-product. We also demonstrate through several application studies that Phoenix model is close enough to regular message passing, thus it is a general programming model that facilitates porting many parallel applications/algorithms to more dynamic environments. Experimental results indicate applications that have a small task migration cost can quickly take advantage of dynamically joining resources using Phoenix. Divide-and-conq! uer algorithms written in Phoenix achieved a good speedup with a large number of nodes across multiple LANs (120 times speedup using 169 CPUs across three LANs). We believe Phoenix provides a useful programming abstraction and platform for emerging parallel applications that must be deployed across multiple LANs and/or shared clusters having dynamically varying resource conditions.