Here is a list of external projects (i.e. projects not in the
Fractal repository) that use Fractal, or that are doing research
on it. The names of ObjectWeb projects are bolded.
|Operating system kernels
is a C implementation targeting the embedded world of the
Fractal component model. It has a toolchain for compiling
and generating code, and a library of system-level components.
|Asynchronous middleware & communication subsystems
is a component-based framework dedicated to the construction
of communication middleware. It provides a component library and
a set of tools to build, configure and deploy middleware
implementing various communication paradigms: group
communications, message passing, event-reaction,
is a component-based framework for building various transaction
services. GoTM support the construction of transaction engine
based on one standard (e.g. Java Transaction Service) or
multiple standards (e.g. Java Transaction Service and Object
a part of JOTM,
is a flexible framework for to make components transactional.
Jironde is based on the use of several component controllers
that manage transactional functionality on behalf of components.
For a component, to be transactional, the only requirement is to
fulfill a component contract which is specific to different
transactional controller implementations. Thanks to the
flexibility and the reflective nature of Fractal, it is possible
to achieve different levels of component transactional
functionality by combining different transactional controllers,
with only taking their component contracts into account.
(Java Open Transaction Demarcation Framework) is about integration
of transaction demarcation functionality in component-oriented
platforms. JOTDF is based on the definition of propagation policies
which defines the scenario to apply for propagating or not the
client transaction context to the component. JOTDF is platform
independent (EJB, CCM, AOP, ...) and transaction manager independent
(JTA, OTS, ...). JOTDF policies are designed as Fractal components
themselves which could be assembled using Fractal ADL.
aims at providing various components that are of general interest
when managing persistency. These components should be used when
constructing different persistence personalities such as EJB/CMP
or JDO. But some components should also be used in other context
that the persistency.
is an open source implementation of the JDO specification.
Speedo uses Fractal to have a clear and modular architecture.
|Middleware for Grid applications
is a Java library for parallel, distributed, and concurrent
computing, also featuring mobility and security in a uniform
framework. With a reduced set of simple primitives, ProActive
provides a comprehensive API allowing to simplify the
programming of applications that are distributed on Local Area
Network (LAN), on cluster of workstations, or on Internet Grids.
ProActive implements the Fractal API to offer components on top
of active objects, in order to facilitate their configuration,
deployment and reconfiguration.
|(EMN-INRIA Obasco, Nokia)
|Distributed systems management
is a framework for the construction of autonomic systems,
following an architecture-based approach. Jade is targeted
towards autonomic management of complex systems including
legacy software. An example of such system is a set of J2EE
servers deployed on a cluster of nodes, each tier of the
system being replicated for better performance and
aims at developing an administration tool dedicated to Java EE
(Apache, JOnAS, EasyBeans, etc.),
MOM (JORAM, ...) or SOA distributed
applications (Orchestra, Bonita, PEtALS,
etc.) in order to facilitate the job of the system
administrator. It relies on advanced management features
and on autonomous behaviour capabilities to reduce the
management costs of such architectures.
is a Java framework dedicated to performance testing of any
kind of system reachable from a JVM. The CLIF framework aims
at supporting the deployment and control of distributed load
injectors, responsible for load/traffic generation on the
system under test, as well as probes giving information about
|Middleware for Enterprise Application Integration
is a lightweight, highly distributed and scalable
Enterprise Service Bus (ESB) platform for both A2A and
|Auto-adaptive EJB servers
|JOnAS A La Carte
is a component-based framework for managing context data in ubiquitous applications.
|Fractal Deployment Framework (FDF)
is an extensible component-based framework to deploy distributed
and heterogeneous software systems.
|FRactal Over OSGiTM (FROGI)
is a proposal to introduce the Fractal component model into
the OSGiTM services platform.
|Fractal Aspect Component (FAC) / Fractal Aspect Component 4 FAROS (F4F)
is an extension of the Fractal component model to support AOP.
It is built as an unification of Component-Based Software
Development (CBSD) and Aspect-Oriented Software Development (AOSD).
is a framework for specifying and checking contracts on
assemblies of Fractal components.
|ARTS (Adaptable and Reflexive Technical Services).
The component-based model is one possible response to the increased
heterogeneity of distributed systems. This model allows developers to
focus on applicative logic and leaves the implementation of the
technical (or non-functional) aspects to the component platform.
However, the technical services themselves do not reap the advantages
provided by the components, particularly as concerns the granularity and
increased reusability that comes from expressing the required APIs as
receptacles and facets. In this project, we propose structuring the
technical services as Fractal components in order to provide adaptable
technical services. Moreover, we try to define ways to use statically
and dynamically those adaptable services thanks to application
construction rules and tools to build such applications.
|NOAH is a framework in which software
entities can communicate without knowing their interlocutors.
Indeed, the implantation code of entities does not need to reference
others entities they interact with. As the communication is abstracted
away (via the ISL language), Noah offers interoperability. On another
hand, Noah can be thought as a dynamic aspect repository with a weaver
using an aspect composition mechanism to ensure commutable and
Nowadays Noah makes Java RMI objects, EJB and .Net components interact
together. We are currently working on an extension so as to take into
account fractal components. A Fractal component will only have to use
a specific controller that manages component interactions to be
Noah-compliant. Due to the externalization of component communication,
one will not need to use "container" controller anymore for primitive
components and one will be able to make a Fractal component cooperate
with others software entities.
| The SATIN
(SAfety model for componenT adaptatIoNs)
project follows the MDA recommendation. Indeed, safety properties
(assembly and behavior composition consistency, semantic of use
preservation, global properties such as deadlock or divergence, ...)
are defined and proven at a meta level that identifies the key elements
implied in the process of component adaptation. Then, the properties
proofs validated on the meta level ensure that no bugs will appear at
runtime after an adaptation has occurred in specific component models
where properties proofs are projected.
We are currently looking at projections into Noah, Fractal/Julia and
Sofa frameworks. As the structure of the Julia model differs on many
points from the Satin model, we target Julia to determine to what
extent the Satin model has the right level of abstraction and is
reusable. On the other hand, this work will provide and assess the
safeness of Julia adaptations.