Abstract: In existing component models, control originates in components, and connectors are channels for passing on the control to other components. This provides a mechanism for message passing, which allows components to invoke one another's operations by method calls (or remote procedure calls) either directly or indirectly via a channel such as a bus. Thus components in these models mix computation with control, since in performing their computation they also initiate method calls and manage their returns, via connectors. Consequently, in terms of control, components are not loosely coupled. In this paper, we propose exogenous connectors, and demonstrate their use in a small example. In contrast to connectors in existing component models, exogenous connectors initiate calls and manage their returns, and are used to encapsulate control in a component model we are working on. In the example, we demonstrate the feasibility of exogenous connectors, and compare them with connectors in closely related architecture description languages.

Abstract: This article describes NuSCR, a formal software requirements specification method for digital plant protection system in nuclear power plants. NuSCR improves the readability and specifiability by providing graphical or tabular notations depending on the type of operations. NuSCR specifications can be formally analyzed for completeness, consistency, and against the properties specified in temporal logic. We introduce the syntax and semantics of NuSCR and demonstrate the effectiveness of the approach using reactor protection system, digital protection system being developed in Korea, as a case study.

Abstract: Understanding and communicating user requirements in a software requirement analysis effort is very important. Misunderstandings of user requirements between software developers and users, will cause problems in terms of satisfying user needs, defects, cost and schedule during the software development process. This paper proposes a new technique that has the ability to represent the mental models of the user and developer communities as network representations using Pathfinder networks. Graphs (mental models) are generated for each of the user and developer groups and compared for similarities/dissimilarities using a graph similarity metric. This paper overviews how this technique is used to categorize requirements and to identify ambiguous and duplicate requirements. We also propose to extend this technique to enhance communication and reduce misunderstanding surrounding the user requirements during the requirement analysis phase.

Abstract: The embedded systems domain represents a class of systems that have high requirements on cost efficiency as well as run-time properties such as timeliness and dependability. The research on component-based systems has produced component technologies for guaranteeing real-time properties. However, the issue of saving resources by allocating several components to real-time tasks has gained little focus. Trade-offs when allocating components to tasks are, e.g., CPU-overhead, footprint and integrity. In this paper we present a general approach for allocating components to real-time tasks, while utilizing existing real-time analysis to ensure a feasible allocation. We demonstrate that CPU-overhead and memory consumption can be reduced by as much as 48% and 32% respectively for industrially representative systems.

Abstract: The dependability analysis of a component-based system may be driven by the components/system implementation or by the model-based specification provided prior to or together with the implementation. In particular, model-based specifications of a component-based system allows to explicitly model the structure and behavior of components and their integration, while model-based testing allows to derive test sequences which can be successively refined into test cases and then run onto the system implementation.Several techniques have been proposed so far to allow model-based testing. However, very few of them show certain characteristics which are peculiar for use in industrial contexts. We here describe TeStor, a TEst Sequence generaTOR algorithm which allows to extract test sequences from both state machine and scenario diagrams. We detail the algorithm, we apply it to a system study and we provide a link to its implementation.

Abstract: Predicting the performance of component-based applications is difficult due to the complexity of the underlying component technology. This problem is exacerbated when a messaging protocol is introduced to create a loosely coupled software architecture. Messaging uses asynchronous communication, and must address quality of service issues such as message persistence and flow control. In this paper, we present an approach to predicting the performance of Java 2 Enterprise Edition (J2EE) applications using messaging services. The prediction is done during application design, without access to the application implementation. This is achieved by modeling the interactions among J2EE and messaging components using queuing network models, calibrating the performance model with architecture attributes associated with these components, and populating the model parameters using a lightweight, application-independent benchmark. Benchmarking avoids the need for prototype testing in order to obtain the value of model parameters, and thus reduces the performance prediction effort. A case study is carried out to predict the performance of a J2EE application with asynchronous communication. Analysis of the resulting predictions shows the error is within 15%.

Abstract: Component-Based Software Engineering is quickly becoming a mainstream approach to software development. At the same time, there is a massive shift from desktop applications to embedded communicating systems (e.g. PDAs or smartphones): it is especially the case for multimedia applications such as video players, music players, etc. Moreover, embedded communicating systems have to deal with open aspect: applications may come or leave the system on the fly. A key point of these systems is its ability to rigorously manage Quality of Service due to resource constraints.In this paper, we present a component-based QoS architecture well-suited for open systems, called Qinna. Qinna is defined using Fractal components and takes into consideration the main QoS concepts (specification, provision and management). An analysis and an experiment illustrate answers brought by Qinna to open system issues.

