Contract-based approach to analyze software components

International audienceComponent-based software development focuses on building large software systems by integrating existing software components to reduce cost, risk and time. However, behavioural and compositional conflicts among components constitute a crucial barrier to successful software composition. In this paper, we present a contract-based approach to analyze and model the properties of components and their composition in order to detect and correct composition errors. With this approach we characterize the structural, interface and behavioural aspects, and a specific form of evolution of these components. Enabling this, we propose the use of the LOTOS language as an Architecture Description Language (ADL) for formalising these aspects

Model-Based Run-time Verification of Software Components by Integrating OCL into Treaty

Model Driven Development is used to improve software quality and efficiency by automatically transforming abstract and formal models into software implementations. This is particularly sensible if the model’s integrity can be proven formally and is preserved during the model’s transformation. A standard to specify software model integrity is the Object Constraint Language (OCL). Another topic of research is the dynamic development of software components, enabling software system composition at component run-time. As a consequence, the system’s verification must be realized during system run-time (and not during transformation or compile time). Many established verification techniques cannot be used for run-time verification. A method to enable model-based run-time verification will be developed during this work. How OCL constraints can be transformed into executable software artifacts and how they can be used in the component-based system Treaty will be the major task of this diploma thesis.Modellgetriebene Entwicklung dient der Verbesserung von Qualität und Effizienz in der Software-Entwicklung durch Automatisierung der notwendigen Transformationen von abstrakten bzw. formalen Modellen bis zur Implementierung. Dies ist insbesondere dann sinnvoll, wenn die Integrität der ursprünglichen Modelle formal bewiesen werden kann und durch die Transformation gewährleistet wird. Ein Standard zur Spezifikation der Integrität von Softwaremodellen ist die Object Constraint Language (OCL). Eine weitere Forschungsrichtung im Software-Engineering ist die Entwicklung von dynamischen Komponenten-Modellen, die die Komposition von Softwaresystemen im laufenden Betrieb ermöglichen. Dies bedeutet, dass die Systemverifikation im laufenden Betrieb realisiert werden muss. Die meisten der etablierten Verifikationstechniken sind dazu nicht geeignet. In der Diplomarbeit soll ausgehend von diesem Stand der Technik eine Methode zur modellbasierten Verifikation zur Laufzeit entwickelt werden. Insbesondere soll untersucht werden, wie OCL-Constraints zur Laufzeit in ausführbare Software-Artefakte übersetzt und in dem komponentenbasierten System Treaty verwendet werden können

Business engineering. Generic Software Architecture in an Object Oriented View

The generic software architecture offers a solution for the the information system's development and implementation. A generic software/non-software model could be developed by integrating the enterprise blueprint concept (Zachman) and the object oriented paradigm (Coad's archetype concept). The standardization of the generic software architecture for various specific software components could be a direction of crucial importance, offering the guarantee of the quality of the model and increasing the efficiency of the design, development and implementation of the software. This approach is also useful for the implementation of the ERP systems designed to fit the user’s particular requirements

Unsolved Tricky Issues on COTS Selection and Evaluation

Component Based Software Engineering (CBSE) approach is based on the idea to develop software systems by selecting appropriate components and then to assemble them with a well-defined software architecture. (CBSE) offers developers the twin benefits of reduced software life cycles, shorter development times , saving cost and less effort as compare to build own component. However the success of the component based paradigm depends on the quality of the commercial off-the-shelf (COTS) components purchased and integrated into the existing software systems. It is need of the time to present a quality model that can be used by software programmer to evaluate the quality of software components before integrating them into legacy systems. The evaluation and selection of the COTS components are the most critical process. These evaluation and selection method cannot be resolved by the IT professionals itself. In this study the author tried to compare the twenty three available systematic methods for best evaluation and selection of COTS components

Integrating a Constraint Mechanism With the JavaBeans Model

The JavaBeans component model allows users to plug together software components to create Java applications by specifying simple relationships between component events and properties. This paper describes work on augmenting the simple JavaBeans model with a multi-way constraint mechanism that allows users to graphically specify more complex multi-way contraints, resolve cyclical constraints between bean properties and graphically layout bean components. We also discuss weaknesses in the JavaBeans model and Java Abstract Windowing Toolkit (AWT) that were discovered while integrating a constraint mechanism with JavaBeans

Goal Programming Approach for Selection of COTS Components in Designing a Fault Tolerant Modular Software System under Consensus Recovery Block Scheme

The application of computer systems has now crossed many different fields. Systems are becoming more software intensive. The requirements of the customer for a more reliable software led to the fact that software reliability is now an important research area. One method to improve software reliability is by the application of redundancy. A careful use of redundancy may allow the system to tolerate faults generated during software design and coding thus improving software reliability. The fault tolerant software systems are usually developed by integrating COTS (commercial off-the-shelf) software components. This paper is designed to select optimal components for a fault tolerant modular software system so as to maximize the overall reliability of the system with simultaneously minimizing the overall cost. A chance constrained goal programming model has been designed after considering the parameters corresponding to reliability and cost of the components as random variable. The random variable in this case has been considered as value which has known mean and standard deviation. A chance constraint goal programming technique is used to solve the model. The issue of compatibility among different commercial off-the shelf alternatives is also considered in the paper. Numerical illustrations are provided to demonstrate the model

Business engineering. Generic Software Architecture in an Object Oriented View

The generic software architecture offers a solution for the the information system's development and implementation. A generic software/non-software model could be developed by integrating the enterprise blueprint concept (Zachman) and the object oriented paradigm (Coad's archetype concept). The standardization of the generic software architecture for various specific software components could be a direction of crucial importance, offering the guarantee of the quality of the model and increasing the efficiency of the design, development and implementation of the software. This approach is also useful for the implementation of the ERP systems designed to fit the user’s particular requirements.software engineering, software architecture, object oriented design, archetype, domain-neutral component

COTS-Based Software Product Line Development

Software Product Line (SPL) is at the forefront among the techniques for reducing costs, decreasing schedule time, and ensuring commonality of features across a family of products - as components off-the-shelf (COTS) are reused in multiple products. A disciplined process for software product line development is still needed. We propose the Y-model for COTS-based software product line development. The model put forward identifies and elaborates the essential phases and activities of software product line development from COTS-based repository. The Y-model provides an efficient way of integrating the approaches of software product line and COTS-based development as a cohesive software development model. The model has the potential to tremendously increase software engineers\u27 productivity. Thus software architects, domain engineers and component designers should become aware of how to use these ideas to structure their models and designs. The model has the potential to tremendously increase software engineers\u27 productivity. Thus software architects, domain engineers and component designers should become aware of how to use these ideas to structure their models and designs