Adel Smeda

An explicit definition of connectors for component-based software architecture

Architecture description languages (ADL) describe systems as a collection of components that interact with each other using connectors. They define components explicitly, however they leave the definition of interactions implicit. Interactions are defined through include files and import and export statements (the connectors are buried inside the components). This implicitly of describing interactions (connectors) makes it difficult to build heterogeneous component-based systems that provide complex functionalities and enroll in complex relations. In this article we present an approach to model and to describe the architecture of component-based systems. It defines connectors as first-class entities. Using this approach one can evolve and reuse not only components but also connectors. We also present some operational mechanisms to permit connectors to be redefined and reused effectively.

MADL: Meta Architecture Description Language

As the concept of meta-classes was introduced in order to permit the manipulation of classes, we introduce the concept of meta-components, meta-connectors, and meta-architectures to permit the manipulation and the redefinition of architectural elements (structural and behavioral). In this article we present a meta-meta-architecture called MADL (Meta Architecture Description Language) to abstract the notions of architectures (components, connectors, architectures), hence to facilitate their manipulation, reuse, and evolution; and also to ease (hence encourage) the transformation and comparison among ADLs.

COSABuilder AND COSAInstantiator: AN EXTENSIBLE TOOL FOR ARCHITECTURAL DESCRIPTION

As software systems grow, their complexity augments rapidly. In consequence their understandability and evolvability are becoming a difficult task. To address this issue, we have previously defined COSA (Component-Object based Software Architecture), which is a software architecture model that describes systems as a collection of components and connectors. However, COSA has been undertaken with academic rather than commercial goals. This paper presents a modeling tool (called COSABuilder) and instantiating tool (called COSAInstantiator) for COSA metamodel and describes their various features. Our contribution is not only offering MDA-based tools but also automatic instantiation and automatic verification of software architecture specifications. The goal is to preserve architecture traceability features in the modeling space and to create accurate architectures.

COSABuilder: an Extensible Tool for Architectural Description

As software systems grow, their complexity augments dramatically. In consequence their understandability and evolvability are becoming a difficult task, therefore a way to describe the architecture of software systems is becoming a must. The architecture of a software system can be described using either an architecture description language (ADL) or an object-oriented modeling language. In this article, we show how we can build a hybrid model, based on the two approaches, to describe the architecture of software systems. This approach profits from the advantages of the two approaches, i.e. the explicit presentation of functional aspects in object-oriented modeling and the explicit separation of competition (components) from interactions (connectors) in architectural description.

MY ARCHITECTURE: A KNOWLEDGE REPRESENTATION META-MODEL FOR SOFTWARE ARCHITECTURE

In this article we show how knowledge representation techniques can be applied to software architecture. We define a representation model for software architecture concepts. The model is based on MY model (meta modeling in Y), which is a knowledge engineering methodology. It represents software architecture concepts using three branches: component, connector, and architecture. The component branch represents concepts that are related to computations, the connector branch represents concepts that are related to interactions, and the architecture branch represents concepts that are related to the structure and the topology of the system described. We think that such a representation of architecture concepts aids in improving reusability not only at the implementation level, but also at the description level. The model assigns a hierarchical library for the four software architecture conceptual levels (meta-meta architecture level, meta architecture level, architecture level, application level).

Operational mechanisms for component-object based software architecture

COSA is an architecture description approach that defines system as a collection of components that interact with each other using connectors. Hence in COSA components and connectors are clearly separated and defined explicitly. By doing this COSA improves the reuse of not only components but also connectors. The reuse and evolve of COSA elements are achieved by using number of operational mechanisms. The basic elements of COSA are: components, connectors, interfaces, configurations, constraints, and properties. COSA describes systems in terms of types and instances. Components, connectors, and configurations are types that can be instantiated to build different architectures.

An automatic transformation from COSA software architecture to CORBA platform

Recently, middleware as an abstraction layer is completely integrated in development environments for resolving heterogeneity and guaranteeing the transparency communication of distributed components. The explicit separation of architecture and implementation is the main concern of the Model Driven Architecture (MDA), aiming to well understanding and controlling interactions and inter-connections among components. This article defines an automatic transformation from COSA (Component-Object based Software Architecture), which is a software architecture model that describes systems as a collection of components and connectors, to a standard platform - CORBA. The goal of our work is rapid mapping and smooth integration of COSA concepts into CORBA middleware platform in order to achieve a higher level of abstraction.

Mapping ADLs into UML 2.0 Using a Meta ADL

In this paper we contribute to the issue of integrating architectural description notations into OMG based modeling techniques using a meta ADL.. The outcome of this work is a meta ADL that helps in approaching issues such as mapping, comparing, and unifying ADLs.

MRED: An Algorithm to Insure High QoS in IP Networks

Abstract—Today’s computer networks support only best-effort service, yet future packet networks will have to support realtime communication services that allow clients to transport information with performance guarantees expressed in terms of delay, delay jitter throughput, and loss rate. Random Early Detection (RED) algorithm is one of the scheduling mechanisms used in IP network. RED is an active queue management scheme that randomly drops packets whenever congestion occurs that results in dropping traffic flow packets that are sensitive to loss. This results in QoS degradation. However, Quality of Service (QoS) is a major factor for a successful business in modern and future network services. In this article, the RED algorithm is modified in order to minimize the packet loss of sensitive traffic flows. Evaluation of the proposed enhancement of the RED algorithm is tested using the Network Simulator (NS-2). Then these results are compared with the current RED algorithm. The proposed model shows ten improvements in QoS of sensitive traffic flows.

Adding Aspects to Software Architecture

An architectural aspect is a concern that spreads across architecture modularity units and cannot be effectively modularized using conventional Architecture Description Languages (ADLs). Dealing with crosscutting concerns is not trivial task since they effect each other and the base architectural decomposition in multiple heterogeneous ways. Lack of ADLs that support modularly representing such aspectual heterogeneous influences leads to a number of architectural breakdowns, such as increased overhead, reduce of reusability, and architectural erosion over the lifetime of the system. In this paper we present Aspectual COSA (ACOSA), a simple and seamless extension of the COSA architectural model to support a modular representation of architectural aspects and their multiple composition forms. ACOSA promotes natural blending of aspects and architectural abstractions by employing a special kind of architectural elements, called Aspectual Component (AC) to encapsulate aspectual behaviors and Aspectual Connector (ACN) to encapsulate both base-component and aspect interactions details.