Sodany Kiv

A Service-Oriented Framework for Component-Based Software Development: An i* Driven Approach

Optimizing is a fundamental concept in our modern mature economy. Software development also follows this trend and, as a consequence, new techniques are appearing over the years. Among those we find services oriented computing and component based development. The first gives the adequate structure and flexibility required in the development of large industrial software developments, the second allows recycling of generically developed code. This paper is at the borders of these paradigms and constitutes an attempt to integrate components into service-oriented modelling. Indeed, when developing huge multi-actor application packages, solutions to specific problems should be custom developed while others can be found in third party offers. FaMOS-C, the framework proposed in this paper, allows modelling such problems and directly integrates a selection process among different components based on their performance in functional and non-functional aspects. The framework is firstly depicted and then evaluated on a case study in supply chain management.

Agent-driven integration architecture for component-based software development

Developing large and complex information systems with the use of off-the-shelf software components has become fundamental in todays enterprise information systems development. Such an approach does not require to develop the system from scratch but rather to adequately integrate third party software packages into the system under development. In this context, this paper introduces an architectural pattern for components integration. This will be materialized through a multi-agent system (MAS) that will offer an abstraction layer over the components. The MAS will be in charge of the functional decomposition and coordination of the user requests with components at disposal. The originality of the proposed architecture is issued of its configurability with respect to the project-specific business logic and its flexibility to adapt to the changing requirements and environment. The architectural description goes beyond a pure system design by incorporating a description over multiple complementary dimensions.

A multi-agent architectural pattern for wrapping off-the-shelf components

The benefits of off-the-shelf component-based software development are essentially lower cost and shorter development time. Nevertheless, the integration of components is seldom trivial. Indeed, developers can face black boxes or products that are poorly documented and specified. Mismatches between components functionality and system requirements are then difficult to address. To deal with such issues, this paper proposes to use an architectural pattern for wrapping software components. To that extend, we develop a multi-agent system architecture - the wrapper - that offers an abstraction layer over the components. The architecture is in charge of the functional decomposition, coordination and delegation of the client requests to the components at disposal.

Round Tripping in Component Based Software Development

Several approaches have been proposed in literature to develop COTS-based software systems. Most of these focus on a functional and non-functional evaluation to select one or more products needing to be customized for specific requirements. Developping on the basis of components is however constraining for the software users as well as for software developers willing to provide tailored solutions. In this paper we propose a component-based development process using a two level components selection procedure with feedback loops. Analysts select one or more components to fulfill the identified goals and soft goals then a multi-agent system (MAS) managing the business logic delegates them the functional execution. Runtime feedback allows analysts to take decisions for component customization, abandonment or the inclusion of new ones so that equilibrium is found by round tripping between the analysis stage and the MAS execution.