Enabling Transparent Data Sharing in Component Models

Component-based Development (CBD) is an important emerging topic in Software Engineering, promising long sought after benefits like increased reuse and reduced time-to-market (and hence software production cost). However, there are at present many obstacles to overcome before CBD can succeed. For one thing, CBD success is predicated on a standardised market place for software components, which does not yet exist. In fact currently CBD even lacks a universally accepted terminology. Existing component models adopt different component definitions and composition operators. Therefore much research remains to be done. We believe that the starting point for this endeavour should be a thorough study of current component models, identifying their key characteristics and comparing their strengths and weaknesses. A desirable side-effect would be clarifying and unifying the CBD terminology. In this tutorial, we present a clear and concise exposition of all the current major software component models, including a taxonomy. The purpose is to distill and present knowledge of current software component models, as well as to present an analysis of their properties with respect to commonly accepted criteria for CBD. The taxonomy also provides a starting point for a unified terminology.

Modern software development is based on a systems approach, in which a program or software complex is considered as a system of interacting software components. Models of software components are analogs of complex system subsystems. Therefore, a complex program is considered as a system of software components. The organization of the structure of software components affects the quality and result of the program. The organization of interaction between software components affects the efficiency of the program. An important factor in the system of software components is the life cycle, which determines the effectiveness and feasibility of using this program. Software differs from many complex systems and information systems in that it has the ability to increase its life cycle. Moreover, the need to increase the life cycle is characterized by two factors: external and internal. The internal factor arises due to the obsolescence of the program. In this case, it does not meet the new conditions, for example, a new operating system. The external factor arises from external influences in the form of interference or purposeful actions, such as computer viruses. The problem of creating the structure of software components of computing systems and information systems that ensure the duration of the life cycle in the presence of external influences is topical. The study of this problem contributes to the improvement of the technological base of computing systems and information systems that solve applied problems. The article presents a new life cycle model based on two models of growth and degradation. The article recommends a resource-based approach for life cycle assessment. As an analytical solution, it is proposed to use a logistic equation, which describes the mechanisms of the life cycle formation process quite well. The article discusses three types of resource in calculations: physical, technological and communicative. A general redundancy solution is proposed to create a network with the inclusion of a multigraph model.

Extending software component models with the master–worker paradigm

Component bused software engineering (CBSE) represents an exciting and promising paradigm for software development, attracting much interest and effort from industrial practice and scientific research. Software components are one of the key issues in CBSE. While practical, the current component models are limited in providing support for CBSE. We introduce a framework aimed at comprehensive interface modelling for software components in the context of CBSE. This framework deals with interface signature, interface constraints, interface packaging and configurations, and non functional properties of software components.

In early 1960s, intricacy of software systems led to a call for the emergence of the concept of Software Reuse. Rather than building software applications from genesis, software reuse consents creating software systems from existing software. Efficient software reuse programs implemented by the firms may increase their productivity and value, thereby giving the organizations headway. Several reuse metric and models reign the software industry. Reuse assessment commit to high quality and economic system development. Despite its commencement as a potent vision, software reuse has botched to become a part of the typical software engineering practice. The paper is an attempt to articulate the notion of software reuse and the concerning issues. Reusability facet has been conferred analogous to OO paradigm and agile development. Here the concept of reuse has been addressed as a combination of artifacts as well as individual components.

In an effort to manage increasing complexity and to maximise the reuse of code, the software engineering community has recently put a considerable effort into the design and development of component-based software development systems and methodologies. The concept of building software from existing components arose by analogy with the way that hardware is now designed and built, using cheap, reliable standard off-the-shelf modules. Due to the analogy with wiring hardware components, the component-based software development is a natural candidate for visual expression. Various component software technologies have emerged as a result of this attention, but their evolution has been rather ad hoc. In fact, some systems are defined purely by their implementation with little or no precise definition. In an attempt to address this shortcoming, we propose a well-defined syntax and semantics for a component software model that captures the essential concepts.

