VOLUME 25 NUMBER 4 2001

Abstracts:

The IRules project at Arizona State University applies active rule technology to the integration of distributed, black-box software components. The goal of IRules is to provide an environment in which an application is developed through the integration of software components using active rules that are known as integration rules. Using the IRules Component Definition Language (CDL), the application integrator first describes a purchased, black-box component within the IRules environment to allow access to the properties and methods defined by the purchased component. In addition, CDL allows for the definition of named extents, stored and derived attributes, externalized relationships and events to enhance the features of the purchased components to support application development. After defining the desired interface for the component, the application integrator then develops the application using active integration rules that define the interaction of the components in response to events. This paper presents the Component Definition Language and its resulting framework that supports the IRules active approach to component-based software integration. (pp. 443-454)

Keywords: component-based integration, active rules, events

This article reports the DEPA (Design Pattern Application) model - a component-based model for applying design patterns (DP) in software development (SD). Prior research has suggested the usefulness of DP in large, complicated SD projects. However, there is still a lack of formal models with which a software engineer could apply DP to SD in a systematic way. The DEPA model is one such formal method that allows systematic applications of DP. We have also illustrated how the DEPA model works in a realistic setting. It shows that the model can be applied to various domains. Further research is suggested in order to develop other models of DP applications. (pp. 455-463)

Keywords: design patterns (DP), software development (SD), component-based software development (CBSD)

Component-based software development has many potential advantages, including shorter time to market and lower price, making it an attractive approach to both customers and producers. However, component-based development is a new technology with many open issues to be resolved. One particular issue is the specification of components as reusable entities, especially for distributed object-oriented applications. Specification of such components by formal methods can pave the way for a more systematic approach for component-based software engineering, including design analysis and simulation. This paper discusses an approach for blending Petri net concepts and object-oriented features to develop a specification approach for distributed component software systems. In particular, a scheme for modeling behavior restriction in the design of object systems is presented. A key result of this work is the definition of a "plug-in" structure that can be used to create "subclass" object models, which correspond to customized components. Algorithms that support the automatic synthesis of these models are provided, discussed, and illustrated by examples.(pp.465-474)

Keywords: Component Customization, Design Models, Distributed Software, Petri Nets

AThis paper presents a component modeling space as a context for supporting component-based software development and accumulating component-related knowledge. The modeling space is structured in three dimensions: A representation dimension that ranges from the languages of problem domains to computer processor languages; a composition dimension that supports a repeating pattern of the whole-part, or system-component, hierarchy; and a generalization dimension that supports reuse of models and components. Also integrated into the modeling space are an interaction model of components and connectors, an approach to component specification, and a provision for relating models via mappings. Each of these elements is characterized as applying in a uniform way throughout the modeling space.(pp. 475-482)

This material is based upon work supported by, or in part by, the U.S. Army Research Office under grant number DAAD19-99-1-0350 and by NSF under grant number CCR-9988168

Keywords: component, composition, generalization, interaction, model, modeling space, representation, specification

Component-based systems require standardization by component models and component platforms providing both an execution environment for software components and core component services. Remote administration and mobile computing require additional support from component platforms. We argue that increased flexibility, especially at run-time, can be achieved by using agent technology and agent platforms as powerful component environments. We present an adaptable component platform which incorporates mobile agent platforms and describe how important issues of component deployment, configuration and security are supported by our environment. (pp. 483-491)

Keywords: component models, distributed components, mobile agents, deployment, remote configuration, component frameworks

This paper presents a mobile-agent-based framework for building mobile compound documents, called MobiDoc, where the compound document can be dynamically composed of mobile agent-based components and can migrate itself over a network as a whole, with all its embedded agents. The key idea of this framework is that it builds a hierarchical mobile agent system that enables multiple mobile agents to be combined into a single one. The framework also provides several value-added mechanisms for visually manipulating components embedded in a compound document and for sharing a window on the screen among the components. This paper describes this framework and its prototype implementation, currently using Java as the implementation language as well as a component development language, and then illustrates several interesting applications to demonstrate the utility and flexibility of this framework.(pp. 493-500)

Keywords: compound document, mobile agent, software component, distributed system

Blocks is an answer to the software engineering needs of the design of knowledge-based system engines. It is a framework composed of reusable and adaptable software components. However, its safe and correct use is complex and we supply formal models and associated tools to assist using it. These models and tools are based on behavioral description of components and on model checking techniques. They ensure a safe reuse of the components, especially when extending them through inheritance, owing to the notion of behavioral refinement. (pp. 501-507)

Keywords: component framework, behavioral model, model checking, artificial intelligence

Commercial-off-the-shelf (COTS) components are black box software products. The absence of their code precludes them from any kind of inspection to certify that the code is safe. This increases the security risk for safety-sensitive applications. The application, before interfacing with COTS component, needs an assurance that it is secure. This paper presents a framework to assure security of components for such applications. This framework uses Aspect Oriented Programming (AOP) paradigm to capture security characteristics of the components and weaves the corresponding security checks into them. It also introduces a novel verification mechanism to ensure that the COTS components are developed as per security contract. (pp. 509-515)

Keywords: Components, Security, Proof Carrying Code, Aspect Oriented Programming

We show how to use AsmL, an executable specification language, to provide behavioral interfaces for components. This allows clients to fully understand the meaning of an implementation without access to the source code. AsmL implements the concept of behavioral subtyping to ensure the substitutability of components and provides many advanced specification features such as generic types, transactional semantics, invariants and history constraints. (pp. 517-526)

Keywords: Specification, Component, Subtyping

