FROM STATIC TO DYNAMIC PROCESS TYPES

Franz Puntigam

Process types -- a kind of behavioral types -- specify constraints on message acceptance for the purpose of synchronization and to determine object usage and component behavior in object-oriented languages. So far process types have been regarded as a purely static concept for Actor languages incompatible with inherently dynamic programming techniques. We propose solutions of related problems causing the approach to become useable in more conventional dynamic and concurrent languagues. The proposed approach can ensure message acceptability and support local and static checking of race-free programs.

ON STATE CLASSES AND THEIR DYNAMIC SEMANTICS

Ferruccio Damiani, Elena Giachino, Paola Giannini and Emanuele Cazzola

We introduce ""state classes"", a construct to program objects that can be safely concurrently accessed. State classes model the notion of object's ""state"" (intended as some abstraction over the value of fields) that plays a key role in concurrent object-oriented programming (as the ""state"" of an object changes, so does its coordination behavior). We show how state classes can be added to Java-like languages by presenting StateJ, an extension of Java with state classes. The operational semantics of the state class construct is illustrated both at an abstract level, by means of a core calculus for StateJ, and at a concrete level, by defining a translation from StateJ into Java.

ASPECTBOXES – CONTROLLING THE VISIBILITY OF ASPECTS

Alexandre Bergel, Robert Hirschfeld, Siobhán Clarke and Pascal Costanza

Aspect composition is a challenging issue where no agreement cur- rently exist within the aspect oriented programming community. In this paper we present a modular construct for aspects, called aspectboxes, that enables aspects application to be limited to a well defined scope. An aspectbox encapsulates class and aspect definitions. Classes can be imported into an aspect- box defining a base system to which aspects can be applied. Refinements defined by an aspect are visible only within the aspectbox that defines this aspect. Outside this aspectbox, the base system behaves as if there were no aspect.

SOFTWARE IMPLEMENTATION OF THE IEEE 754R DECIMAL FLOATING-POINT ARITHMETIC

Marius Cornea, Cristina Anderson and Charles Tsen

The IEEE Standard 754-1985 for Binary Floating-Point Arithmetic is being revised, and an important addition to the current text is the definition of decimal floating-point arithmetic. This is aimed mainly to provide a robust, reliable framework for financial applications that are often subject to legal requirements concerning rounding and precision of the results in the areas of banking, telephone billing, tax calculation, currency conversion, insurance, or accounting in general. Using binary floating-point calculations to approximate decimal calculations has led in the past to the existence of numerous proprietary software packages, each with its own characteristics and capabilities. New algorithms are presented in this paper which were used for a generic implementation in software of the IEEE 754R decimal floating-point arithmetic, but may also be suitable for a hardware implementation. In the absence of hardware to perform IEEE 754R decimal floating-point operations, this new software package that will be fully compliant with the standard proposal should be an attractive option for various financial computations. Preliminary performance results are included, showing one to two orders of magnitude improvement over a software package currently incorporated in GCC

ON ABILITY OF ORTHOGONAL GENETIC ALGORITHMS FOR THE MIXED CHINESE POSTMAN PROBLEM

Hiroshi Masuyama, Tetsuo Ichimori and Toshihiko Sasama

The well known Chinese Postman Problem has many applications, and this problem has been proved to be NP-hard in graphs where directed and non-directed edges are mixed. In this paper, in order to investigate the salient feature of orthogonal design, we designed a genetic algorithm adopting an orthogonal crossover operation to solve this (mixed Chinese Postman) problem and evaluate the salient ability. The results indicate that for problems of small sizes, the orthogonal genetic algorithm can find near-optimal solutions within a moderate number of generations. We confirmed that the orthogonal design shows better performance, even for graph scales where simple genetic algorithms almost never find the solution. However, only the introduction of orthogonal design is not yet effective for the Chinese Postman Problem of practical size where a solution can be obtained in less than 104 generations. This paper concludes that the optimal design scale of orthogonal array to this mixed Chinese Postman Problem does not conform to the same scale as the multimedia multicast routing problem.

ASSOCIATIVE PROGRAMMING AND MODELING: ABSTRACTIONS OVER COLLABORATION

Bent Bruun Kristensen

Associations as abstractions over collaborations are motivated and explored. Associations are seen as first class concepts at both modeling and programming levels. Associations are seen as concepts/phenomena and possess properties. Various notations for collaboration in object-oriented programming and modeling are discussed and compared to associations. Concurrent and interleaved execution of objects is described in relation to associations.

ZÁS - ASPECT-ORIENTED AUTHORIZATION SERVICES

Paulo Zenida, Manuel Menezes de Sequeira, Diogo Henriques and Carlos Serrão

This paper proposes Zás, a novel, flexible, and expressive authorization mechanism for Java. Zás has been inspired by Ramnivas Laddad's proposal to modularize Java Authentication and Authorization Services (JAAS) using an Aspect-Oriented Programming (AOP) approach. Zás' aims are to be simultaneously very expressive, reusable, and easy to use and configure. Zás allows authorization services to be non-invasively added to existing code. It also cohabits with a wide range of authentication mechanisms. Zás uses Java 5 annotations to specify permission requirements to access controlled resources. These requirements may be changed directly during execution. They may also be calculated by client supplied permission classes before each access to the corresponding resource. These features, together with several mechanisms for permission propagation, expression of trust relationships, depth of access control, etc., make Zás, we believe, an interesting starting point for further research on the use of AOP for authorization.

A DECLARATIVE EXECUTABLE MODEL FOR OBJECT-BASED SYSTEMS BASED ON FUNCTIONAL DECOMPOSITION

Pierre Kelsen

Declarative models are a commonly used approach to deal with software complexity: by abstracting away the intricacies of the implementation these models are often easier to understand than the underlying code. Popular modeling languages such as UML can however become complex to use when modeling systems in sufficient detail. In this paper we introduce a new declarative model, the EP-model, named after the basic entities it contains - events and properties - that possesses the following features: it has a small metamodel; it supports a graphical notation; it can represent both static and dynamic aspects of an application; finally, it allows executable models to be described by annotating model elements with code snippets. By leaving complex parts at the code level this hybrid approach achieves executability while keeping the basic modeling language simple.

AVOIDING TWO-LEVEL SYSTEMS: USING A TEXTUAL ENVIRONMENT TO ADDRESS CROSS-CUTTING CONCERNS

David Greaves

We believe that, owing to the paucity of textual facilities in contemporary HLLs (high-level languages), large software systems frequently require an additional level of meta-programming to sufficiently address their cross-cutting concerns. A programming team can either implement its system by both writing the main application in a slightly customised language and the corresponding customised compiler for it, or it can use a macro pre-processor to provide the remaining cross-cutting requirements not found in the chosen HLL. With either method, a two-level system arises. This paper argues that textual macro-programming is an important cross-cutting medium, that existing proposals for sets of pre-defined AOP (aspect-oriented programming) joinpoints are overly constrictive and that a generalised meta-programming facility, based on a {\em textual environment} should instead be directly embedded in HLLs. The paper presents the semantics of the main additions required in an HLL designed with this feature. We recommend that the textual features must be compiled out as the reference semantics would generally be too inefficient if naively interpreted.