This paper presents FRACTAL, a hierarchical and reflective component model with sharing. Components in this model can be endowed with arbitrary reflective capabilities, from plain black-box objects to components that allow a fine-grained manipulation of their internal structure. The paper describes JULIA, a Java implementation of the model, a small but efficient runtime framework, which relies on a combination of interceptors and mixins for the programming of reflective features of components. The paper presents a qualitative and quantitative evaluation of this implementation, showing that component-based programming in FRACTAL can be made very efficient. Copyright © 2006 John Wiley & Sons, Ltd.

The FRACTAL component model and its support in Java

This paper presents FRACTAL, a hierarchical and reflective component model with sharing. Components in this model can be endowed with arbitrary reflective capabilities, from black-boxes to components that allow a fine-grained manipulation of their internal structure. The paper describes JULIA, a Java implementation of the model, a small but efficient run-time framework, which relies on a combination of interceptors and mixins for the programming of reflective features of components. The paper presents a qualitative and quantitative evaluation of this implementation, showing that component-based programming in FRACTAL can be made very efficient.

An open component model and its support in Java

This paper presents Fractal, a hierarchical and reflective component model with sharing. Components in this model can be endowed with arbitrary reflective capabilities, from black-boxes to components that allow a fine-grained manipulation of their internal structure. The paper describes Julia, a Java implementation of the model, a small but efficient run-time framework, which relies on a combination of interceptors and mixins for the programming of reflective features of components. The paper presents a qualitative and quantitative evaluation of this implementation, showing that component-based programming in Fractal can be made very efficient.

An Open Component Model and Its Support in Java

We investigate the combined effect of application implementation method, container design, and efficiency of communication layers on the performance scalability of J2EE application servers by detailed measurement and profiling of an auction site server.We have implemented five versions of the auction site. The first version uses stateless session beans, making only minimal use of the services provided by the Enterprise JavaBeans (EJB) container. Two versions use entity beans, one with container-managed persistence and the other with bean-managed persistence. The fourth version applies the session fasade pattern, using session beans as a fasade to access entity beans. The last version uses EJB 2.0 local interfaces with the session fasade pattern. We evaluate these different implementations on two popular open-source EJB containers with orthogonal designs. JBoss uses dynamic proxies to generate the container classes at run time, making an extensive use of reflection. JOnAS pre-compiles classes during deployment, minimizing the use of reflection at run time. We also evaluate the communication optimizations provided by each of these EJB containers.The most important factor in determining performance is the application implementation method. EJB applications with session beans perform as well as a Java servlets-only implementation and an order-of-magnitude better than most of the implementations based on entity beans. The fine-granularity access exposed by the entity beans limits scalability. Use of session fasade beans improves performance for entity beans, but only if local communication is very efficient or EJB 2.0 local interfaces are used. Otherwise, session fasade beans degrade performance.For the implementation using session beans, communication cost forms the major component of the execution time on the EJB server. The design of the container has little effect on performance. With entity beans, the design of the container becomes important. In particular, the cost of reflection affects performance. For implementations using session fasade beans, local communication cost is critically important. EJB 2.0 local interfaces improve the performance by avoiding the communication layers for local communications.

/pdf/performance-and-scalability-of-ejb-applications-13yyqgcz8m.pdf

Performance and scalability of EJB applications

Component-based programming and component-based system construction have emerged as important topics in software engineering and distributed computer systems, as witnessed by the number of recent papers addressing these themes in the sub fields of software architecture (e.g. [1, 16]), software configuration management (see e.g. [12]), and configurable and reflective distributed systems (see e.g. [2, 4, 15]), not to mention standardized component models such as OMG’s CCM, Sun’s EJB, or Microsoft COM. Components, in these works, are variously understood as units of software configuration, units of dynamic system configuration, units of deployment, units of distribution and mobility, etc. Despite these different works, we believe we are still missing an appropriate basis for the construction of highly flexible, highly dynamic, heterogeneous distributed environments. We attribute that to the failure of the proposed different models to meet several key requirements along several of the practical dimensions identified by Van Hoek et al [20] for the analysis of component-based system models. In particular, several key requirements along the composition dimension (which deals with facilities for modelling a system as a structured set of components) and the dynamism dimension (which deals with facilities for modelling the dynamic changes of a system) are currently insufficiently met. In this paper, we introduce a component model which fares better along the two above dimensions than its predecessors. In particular, it includes a combination of sharing, hierarchy, and an open approach to component composition and binding which we believe to be novel. The paper is organised as follows. Section 2 gathers crucial requirements we identify on a general component model for distributed configurable systems. Section 3 introduces the Fractal model, our proposal for such a general component model. Section 4 introduces a software that we have developed to support the Fractal model and support the programming of Fractal components and systems in Java. Section 5 briefly reports on a first implementation of the Fractal framework. Section 6 concludes the paper.

/pdf/recursive-and-dynamic-software-composition-with-sharing-2qazvph3co.pdf

Recursive and Dynamic Software Composition with Sharing

This paper describes a minimal and modular Object Request Broker (ORB) framework from which it is possible to build highly flexible ORBs supporting the introduction of arbitrary binding mechanisms between interacting objects. We show that such a framework consists essentially of extending the Java notion of object reference to make it distributed. Jonathan is a Java implementation of such a framework, featuring a CORBA 2.0 `personality' and several different binding factories. It could be easily extended with new binding factories and personalities (e.g. a RMI personality) or scaled down to fit particular needs.

https://iopscience.iop.org/article/10.1088/0967-1846/6/1/301/pdf

Jonathan: an open distributed processing environment in Java

This article describes a minimal and modular ORB framework from which highly flexible ORBs supporting the introduction of arbitrary binding mechanisms between interacting objects can be built. This framework essentially extends the Java notion of object reference to make it distributed. Jonathan is a Java implementation of this framework, featuring a CORBA 2.0 "personality" and several different binding factories. It could be easily extended with new binding factories and personalities (e.g. a RMI personality) or scaled down to fit particular needs.

Middleware has emerged as an important architectural component in supporting distributed applications. With the expanding role of middleware, however, a number of problems are emerging. Most significantly, it is becoming difficult for a single solution to meet the requirements of a range of application domains. Hence, the paper argues that the next generation of middleware platforms should be both configurable and re-configurable. Furthermore, it is claimed that reflection offers a principled means of achieving these goals. The paper then presents an architecture for reflective middleware based on a multi-model approach. The main emphasis of the paper is on resource management within this architecture (accessible through one of the meta-models). Through a number of worked examples, we demonstrate that the approach can support introspection, and fine- and coarse- grained adaptation of the resource management framework. We also illustrate how we can achieve multi-faceted adaptation, spanning multiple meta-models.

The Design of a Resource-Aware Reflective Middleware Architecture

This paper presents and discusses the ReTINA approach to distributed object-based middleware It is based on a minimal but highly flexible framework for the construction of Object Request Brokers (ORBs) The ReTINA ORB framework supports the introduction of arbitrary binding mechanisms, including arbitrary communication protocols and communication stacks, and fine-grained control of system-level resources This makes up for a highly scalable ORB (“from mobile phone to mainframe”) which supports the development of applications with temporal quality of service constraints

Bruno Dumant

Papers

Jonathan: an open distributed processing environment in Java

Jonathan: an open distributed processing environment in Java

The Design of a Resource-Aware Reflective Middleware Architecture

The ReTINA DPE Kernel: A Flexible, Real-Time ORB Framework