The abstract data type (ADT) is the basis for the information-hiding design philosophy that makes software easier to analyze and understand, and that support maintenance and reuse. For these reasons, ADTs can be used to write contracts between specifiers that describe type requirements in an abstract and declarative way and programmers that implement components for these requirements. The construction of components from software specifications could not be a systematic activity if the specification language has powerful abs\-traction and expression capabilities. Therefore, it is very important to study different forms of type specification in order to understand its programming repercussions. The form of specification is essential to consider a type specification as a rigorous and effective functional contract for components between a specifier and a programmer. (pp. 527-532)

Keywords: abstract data type, component, design by contract, correctness, formal specification, cons\-tructive specification

N-version programming (NVP) and acceptance testing (AT) are established methods for obtaining highly reliable results from imperfect software. In NVP, several program modules are executed independently and the final result is derived by voting on the module outputs. In AT (as embodied, for example, in the recovery-block construct), outputs of a program module are subjected to an acceptance test and in the event of failing the test, alternate modules are invoked, until a module produces results that pass the test. Various symmetric combinations of NVP and AT techniques have also been suggested. We have found that a more general view, allowing the insertion of ATs at arbitrary points within a suitably constructed multichannel computation graph can lead to higher reliability and/or greater cost-effectiveness compared to the previously envisaged hybrid schemes such as consensus recovery blocks, recoverable N-version blocks, and N-self-checking programs. Accordingly, we introduce MTV graphs, and their simplified data-driven version called DD-MTV graphs, as component-based frameworks for the creation, representation, and analysis of hybrid NVP-AT schemes. MTV graphs model variations in fault-tolerant software architectures built of computation module (M), acceptance test (T), and voter (V) components. Following the definition of (DD-)MTV graphs, we present several examples of hybrid NVP-AT schemes, as instances of fault-tolerant software based on our component-based approach, and quantify the resulting reliability improvements. We show, for example, that certain, somewhat asymmetric, combinations of M, T, and V components lead to higher reliabilities and/or lower cost than previously proposed symmetric arrangements. We conclude that our component-based approach facilitates design space exploration for fault-tolerant software and leads to reliability improvements due to the double effect of architectural optimization and component refinement afforded by reuse. (pp. 533-543)

Keywords: components, design diversity, fault tolerance, multichannel computation, multiversion software, software reliability, safety, software reuse, weighted voting

Prediction of problematic software components is an important activity today for many organisations as they manage and maintain their legacy systems and the maintenance problems they cause. This means that there is a need for methods and models to identify problematic components. We apply a model for classification of software components as green, yellow and red according to the number of times they required corrective maintenance over successive releases. Further, we apply principal component analysis (PCA) and box plots to investigate the causes for the code decay and structural changes. The case study includes five system releases and 80 software components. A large set of non fault-prone components was identified. The system did not contain any large structural changes, which was indicated by the PCA and the box plots. Most of the changes were small fault corrections. A number of design improvement suggestions had been identified by the developers but not carried out. Overall, the model was successful in identifying the most problematic components and provided information about the evolution of the system. The strength of the model was the combination of both a short-term view and a long-term view. (pp. 545-553)

Keywords: software evolution, fault-prone components, prediction, tracking, legacy systems

This paper reflects a practitioner's view on the present state of component-based software development in eBusiness; the observations are motivated by a recent software effort that created an eBusiness trading system. We observe which types of components significantly increased the speed of our development and which types, while promising, did not realize their potential. Of particular concern here are the reasons the promising components did not work in our application; we reflect on what issues should be addressed when attempting to employ components of this type. (pp. 555-564)

Keywords: e-business, reuse, software engineering

CBD (Component-Based Software Development) has rapidly become a substantial and interesting field in the development of business applications. Because CBD represents a new development paradigm composing applications from software components, increasing requirements for productivity of the flexible systems development can be solved by CBD technologies. It must be recognized that CBD does not mean acquiring parts from anywhere. CBD is a new discipline and there are many associated problems which remain unsolved In this paper, we try to clarify the CBD-related theories as practical techniques to be applied to real systems. So, we suggested technical theories for guidelines management for supporting the development of the CBD process, especially for component development. We focus on setting standards for components and address the impact that CBD has on managing component development. This includes the model management strategy, development and delivery of components, adoption by an organization and the capability to add new releases of components or parts of components. (pp. 565-573)

Keywords: Component-Based Development, management process, independent extensions, cost effective, component repository

Based on the Holonomic Brain Theory by Karl Pribram and related models, an integrated model of conscious image processing is proposed. It optimally incorporates contemporary limited knowledge starting from a systematic search for fit between existing computational models, and between available experimental data, and between data and models. Since we are not yet able to tackle qualitative conscious experience directly, processes for making an image (or result of image processing, respectively) conscious are discussed. 
A quantum implementation of holography-like processing of images in the striate cortex (V1) is proposed using a computational model called quantum associative network. The input to the quantum net could be the Gabor wavelets, together with their coefficients, which are infomax-constrained spectral and sparse neural codes produced in the convolutional cascade along the retino-geniculo-striate visual pathway using the receptive fields as determined by dendritic processes. Perceptual projections are used as argument for holography-like and quantum essence of visual phenomena, because classically (neurally) alone they could not be produced in such a quality. Level-invariant image attractors are argued to be representations to become conscious in/by a subject, after a similar stimulus has triggered the wave-function collapse (i.e., recall from memory). Auxiliary representations for simultaneous subconscious processing, based on phase-information, for associative vision-based cognition are proposed to be Gabor wavelets (i.e., spectral codes in V1 receptive fields, or dendritic trees, respectively) and their coefficients (i.e., sparse codes in activities of V1 neurons). (pp. 575-592)

Keywords: image processing, brain, vision, striate cortex = V1, consciousness, quantum associative net, Pribram