Software Architecture for Correct Components Assembly

This paper describes an approach to the design of a wrapper for self-managing COTS (commercial off-the-shelf) components. Each wrapper for COTS components encapsulates the properties of self-management — detection, reconfiguration, and repair. A COTS component deals with the application perspectives, whereas the wrapper handles the self-management perspectives, separately from the application perspectives. Each wrapper for self-managing COTS components is structured into several objects in support of detection, reconfiguration, and repair of the anomalous COTS components. The approach suggested in this paper is applied to the distributed elevator system consisting of multiple COTS components.

The authors describe their research which improves software reuse by using an automated approach to semantically search for and retrieve reusable software components in large software component repositories and on the World Wide Web (WWW). Using automation and smart (semantic) techniques, their approach speeds up the search and retrieval of reusable software components, while retaining good accuracy, and therefore improves the affordability of software reuse.A program understanding of software components and natural language understanding of user queries was employed. Then the software component descriptions were compared by matching the resulting semantic representations of the user queries to the semantic representations of the software components to search for software components that best match the user queries.A proof of concept system was developed to test the authors' approach. The results of this proof of concept system were compared to human experts, and statistical analysis was performed on the collected experimental data. The results from these experiments demonstrate that this automated semantic‐based approach for software reusable component classification and retrieval is successful when compared to the labor‐intensive results from the experts, thus showing that this approach can significantly benefit software reuse classification and retrieval.

Component-Based Software Development (CBSD) provides a high efficient and low cost way to construct software systems by integrating reusable software components. Although CBSD has already become a widely accepted paradigm, it is still beyond possibility to assemble components easily from commercial-off-the-shelf (COTS) components into one application system. A variety of mismatches between components often impede the integration of COTS components, and component adaptation is becoming a key problem in Component-Based Software Engineering (CBSE). Aiming at this requirement, this paper presents a self-adaptive software architecture (model-based) approach for supporting seamless integration of COTS components. Specifically, we first propose a self-adaptive software architecture model, and then we discuss and exemplify how to eliminate the mismatches between heterogeneous COTS components based on this model. A simplified on-line shopping system is referred throughout the paper to illustrate our approach.

This paper presents and validates a methodology for integrating reusable software components in diverse game engines. While conforming to the RAGE component-based architecture described elsewhere, the paper explains how the interactions and data exchange processes between a reusable software component and a game engine should be implemented for procuring seamless integration. To this end, a RAGE-compliant C# software component providing a difficulty adaptation routine was integrated with an exemplary strategic tile-based game TileZero. Implementations in MonoGame, Unity and Xamarin, respectively, have demonstrated successful portability of the adaptation component. Also, portability across various delivery platforms Windows desktop, iOS, Android, Windows Phone was established. Thereby this study has established the validity of the RAGE architecture and its underlying interaction processes for the cross-platform and cross-game engine reuse of software components. The RAGE architecture thereby accommodates the large scale development and application of reusable software components for serious gaming.

Many regard widespread development and reuse of software components as one of the next biggest phenomena for software. However, widespread reuse of a software component with poor quality may lead to disasters. Improper reuse of software components of good quality may also be disastrous. Testing and quality assurance is therefore critical for both software components and component-based software systems. This tutorial provides an in-depth look at the technical issues, challenges, managerial aspects, and needs in testing of components and systems. Moreover, this tutorial reports on the recent advances and research efforts in developing new solutions to solve those problems and meet those needs, from the perspectives of component-based software engineering. The tutorial will discuss the state-of-the-art practice, issues, and challenges, new solutions and research efforts in third-party component testing, component-based program validation, and test automation. The targeted audience includes technical managers, software testing engineers, quality assurance people, and development engineers who are working on component-based software projects. The tutorial will be useful for professionals, researchers, and students interested in understanding the general concepts and methods in component testing and component-based software validation. This tutorial assumes that participants have a general understanding of software engineering and software testing methods, and have some working experience in software development and validation.

