Components and connectors are the main building blocks for software architectures. In the design phase of a software system, components can either be created from scratch or reused. When reused, they can either exist on component shelves or identified from existing software systems. Thus, software component identification is one of the primary challenges in component based software engineering. Typically, the identification is done by analyzing existing software artifacts. When considering object-oriented systems, many approaches have been proposed to deal with this issue by identifying a component as a high cohesive and loose coupled set of classes. However, this assumption leads to two main limitations: in one hand, the focus on simple metrics like high cohesion and loose coupling will not necessarily lead to the identification of good quality components. On the other hand, the identified components external structure (provided and required interfaces) is missing. As a result, the identified components can hardly be reused, composed, packaged and documented. To overcome these limitations, we propose in this paper an approach for identifying components based on a fitness function to measure the quality of a component. To evaluate this function, we use a semantic-correctness model defined in our previous works. Also, we propose to identify provided and required interfaces of components.
1 January 2010 in The Journal of Object Technology
Software component identification is one of the primary challenges in component based software engineering. Typically, the identification is done by analyzing existing software artifacts. When considering object-oriented systems, many approaches have been proposed to deal with this issue by identifying a component as a strongly related set of classes. We propose in this paper a comparison between the formulations and the results of two algorithms for the identification of software components: clustering and genetic. Our goal is to show that each of them has advantages and disadvantages. Thus, the solution we adopted is to combine them to enhance the results.
Models@runtime (models at runtime) are based on computation reflection. Runtime models can be regarded as a reflexive layer causally connected with the underlying system. Hence, every change in the runtime model involves a change in the reflected system, and vice versa. To the best of our knowledge, there are no runtime models for Python applications. Therefore, we propose a formal approach based on Petri Nets (PNs) to model, develop, and reconfigure Python applications at runtime. This framework is supported by a tool whose architecture consists of two modules connecting both the model and its execution. The proposed framework considers execution exceptions and allows users to monitor Python expressions at runtime. Additionally, the application behavior can be reconfigured by applying Graph Rewriting Rules (GRRs). A case study using Service-Level Agreement (SLA) violations is presented to illustrate our approach.