Abstract: The grid has emerged as a novel paradigm that supports seamless cooperation of distributed, heterogeneous computing resources in addressing highly complex computing and data management tasks. A number of software technologies have emerged to enable ”grid computing”. However, their exact nature, underlying principles, requirements, and architecture are still not fully understood and remain under-specified. In this paper, we present the results of a study whose goal was to try to identify the key underlying requirements and shared architectural traits of grid technologies. We then used these requirements and architecture in assessing five existing, representative grid technologies. Our studies show a fair amount of deviation by the individual technologies from the widely cited baseline grid architecture. Our studies also suggest a core set of critical requirements that must be satisfied by grid technologies, and highlight a key distinction between ”computational” and ”data” grids in terms of the identified requirements.

Abstract: Software component run-time characteristics are highly dependent on their actual deployment situation. Validating that software components meet required functional and non-functional properties is time consuming and for some properties quite challenging. We describe the use of "validation agents" to automate the testing of deployed software components to verify that component functional and non-functional properties are met. Our validation agents utilise "component aspects" that describe functional and non-functional cross-cutting concerns impacting software components. Aspect information is queried by our validation agents and these construct and run automated tests on the deployed software components. The agents then determine if the deployed components meet their aspect-described requirements. Some agents deploy an existing performance test-bed generation tool to run realistic loading tests on these components. We describe the motivation for our work, how component aspects are designed and encoded, our automated agent-based testing process, the architecture and implementation or our validation agents, and our experiences using them.

Abstract: Software for embedded systems must cope with a variety of stringent constraints, such as real-time requirements, small memory footprints, and low power consumption It is usually implemented using low-level programming languages, and as a result has not benefitted from component-based software development techniques This paper describes a data-centric component model for embedded devices that (i) minimizes the number of concurrent tasks needed to implement the system, (ii) allows one to verify whether components meet their deadlines by applying rate monotonic analysis, and (iii) can generate and verify schedules using constraint logic programming This model forms the foundation for a suite of tools for specifying, composing, verifying and deploying embedded software components developed in the context of the PECOS project

Abstract: AT&T CallVantageSM service is a consumer broadband voice-over-Internet-protocol (VoIP) service. Its feature server has a component-based architecture. This paper is a brief report on our experience with building and deploying advanced telecommunication features using component-based technology.

Abstract: We consider a class of component-based software models with interaction style of buffered asynchronous message passing between components with ports, represented by UML-RT. After building a logical software model, it is necessary to synthesize a multi-threaded implementation that runs on a given target hardware platform and satisfies timing constraints. Commercial code generators generate functional code, but ignore concurrency and timing issues. In this paper, we compare alternative multi-threading strategies for implementation synthesis from this class of software models, and describe real-time scheduling analysis techniques that are useful during design space exploration for implementation synthesis. We use the elevator control application to illustrate our analysis techniques.

Abstract: The rigorous specification of components is necessary to support their selection, adaptation, and integration in component-based software engineering techniques. The specification needs to include the functional and non-functional attributes. The non-functional part of the specification is particularly challenging, as these attributes are often described subjectively, such as Fast Performance or Low Memory. Here, we propose the use of infinite value logic, fuzzy logic, to formally specify components. A significant advantage of fuzzy logic is that it supports linguistic variables, or hedges (e.g., terms such as slow, fast, very fast, etc.), which are convenient for describing non-functional attributes. In this paper, a new systematic approach for the specification of components using fuzzy logic is presented. First, an empirical study is conducted to gather data on five components that provide data compression capabilities; each uses a different algorithm (Arithmetic Encoding, Huffman, Wavelet, Fractal, and Burrows-Wheeler Transform). Data on the response time performance, memory use, compression ratio, and root mean square error are collected by executing the components on a collection of 75 images with different file formats and sizes. The data are fuzzified and represented as membership functions. The fuzzy component specifications are ranked using a set of test queries. Fuzzy multi-criteria decision making algorithms are going to be investigated for the selection of components in the next phase of the work.

Abstract: Searching and subsequently selecting reusable components from component repositories has become a key impediment for not only component-based development but also for achieving the overall usability of component development environments and the ultimate re-usability of the components themselves. Component matching, a fundamental aspect of the component search problem, has been a well-studied problem, resulting in many different matching techniques such as keyword, facet, signature and specification matching techniques. However, each matching technique individually applied for component search often yields a small or large number of (sometimes irrelevant) hits. In this paper, we propose a disciplined combination of the different matching techniques to provide a ranked set of highly qualified components from component repositories. Our work is based on a unique Quality of Match (QoM) metric that measures the overall “goodness” of the match between two given components. In particular, we provide qualitative and quantitative analysis to evaluate the QoM of two given components based on component information. Moreover, we present QoMym, a QoM-based hybrid match algorithm, that combines the strengths of different matching techniques and provides higher accuracy than existing matching techniques.