Software in the modern age are mostly developed by the of pre fabricated COTS components as it is the simplest way to develop systems quickly consuming lesser cost as compared to the traditional development approaches. The promising features of component-based-software-engineering (CBSE) have introduced new idea of assembling-software rather than building them.Assembling software in this way alternatively results in rapid development, lesser cost with quality software assembled from pre tested COTS components. However the task is not as easy as it appears apparently. Assembling software from the existing components presents other challenges among which the integration time is the one.Various strategies have been proposed to overcome these mismatches each requiring some external mechanism outside the component to solve them.This paper is an endeavour to provide an integrated approach for resolving time semantic mismatches. It enables COTS components to detect semantic mismatches and resolve them by themselves, thus letting the COTS component itself to participate in mismatch resolution process.The external mediation, in this way, will be reduced up to maximum, resulting in a smooth process with a cut-down in cost. The proposed approach will further enhance the fault tolerance capabilities of COTS components as it is used more and more.

Safety-critical systems and in particular mixed-criticality systems require spatial and temporal separation for their hosted applications and functionalities. Additional constraints are using Commercial Off -- The -- Shelf (COTS) components, portability and determinism. These items are required for economic success for products with low piece numbers and long life-cycles like aircraft. Available embedded processors lack means for spatial separation of Input/Output (I/O) components like an Input/Output Memory Management Unit (IOMMU). The objective of this paper is to provide spatial separation for I/O in COTS mixed-criticality embedded real-time systems like avionics with minimum possible impact on performance (transfer time, transfer rate, Central Processing Unit (CPU) usage). The three main contributions of this paper are: (1) The presented Input/Output Memory Protection Unit (IOMPU) enables to upgrade spatial separation for I/O to a system by using COTS components and Non-Transparent Bridge (NTB) technology. In addition, the IOMPU concept is compatible with existing temporal separation solutions. (2) The paper shows a prototype implementation and a potential use case in context of hardware-based I/O virtualization. (3) The evaluation in this paper demonstrates that the IOMPU concept is practically applicable. The performance overhead (transfer time, transfer rate) is below 0.88%, which is almost negligible, particularly compared to state-of-the-art software-based solutions.

Requirements engineering for COTS based systems

Component based software development (CBSD) endeavors to deliver cost-effective and quality software systems through the selection and integration of commercially available software components. CBSD emphasizes the design and development of software systems using preexisting components. Software component reusability is an indispensable part of component based software development life cycle (CBSDLC), which consumes a significant amount of organization’s resources, that is, time and effort. It is convenient in component based software system (CBSS) to select the most suitable and appropriate software components that provide all the required functionalities. Selecting the most appropriate components is crucial for the success of the entire system. However, decisions regarding software component reusability are often made in an ad hoc manner, which ultimately results in schedule delay and lowers the entire quality system. In this paper, we have discussed the analytic network process (ANP) method for software component selection. The methodology is explained and assessed using a real life case study.

In component-based software engineering research, much effort has gone into developing specification techniques for software components. There exist many software component specification techniques, from interface description language (IDL), to design-by-contract based, to formal methods. However, much of the focus of the research literature is aimed at component specification for the development of components, not their use. The current best practices for component specification ignore information that is vital in determining if an available, ready to use component contains precisely the functional and extra-functional properties required and if that component can be used in the target environment. These specification techniques do not sufficiently support selection and reuse of software components. This paper evaluates some of the current component specification techniques with respect to the needs of component selection and reuse. From this evaluation, some recommendations made as to advancing the development of component specifications to include the purposes of component selection and reuse.

Budget and schedule savings are the driving factors for the adoption of commercial-off-the-shelf (COTS) software components by software development organizations. The reliance on COTS components has lead to component-based development (CBD) software systems and introduced changes to the software development process and hence software project management responsibilities and roles. This paper introduces a general framework discussion of essential management aspects for CBD, focusing on COTS. Particularly, stakeholders, requirements, component selection and architecture management issues are discussed from different angles. Some CBD management guidelines and best practices for these aspects are outlined in the conclusion. In addition, CBD management challenges are drawn along with some suggestions in the conclusion section.

