4,441 research outputs found
AO-OpenCom: an AO-Middleware architecture supporting flexible dynamic reconfiguration
Middleware has emerged as a key technology in the construction of distributed systems. As a consequence, middleware is increasingly required to be highly modular and configurable, to support separation of concerns between services, and, crucially, to support dynamic reconfiguration: i.e. to be capable of being changed while running. Aspect-oriented middleware is a promising technology for the realisation of distributed reconfiguration in distributed systems. In this paper we propose an aspect-oriented middleware platform called AO-OpenCom that builds AO-based reconfiguration on top of a dynamic component approach to middleware system composition. The goal is to support extremely flexible dynamic reconfiguration that can be applied at all levels of the system and uniformly across the distributed environment. We evaluate our platform by the capability in meeting flexible reconfiguration and the impact of these overheads
Recommended from our members
Towards an aspect weaving BPEL engine
This position paper proposes the use of dynamic aspects and
the visitor design pattern to obtain a highly configurable and
extensible BPEL engine. Using these two techniques, the
core of this infrastructural software can be customised to
meet new requirements and add features such as debugging,
execution monitoring, or changing to another Web Service
selection policy. Additionally, it can easily be extended to
cope with customer-specific BPEL extensions. We propose
the use of dynamic aspects not only on the engine itself
but also on the workflow in order to tackle the problems of
Web Service hot deployment and hot fixes to long running
processes. In this way, composing aWeb Service "on-the-fly"
means weaving its choreography interface into the workflow
Multi-Platform Generative Development of Component & Connector Systems using Model and Code Libraries
Component-based software engineering aims to reduce software development
effort by reusing established components as building blocks of complex systems.
Defining components in general-purpose programming languages restricts their
reuse to platforms supporting these languages and complicates component
composition with implementation details. The vision of model-driven engineering
is to reduce the gap between developer intention and implementation details by
lifting abstract models to primary development artifacts and systematically
transforming these into executable systems. For sufficiently complex systems
the transformation from abstract models to platform-specific implementations
requires augmentation with platform-specific components. We propose a
model-driven mechanism to transform platform-independent logical component &
connector architectures into platform-specific implementations combining model
and code libraries. This mechanism allows to postpone commitment to a specific
platform and thus increases reuse of software architectures and components.Comment: 10 pages, 4 figures, 1 listin
A methodology for component-based system integration
Component-based software based on software architectures is emerging to be the next generation software development paradigm. The paradigm shifts the development focus from lines-of-codes to coarser-grained components and the interconnections among them. It consists of system architecture design, architecture description, component search and system integration from components to generate a software system.
However, one of the bottlenecks in this paradigm is the integration of the individual components into the overall system. In this dissertation a methodology for component-based system integration is proposed. It is based on an architectural aggregation view, a component model, flowgraphs and cyclomatic complexity. We introduce this view, model, and new ways to compute cyclomatic complexity based on flowgraphs.
The methodology makes use of Jackson diagram to represent the detailed design of a system and decomposes the system into components and aggregations. An aggregation is a set of components glued together by one connector, and is represented as a flowgraph. Then an aggregation flowgraph is decomposed into prime flowgraphs called prime connections. An Implementation Description Language (IDL) is introduced to represent the aggregations and components. Finally a system synthesis mechanism is proposed that is responsible for translating prime connections, embedding functional units into them, and composing aggregations and the integrated system from them
Model-Driven Development of Aspect-Oriented Software Architectures
The work presented in this thesis of master is an approach that takes advantage of the Model-Driven Development approach for developing aspect-oriented software architectures. A complete MDD support for the PRISMA approach is defined by providing code generation, verification and reusability properties.PĂ©rez BenedĂ, J. (2007). Model-Driven Development of Aspect-Oriented Software Architectures. http://hdl.handle.net/10251/12451Archivo delegad
- âŠ