Abstract: The quality of software components is very important for the overall service quality of the component-based software systems. Several factors make exhaustive testing of components very difficult. Furthermore, the behavioral correctness of each independently produced component does not guarantee the behavioral correctness of the composed software system. Experience shows that there are faults in components which elude the testing effort and do not surface until the system is operating. In this paper, a specification-based software monitor is presented which can be used for detecting certain kinds of errors and failures of a component as well as the whole system while the system is operating. The behavior of each component is assumed to be specified in a formalism based on communicating finite state machines with addressing variables, and inter-component communications are achieved via asynchronous message passing. The monitor passively observes the external input/output and receives partial state information of the target system or component. These are used to interpret the specification. The approach is compositional as it achieves global monitoring by analyzing the behavior of the components of a system individually, and then combining the results obtained from the independent component analyses. The paper describes the architecture and operations of the monitor and includes illustrative examples. Techniques for dealing with non-determinism and concurrency issues in monitoring a concurrent component-based system are also discussed.

Abstract: Interprocedural dataflow analysis has a wide range of uses in software maintenance, testing, verification, and optimization. Despite the large body of research on various analyses, the widespread adoption of these techniques faces serious challenges. In particular, when software is built with reusable components, the standard approaches for dataflow analysis cannot be applied. This paper proposes a model of component-level analysis which generalizes the traditional model of whole-program analysis. We outline the theoretical foundations of component-level analysis, discuss some of the key technical challenges for such analysis, and present initial results from our work on addressing these challenges.

Abstract: After a component based system is developed, it has to be deployed into a target environment. As the system becomes much larger and more complex and the environment becomes open and dynamic, the deployment comes to be a difficult, tiring, error-prone and time-consuming task. This paper proposes an architecture based approach to deploying large-scale component based systems into open and dynamic environments in a systematic and semi-automatic manner. It does four contributions to facilitate the deployment: Firstly, a supporting tool is developed to visualize the software architecture of the system to be deployed to help deployers understand the structure, functions and desired qualities of the system. Secondly, the tool can automatically generate the deployment information from the architecture description produced in the phase of design and this will relieve deployers of inputting hundreds or thousands of deployment elements manually. Thirdly, the tool can monitor the up-to-date resource consumptions of the machines and support to partition one system into several subsystems and deploy the subsystems onto multiple machines simultaneously. Fourthly, a set of principles are proposed for guiding the deployment with the tool. The approach, especially the tool and principles are demonstrated on J2EE (Java 2 Platform Enterprise Edition).

Abstract: State-of-the-art middleware for component-based distributed applications requires openness to support a broad and varying range of services. It also requires powerful and maintainable composition between application logic and middleware services. In this paper we describe DyMAC (Dynamic Middleware with Aspect-Components), a component and aspect-based middleware framework that supports component-based development of middleware services and offers the power of aspect-oriented composition to connect the application logic to the middleware services. We discuss the issue of a lack of expressive power in the contracts of components and aspects when combining component-based and state-of-the-art aspect-oriented development. We describe how the DyMAC framework offers a component model that solves this problem with aspect integration contracts.

Abstract: Voice application development requires specialized speech related skills besides the general programming ability. Encapsulating the speech specific behavior and complexities in prepackaged, configurable User Interface (UI) components will ease and expedite the voice application development. These components can be used across applications and are called as Reusable Dialog Components (RDCs). In this paper we propose a programming model and the framework for developing reusable dialog components. Our framework facilitates the development of voice applications via the encapsulation of interaction mechanisms, the encapsulation of best-of-breed practices (ie. grammars, prompts, and configuration parameters), a modular design and through pluggable dialog management strategies. The framework extends the standard J2EE/JSP based programming model to make it suitable for voice applications.

Abstract: We previously developed a component-oriented model that combines ideas from self-organizing architectures and from design by contract to address the complexity of design in multi-threaded systems. Components in our model are cohesive collections of objects that publish contracts declaring the conditions under which they access other components. These contracts localize a component's contextual synchronization dependencies in its interface. Moreover, the resulting systems permit strong guarantees of safety.This paper reports a case study to validate the efficacy of our model on a realistic design problem: the component-based design of a multi-threaded web server. We first developed a bare-bones web server based on the Apache architecture and then subjected this design to three extension tasks. The study corroborates that our model enables a fine-grain component-based design of multi-threaded applications of realistic complexity, while guaranteeing freedom from certain synchronization errors.