Scientific missions in the Earth sciences frequently require cost-effective, highly reliable, and easy-to-use software, which can be a challenge for software developers to provide. The NASA Earth Science Enterprise (ESE) spends a significant amount of resources developing software components and other software development artifacts that may also be of value if reused in other projects requiring similar functionality. In general, software reuse is often defined as utilizing existing software artifacts. Software reuse can improve productivity and quality while decreasing the cost of software development, as documented by case studies in the literature. Since large software systems are often the results of the integration of many smaller and sometimes reusable components, ensuring reusability of such software components becomes a necessity. Indeed, designing software components with reusability as a requirement can increase the software reuse potential within a community such as the NASA ESE community. The NASA Earth Science Data Systems (ESDS) Software Reuse Working Group is chartered to oversee the development of a process that will maximize the reuse potential of existing software components while recommending strategies for maximizing the reusability potential of yet-to-be-designed components. As part of this work, two surveys of the Earth science community were conducted. The first was performed in 2004 and distributed among government employees and contractors. A follow-up survey was performed in 2005 and distributed among a wider community, to include members of industry and academia. The surveys were designed to collect information on subjects such as the current software reuse practices of Earth science software developers, why they choose to reuse software, and what perceived barriers prevent them from reusing software. In this paper, we compare the results of these surveys, summarize the observed trends, and discuss the findings. The results are very similar, with the second, larger survey confirming the basic results of the first, smaller survey. The results suggest that reuse of ESE software can drive down the cost and time of system development, increase flexibility and responsiveness of these systems to new technologies and requirements, and increase effective and accountable community participation.

This paper presents an approach to incorporating collaboration among process actors as a major construct for business process modeling. Furthermore collaboration is realized as a reusable software component. This provides today's workflow management systems with an opportunity to integrate collaboration with their existing process execution to realize full co-operation support for business process management. A collaboration-centric application framework based on a reusable collaboration component and a multi-agent platform is proposed. A description of how it was refined through use in a succession of applications used to trial team-working with various groups of mobile workers is included to show the usefulness and maturity of the approach. Finally some information is given in regards to the productisation of the enterprise mobilization platform of which the collaboration-centric application framework is a component.

The most important goal in hard real-time systems is to guarantee that all timing constraints are satisfied. Even though object-based techniques (which contain reusable software components) are used to manage the complexity in the software development process of such systems, execution efficiency may have to be sacrificed, due to the large number of procedure calls and contention for accessing software components. These issues are addressed by the following parallelizing techniques: converting potentially inefficient procedure calls to a source of concurrency via asynchronous remote procedure calls (ARPC); and replicating (or cloning) software components to reduce the contention. The existing object-based scheduling algorithms construct an initial schedule and apply incremental parallelization techniques to modify the initial schedule until a feasible schedule is generated. These algorithms are applicable for scheduling only multiple independent tasks. This paper describes a pre-run-time scheduling algorithm for a set of periodic object-based tasks having precedence constraints among them. The algorithm employs parallelism exploitation techniques to guarantee timeliness in almost fully predictable environments such as factory automation, aerospace, and avionics. It allocates the components of object-based periodic tasks to the sites of a distributed system based on a clustering heuristic which takes into account the ARPC parallelism and load balancing, and schedules them on respective sites.

KAPSEL is a new object-oriented programming language to encourage the building of reusable software components. The components, i.e. classes, establish clear boundaries between their implementation detail and their outside-visible specification. The underlying software concept employed is that of encapsulation: the close integration and protection of information and its functionality. The paper explores the basic idea of encapsulation in object-oriented methodology: as it applies to objects, classes and class hierarchies, and introduces the programming language-KAPSEL-which facilitates the specification of reusable object-oriented software components.