ObjectWeb Consortium

Advanced Search - Powered by Google

  Consortium     Activities     Projects     Forge     Events 


Project Links
· Home
· Documentation
· Download
· License
· What's New

Developers' Corner
· Workplan
· OW2 GitLab Fractal

· Team
· Users
· Partners
· Mailing List Archive

Fractal community

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
THINK 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
Dream 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, publish-subscribe, etc.
Transaction management
GoTM 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 Transaction Service).
Jironde, 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.
JOTDF (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.
Persistency services
Perseus 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.
Speedo is an open source implementation of the JDO specification. Speedo uses Fractal to have a clear and modular architecture.
JOnAS persistency
Middleware for Grid applications
Proactive 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.
Self-adaptive structures
(EMN-INRIA Obasco, Nokia)
Distributed systems management
Jade 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 availability.
Jasmine 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.
Performance evaluation
CLIF 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 resource consumptions.
Middleware for Enterprise Application Integration
PEtALS is a lightweight, highly distributed and scalable Enterprise Service Bus (ESB) platform for both A2A and B2B integration.
Auto-adaptive EJB servers
JOnAS A La Carte
Context Middleware
COSMOS is a component-based framework for managing context data in ubiquitous applications.
Deployment Middleware
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).
ConFract is a framework for specifying and checking contracts on assemblies of Fractal components.

Research projects

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 associative adaptations.
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.

Copyright © 1999-2009, OW2 Consortium | contact | webmaster | Last modified at 2012-12-03 09:57 PM