Component-Based Software Development (CBSD) is an approach that has many benefits, such as improving application developer productivity, reducing costs and complexity by reusing of existing codes. Programming within this approach is like assembly (i.e. composing software out of prefabricated components) rather than development, which reduces skill requirements, and allows expertise focuses on domain problems. The foundation of any CBSD methodology is its underlying component model, which defines what components are, how they can be constructed, and specifies the standards and conventions that are needed to enable composition of independently developed component. The current component models do not support composition in both design and deployment phase. They also focus on the specification and packaging of components but provide almost no support for the easy composition of components. Component in these models uses either direct or indirect message passing as connection schemes, which leads to tightly coupling (i.e. components mix computation with control). It is conclude that this research has proposed an effective way for component composition which provides loosely coupling between composed components. For system maintenance and evolution, this decoupling should make it simpler to manage changes in the components, and also changes in the connector separately. This research has resulted in the proposed of mediator connector which is similar to a communication hub. It initiates method calls and manages the returns, and also provides total loosely coupling between components and also itself. Mediator connector is a framework and can be reused without any modification. The components composition using mediator connector belongs to the deployment phase. Our approach is based on interactions between components as a subset of behavior in a system. In order to minimize coupling between components and mediator connector, we have designed and developed an XML-based language, called Component Interaction Markup Language (CIML), where components as well as their interactions are described in a CIML document which are used by mediator connector. For evaluation of mediator connector in order to measure the loosely coupling it provides, four case studies have been tested. To measure coupling we applied Coupling Between Object (CBO) software metric. The result shows that mediator connector provides totally loosely coupling between software components composing in the deployment phase.

Component-based software development established as an effective technique to cope with the increasing complexity of modern computing systems. In the context of real-time systems, the M-BROE framework has been recently proposed to efficiently support component-based development of real-time applications on multiprocessor platforms in the presence of shared resources. The framework relies on a two-stage approach where software components are first partitioned upon a virtual multiprocessor platform and are later integrated upon the physical platform by means of component interfaces that abstract from the internal details of the applications. This work presents a complete design flow for the M-BROE framework. Starting from a model of software components, a first method is proposed to partition applications to virtual processors and perform a synthesis of multiple component interfaces. Then, a second method is proposed to support the integration of the components by allocating virtual processors to physical processors. Both methods take resource sharing into account. Experimental results are also presented to evaluate the proposed methodology.

Software modules and components have always played a key role in software engineering, primarily as coarse-grained abstractions that embody the principle of information hiding. The fundamental contribution of component-based software engineering lies in making the black-box property a core requirement. In this paper we point out that this important notion tends to be neglected in component model analyses, and define the black-box property in terms of detailed characteristics which help to evaluate component models from this perspective. A survey of typical representatives of industrial and research component models shows that especially the former ones leave much to be desired, and the paper discusses the consequences of the weak aspects of their design.

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.

A Distributed Run-Time Environment for the Kalray MPPA®-256 Integrated Manycore Processor

The software development trend by selecting and assembling commercial off-the shelf (COTS) components is widely accepted. This approach implies that the selected components must not only match application requirements but also work well with each other. These component selection and integration issues are not much addressed in research and commercial world as there is no standardized way to specify component descriptions that will be used for selection and integration of components. This research proposes a metadata model for reusable software components that can be used by component vendors to describe components to be published and by system integrators to specify search criteria for required components. A prototype of the model has been devleoped to employ the proposed metadata description which comprises integration-related attributes, all of which can be used to determine the degree of compatibility between integrated components. With this prototype, specifications of required components are compared with specifications of published components, and the results are the candidate ensembles that match requirement specifications. These ensembles are then ranked by compatibility scores according to predefined integration rules. System integrators can make further decision on the ensemble that best suits their applications based on the results from the prototype. It is expected that this metadata model and its integration approach can be a starting point for a more standardized component specification and deployment in the future.

We combine model learning and model checking in a challenging case study involving Linux, Windows and FreeBSD implementations of TCP. We use model learning to infer models of different software components and then apply model checking to fully explore what may happen when these components (e.g. a Linux client and a Windows server) interact. Our analysis reveals several instances in which TCP implementations do not conform to their RFC specifications.

In this paper we present a novel approach for mapping interconnected software components onto cores of homogenous MPSoC architectures. The analytic mapping process considers shared memory communication as well as the routing algorithm controlling packet-based communication. The software components are mapped with the constraints of avoiding communication conflicts as well as access conflicts to shared memory resources. The core of the elaborated approach consists of an algorithm for software mapping which is inspired by force-directed scheduling from high-level synthesis. Experimental results show that the presented approach increases the overall system performance by 22% while reducing the average communication latency by 35%. For presenting the major advantages of the developed solution, we optimized an advanced driver assistance system on the Tilera TILEPro64 processor.

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.