Abstract: This report reflects, from a software engineering perspective, on the experience of designing and implementing protection mechanisms for ASP.NET Web services. The limitations of Microsoft ASP.NET container security mechanisms render them inadequate for hosting enterprise-scale applications that have to be protected according to diverse and/or complex application-specific security policies. In this paper we report on our experience of designing and implementing a component-based architecture for protecting enterprise-grade Web service applications hosted by ASP.NET. Due to its flexibility and extensibility, this architecture enables the integration of ASP.NET into the organizational security infrastructure with less effort by Web service developers. The architecture has been implemented in a real-world security solution. This paper also contributes a best practice on constructing flexible and extensible authentication and authorization logic for Web services by using Resource Access Decision and Attribute Function (AF) architectural styles. Furthermore, the lessons learned from our design and implementation experiences are discussed throughout the paper.

Abstract: Safe and efficient deployment of software components is an important aspect of CBSE. The Nix deployment system enables side-by-side deployment of different versions and variants of components, complete installation, safe upgrades, and safe uninstalls through garbage collection. It accomplishes this through a purely functional deployment model, meaning that the file system content of a component only depends on the inputs used to build it, and never changes afterwards. An apparent downside to this model is that upgrading “fundamental” components used as build inputs by many other components becomes expensive, since all of these must be rebuilt and redeployed. In this paper we show that binary patching between sets of components enables efficient deployment of upgrades in the purely functional model, transparently to users. Sequences of patches can be combined automatically to enable upgrading between arbitrary versions. The approach was empirically validated.

Abstract: Deriving resource properties of components such as memory consumption is a requirement for the specification of non-functional properties of software components, enabling developers to make a selection among components not solely based on their function. In this paper we present a profiler for Enterprise Java Beans components that has been specifically adapted to the characteristics of such components. It facilitates focussing on the component concept whithout getting caught up in the details of the objects that actually constitute a component and offers several views concerning what to attribute to the memory consumption of a component. Our implementation is based on JVMPI and uses filtering inside the agent to generate the component profiles.

Abstract: This paper presents a parallel, component-oriented nuclear power plant simulator kernel It is based on the high-performance computing oriented Common Component Architecture The approach takes advantage of both the component paradigm and the parallel execution of simulation models This way, the maintenance, evolution and efficiency of a simulator are improved The work introduces the main features of the simulator kernel, describing concepts and the model it is based on Data dependencies among components (simulation models conforming a simulator) are solved in a configuration phase, reducing the execution time of the simulation phase Some preliminary results are shown, which anticipate the feasibility, suitability and efficiency of the proposal

Abstract: The concept of responsibility aims at making a computing system trustworthy for its users despite the fact that failures of IT systems cannot be completely excluded. The presented concept comprises the following issues: In case of failures, the responsible stakeholder can be identified and it is ensured that this stakeholder is willing to compensate arisen loss. This enables users to claim damages. Until now, responsibility in this sense is not considered in practical systems. We especially investigate possibilities for integration of responsibility into component-based systems whereas the interests of all involved stakeholders should be considered. The newly introduced concept of tailored responsibility enables users to pose flexible demands for responsibility.

Abstract: The process of starting to use any reuse technology is usually one of the most frustrating factors for novice users. For this reason, tools able to reduce the learning curve are valuable to augment the potential of the technology to rapidly build new applications. In this work, we present Hint, an environment for assisting the instantiation of Java applications based on software agents technology. Hint is built around a software agent that has the knowledge about how to use a reusable asset and, using this knowledge, is able to propose a sequence of programming activities that should be carried out in order to implement a new application satisfying the functionality the user wants to implement. The most relevant contribution of this work is the use of planning techniques to guide the execution of instantiation activities for a given technology.

Abstract: One of the major problems in building large-scale enterprise systems is anticipating the performance of the eventual solution before it has been built. The fundamental software engineering problem becomes more difficult when the systems are built on component technology. This paper investigates the feasibility of providing a practical solution to this problem. An empirical approach is proposed to determine the performance characteristics of component-based applications by benchmarking and profiling. Based on observation, a model is constructed to act as a performance predictor for a class of applications based on the specific component technology. The performance model derived from empirical measures is necessary to make the problem tractable and the results relevant. A case study applies the performance model to an application prototype implemented by two component infrastructures: CORBA and J2EE.

Abstract: This article presents the contracting system ConFract for the open and hierarchical component model Fractal. Contracts are dynamically built from specifications, currently executable assertions, at assembly times, and are updated according to dynamic reconfigurations. These contracts are not restricted to the scope of interfaces, taken separately. On the contrary, new kinds of composition contracts can be built in order to associate several external interfaces of a component, providing an “usage contract”, or several interfaces inside the component, providing an “assembly and implementation contract”. All these contracts identify fine-grained responsibilities and developers can thus easily organize the handling of contract violations and the resulting reconfigurations.