Step-wise refinement is a powerful paradigm for developing a complex program from a simple program by adding features incrementally. We present the AHEAD (Algebraic Hierarchical Equations for Application Design) model that shows how step-wise refinement scales to synthesize multiple programs and multiple noncode representations. AHEAD shows that software can have an elegant, hierarchical mathematical structure that is expressible as nested sets of equations. We review a tool set that supports AHEAD. As a demonstration of its viability, we have bootstrapped AHEAD tools from equational specifications, refining Java and non-Java artifacts automatically; a task that was accomplished only by ad hoc means previously.

This paper is concerned with improving the software engineering of agent-based open systems. It critiques the existing Gaia methodology in the light of a motivating example of intelligent home networks. It describes the ROADMAP methodology, which extends Gaia with four improvements - formal models of knowledge and the environment, role hierarchies, explicit representation of social structures and relationships, and incorporation of dynamic changes.

Java Layers extends the Java programming language by implementing a software component model based on layer composition. Each layer implements a single design feature and may contain code that crosscuts multiple classes. Layer composition enables large software applications to be constructed in a more modular way, and with a higher level of semantic checking, than is typically achieved using current programming techniques such as object-oriented frameworks. This paper describes the Java Layers language extension. 1

This paper describes our extension of the UML metamodel for specifying reflective software components. Reflection is a design principle that allows a system to have a representation of itself in the manner that makes it easy to adapt the system to a changing environment. It has matured to the point where it is used to address real-world problems in various areas. We describe how to document reflective components in the fi'amework of UML. Our work allows for recognizing and understanding reflective components in the upper levels of abstraction at an earlier stage of the development process. It leverages the documentation, learning, visual modeling, reuse and roundtrip development of metalevel designs.

In Timor multiple inheritance of methods from a common abstract ancestor (e.g. Collection) and of separate "parts " (possibly repeatedly) from distinct supertypes (e.g. a Radio, a Cassette Player) are handled in different ways. The paper shows that neither technique is suitable for cases where a common concrete ancestor (e.g. Person) is specialised in different subtypes (e.g. as a Student, an Employee) and then brought together in a new subtype, possibly with repeated inheritance (e.g. a Doubly Employed Student). For such cases a new kind of type ("attribute types") is proposed, which provides an alternative programming paradigm to inheritance, based on the idea of adjectives and their use in noun phrases in natural languages. 1

Th- paper proposes Jarcler,whc h is aspect oriented mid dleware for using replicated objects in Java. It enablesth users to customizeth beh vior of replicated objects per class sothW th beh vior fits requirements of a particular application. Althcat reflectionhfl been a typical tech nique for customizing such beh vior,thr paper sh wsth5 reflection forces programmers to write a program far from thom intuition; aspect oriented programming provided by Jarcler makes it easier to describeth customization.Ths paper illustratesthu issuethue-1 an example of simple network game.

Adaptive Object Models are a sophisticated way of building object-oriented systems that let non-programmers customize the behavior of the system and that are most useful for businesses that are rapidly changing. Although systems based on an Adaptive Object Model are often much smaller than competitors, they can be difficult to build and to learn. We believe that the problems with Adaptive Object Models are due in part to a mismatch between their design and the languages that are used to build them. This paper describes how to avoid this mismatch by using implicit and explicit metaclasses.

In this paper we describe services that have been developed in the context of Active Networks, where network nodes can perform customized processing of packets. Two services that use code mobility in several interesting ways are described. The first service allows to connect two disjoint "worlds": the Web, which is connection oriented and where requests and answers follow a fixed protocol, and Active Networks, where communications are achieved by moving small pieces of code. The second service has the purpose of giving Graphical User Interfaces to Active Network applications. In this case Mobile Code is used to propagate events between fixed objects composing the GUI and corresponding "images" of these objects which are located inside the Active Network. Finally we describe a distributed application that uses both these services, where Mobile Code is used to extend the functionalities of the services by hooking event handlers at specific places of a running service. 1 Introduction Rec...

Client-side processing can reduce server/network loads and user wait times for typical web applications by 90% or more. Leveraging JavaScript for these tasks rather than applets or plug-ins provides barrier-free deployment, seamless integration with server-side tools, and W3C standards-compliance, without browser upgrades. This paper introduces the technology underlying TIBET^TM, a JavaScript framework that achieves these goals in 120K, small enough for the EPROMS of embedded web servers but powerful enough to support advanced web applications.

The widespread application of object oriented frameworks for distributed programming lead to their penetration into such areas, where they were not intended to be used before. However, these frameworks basically use synchronous interactions and at most a small and xed set of other invocation semantics; and this is very restricting and even penalising, especially in case of multimedia and mobile communication. In order to comply with the requirements bound to these new areas the framework should allow the developer to extend the circle of applicable invocation abstractions and enable them to exploit the special characteristics of the networking/computing environment and the problem.