Component-based Applications Research Articles

A Graph-based Approach for Deploying Component-based Applications into Channel-based Distributed Environments

With significant advances in software development technologies, it is now possible to have complex software applications, which include a large number of heterogeneous software components distributed over a large network of computers with different computational capabilities. To run such applications, their components must be instantiated on proper hardware resources in their target environments so that user requirements and constraints are also met. This process is called software deployment. However, this process is often challenging for large, distributed, component-based applications with many constraints and requirements. This article presents a graph-based deployment approach that does the deployment with respect to the communication resources required by application components and communication resources available on the hosts in the target environment. In our approach, component-based applications and distributed environments are modeled with the help of graphs. Deployment of an application is then defined as the mapping of the application graph to the target environment graph. This article further discusses how this mapping could be done to minimize the cost and to maximize the reliability of deployments.

Support for development and test of web application: A tree-oriented model

Building an abstract model of the web application is the chief task of software test based on model, which is an efficient way for testing the web application. One problem with current web application test technologies is the lack of tools for modeling the whole web software, especially the lack of support for describing web application from the view of action and function. This paper is concerned with providing the support for development and test of the web application. The presented novel model, named component-based and tree-oriented web application development model (CBTOWADM), abstracts the web application as a tree based on its system function and business process. CBTOWADM not only simplifies the design and development of the web application, but also acts as the model middleware for software test. The basic model definition, the system framework and the application in software test of CBTOWADM is described.

Abstract only

For service providers of multi-tiered component-based applications, such as web portals, assuring high performance and availability to their customers without impacting revenue requires effective and careful capacity planning that aims at minimizing the number of resources, and utilizing them efficiently while simultaneously supporting a large customer base and meeting their service level agreements. This paper presents a novel, hybrid capacity planning process that results from a systematic blending of 1) analytical modeling, where traditional modeling techniques are enhanced to overcome their limitations in providing accurate performance estimates; 2) profile-based techniques, which determine performance profiles of individual software components for use in resource allocation and balancing resource usage; and 3) allocation heuristics that determine minimum number of resources to allocate software components. Our results illustrate that using our technique, performance (i.e., bounded response time) can be assured while reducing operating costs by using 25% less resources and increasing revenues by handling 20% more clients compared to traditional approaches.

Agents, clusters and components: A synergistic approach to the GSP

Grids provide access to a vast amount of computational resources for the execution of demanding computations. These resources are geographically distributed, owned by different organizations and are vastly heterogeneous. The aforementioned factors introduce uncertainty in all phases of a Grid Scheduling Process (GSP). This work describes a synergistic multidisciplinary approach which aims at addressing this uncertainty. It proposes a network of resource representatives (RRs), which maintain the more or less static characteristics of available workers they represent. Clustering techniques are used for the efficient searching in the network of RRs by client agents. After the discovery of possibly suitable resources, client agents and resource agents negotiate directly for the selection of the best available resource set. Finally, according to the characteristics of the selected resource set and its current state, we propose a component-based application configuration approach based on component variants, that adjusts the application for the forthcoming execution phase in the selected resource set. We evaluate our approach using simulation and we show that it outperforms centralized index approaches for large computational grids.

MODELING AND ANALYSIS OF COMPONENT-BASED SOFTWARE SYSTEMS: A GRAPH THEORETIC SYSTEMS APPROACH

Component-oriented paradigm (COP) is becoming popular in the development of present day software. To get the quality of finished product it is necessary to analyze architecture at the early stages of the development life cycle. In the current study, a graph theoretic systems approach to model and analyze component-based software system (CBSS) is presented that describes the characteristics of quality. It proposes a set of analytical tool to capture the notion of structural model as the basis to analyze characteristics of CBSS. A system equation is developed using graph theoretic models which is characteristic of the quality of the CBSS. The current work is an attempt to formulate computationally simple and analytical method to develop the architectural model and analysis of CBSS. The methodology proposed in the study not only takes into account the structure/architecture of the CBSS, but also incorporates interactions among sub-systems (sub-sub-systems up to the component level) effectively. Thus it maintains the inherent characteristics of software architecture models so proposed. By utilizing the approach, two individual CBSS or families of CBSS can also be compared. In the present work, architecture (structure) modeling and analysis of typical component-based web application (CWA) is presented that describes characteristics of quality. The current work also deals with the development/selection of optimum architecture (structural) model of CWA. This can be done using the criteria as discussed in the paper.

Using Genetic Search for Reverse Engineering of Parametric Behavior Models for Performance Prediction

In component-based software engineering, existing components are often reused in new applications. Correspondingly, the response time of an entire component-based application can be predicted from the execution durations of individual component services. These execution durations depend on the runtime behavior of a component which itself is influenced by three factors: the execution platform, the usage profile, and the component wiring. To cover all relevant combinations of these influencing factors, conventional prediction of response times requires repeated deployment and measurements of component services for all such combinations, incurring a substantial effort. This paper presents a novel comprehensive approach for reverse engineering and performance prediction of components. In it, genetic programming is utilized for reconstructing a behavior model from monitoring data, runtime bytecode counts, and static bytecode analysis. The resulting behavior model is parameterized over all three performance-influencing factors, which are specified separately. This results in significantly fewer measurements: The behavior model is reconstructed only once per component service, and one application-independent bytecode benchmark run is sufficient to characterize an execution platform. To predict the execution durations for a concrete platform, our approach combines the behavior model with platform-specific benchmarking results. We validate our approach by predicting the performance of a file sharing application.

Challenges and Solutions for Embedded and Networked Aerospace Software Systems

Aerospace systems are increasingly dependent upon software for their functionality, with associated software spanning a wide range of application domains. These include aircraft and spacecraft flight controls, mission computing, weapons management, command and control, surveillance, sensor management and processing, telemetry, and more. Understanding of their unique challenges has driven technology development on many fronts associated both with the products - such as real-time component-based application frameworks, supporting middleware, and algorithms - and the processes and tools by which they are created - such as model-based development and integration, automated code generation, simulations, and desktop test environments. This paper describes a number of these domains and challenges, future directions associated with networking and systems of systems, and technologies facilitating their development within The Boeing Company.

Formal design and implementation of constraints in software components

This paper deals with the modeling, automatic implementation and runtime verification of constraints in component-based applications. Constraints have been assuming an ever more relevant role in modeling distributed systems as long as business rules implementation, design-by-contract practice, and fault-tolerance requirements are concerned. Nevertheless, component developers are not sufficiently supported by existing tools to model and implement such features. In this paper, we propose a methodology and a set of tools that enable developers both to model component constraints and to generate automatically component skeletons that already implement such constraints. The methodology has been extended to support implementation even in case of legacy components.

Modeling Stream Communications in Component-based Applications

Component technology is a promising approach to develop Grid applications, allowing to design very complex applications by hierarchical composition of basic components. Nevertheless, component applications on Grids have complex deployment models. Performance-sensitive decisions should be taken by automatic tools, matching developer knowledge about component performance with QoS requirements on the applications, in order to find deployment plans that satisfy a Service Level Agreement (SLA). This paper presents a steady-state performance model for component-based applications with stream communication semantics. The model strictly adheres to the hierarchical nature of component-based applications, and is of practical use in launch-time decisions.

Opportunistic Software Deployment in Disconnected Mobile Ad Hoc Networks

This paper presents a middleware platform allowing the dissemination of software components on handheld devices forming a disconnected MANET. It is based on a model that exploits peer-to-peer and opportunistic interactions between neighboring devices to deploy component-based applications, without relying on any kind of infrastructure network. Each device runs a deployment manager, which strive to fill a local component repository with software components so as to be able to satisfy the deployment requests expressed by the user. To do so the deployment manager interacts with peer managers located on neighboring devices, providing its neighbors with copies of software components it owns locally, while obtaining itself from these neighbors copies of components it lacks. The platform also provides communication facilities adapted to disconnected MANETs that notably allow efficient multi-hop exchanges.

Parallel, Distributed and Network-based Computing: an Application Perspective

Parallel, distributed and network-based computing is a continuosly evolving field, driven by progress in microprocessor architecture and interconnection technology, as well as by the needs of computing- and data-intensive applications in science and engineering, and, more recently, in business. This field is currently undergoing a significant change, because of the development of multicore and manycore processors, GPUs, and FPGAs, which are the new building blocks of parallel architectures. At the other end of the parallel and distributed computing scenario, computational grids are far from being a mature infrastructure and are evolving toward cloud computing, to get a higher level of virtualization. The availability of programming models, algorithms and software tools capable of harnessing the processing power offered by the new technologies is a key issue to make them usable by application developers. This special issue provides a view of the efforts carried out in this direction. Barlas introduces an optimization approach for reducing data communication and load imbalance in medical image matching on Grids. Binzenhofer et al. present a distributed and scalable algorithm to monitor a p2p network. Cesario and Talia discuss the use of data mining models and services on Grid systems for analysis of large data repositories. Danelutto et al. describe a performance model for component-based applications with stream communication semantics running on Grids. Danese et al. describe a FPGA-based coprocessor to accelerate double precision floating point operations in high-performance applications. Gross and Marquardt introduce a graphical editor providing abstractions from base technology for user-friendly configuration of Ubiquitous Computing environments. The papers collected here are selected extended versions of papers presented at PDP 2007, the Fifteenth Euromicro Conference on Parallel, Distributed and Network-based Processing, held in Naples, Italy, in February 2007. The conference was organized by the Institute for High-Performance Computing and Networking (ICAR) of the Italian National Research Council (CNR) in collaboration with the Second University of Naples, the University of Naples Parthenope and the University of Naples Federico II. We thank the editors of Scalable Computing: Practice and Experience for providing us the opportunity of publishing this issue, the authors for their contributions, and the referees for their precious help in selecting good-quality papers. Pasqua D'Ambra Institute for High-Performance Computing and Networking (ICAR), CNR Naples, Italy pasqua.dambra@cnr.it Daniela di Serafino Department of Mathematics, Second University of Naples Caserta, Italy daniela.diserafino@unina2.it Mario Rosario Guarracino Institute for High-Performance Computing and Networking (ICAR), CNR Naples, Italy mario.guarracino@cnr.it Francesca Perla Department of Statistics and Mathematics for Economic Research, University of Naples Parthenope Naples, Italy francesca.perla@uniparthenope.it

A layered structure for uniform version management in component based systems

The prerequisite of component-based systems is to manage the life-cycle evolution of software components. As there are multiple versions of constituent components, a need exists to keep track of them. Various version control systems, either in the form of open-source or commercial, are available in the market to maintain the evolution history of multiple versions of constituent components with respect to component-based applications. This paper dis-cusses the requirements of a version control framework and then presents a generic framework that can handle multiple versions of different types of components. The prototype framework named as Visual Version Control Tool (VVCT), for the management of life-cycle evolution of heterogeneous component systems, is developed and tested using .NET environment. The developed tool satisfies all the conditions required for uniform version management and also becomes the basis for version model, which can be used to control the different revisions or variants of the same component in the evolving system.

Healing Web applications through automatic workarounds

We develop the notion of automatic workaround in the context of Web applications. A workaround is a sequence of operations, applied to a failing component, that is equivalent to the failing sequence in terms of its intended effect, but that does not result in a failure. We argue that workarounds exist in modular systems because components often offer redundant interfaces and implementations, which in turn admit several equivalent sequences of operations. In this paper, we focus on Web applications because these are good and relevant examples of component-based (or service-oriented) applications. Web applications also have attractive technical properties that make them particularly amenable to the deployment of automatic workarounds. We propose an architecture where a self-healing proxy applies automatic workarounds to a Web application server. We also propose a method to generate equivalent sequences and to represent and select them at run-time as automatic workarounds. We validate the proposed architecture in four case studies in which we deploy automatic workarounds to handle four known failures in to the popular Flickr and Google Maps Web applications.

Jolt

It has been observed that component-based applications exhibit object churn , the excessive creation of short-lived objects, often caused by trading performance for modularity. Because churned objects are short-lived, they appear to be good candidates for stack allocation. Unfortunately, most churned objects escape their allocating function, making escape analysis ineffective. We reduce object churn with three contributions. First, we formalize two measures of churn, capture and control (15). Second, we develop lightweight dynamic analyses for measuring both capture and control . Third, we develop an algorithm that uses capture and control to inline portions of the call graph to make churned objects non-escaping, enabling churn optimization via escape analysis. JOLT is a lightweight dynamic churn optimizer that uses our algorithms. We embedded JOLT in the JIT compiler of the IBM J9 commercial JVM, and evaluated JOLT on large application frameworks, including Eclipse and JBoss. We found that JOLT eliminates over 4 times as many allocations as a state-of-the-art escape analysis alone.

Using Aspects for Enforcing Formal Architectural Invariants

Formal methods such as Z and Petri nets can be used to specify invariants that should hold during the execution of component-based applications such as those regarding changes in the architecture of the application and valid sequences of architecture reconfigurations. Integrating logic for checking and enforcing these invariants into the application's implementation is generally done by adding appropriate code to the functional application code. In this paper, we discuss several limitations of this approach that may ensue in a disconnection between the application implementation and its formal specification.We propose an approach for specifying and enforcing architectural constraints, which combines formal methods and Aspect-Oriented Programming. We use the Z notation for describing the architectural invariants of the application and Petri nets for modeling coordination protocols. At the implementation level, aspects intercept architecture reconfiguration events and check according to the formal specification and the coordination protocol whether a reconfiguration action can be performed.

Component behavior relativity analysis

Component-Based Development, CBD for short, is becoming a main stream software development paradigm which reuses the off-the-shelf components and assembles them together to form a component-based application. CBD paradigm obviously has aroused a great attention among the engineering and academic domain and many new concepts, tools, and development methodologies have been coming out. However, CBD paradigms are usually questioned by its feasibility and performance. The inherent reason of this dilemma is lacking a methodology to guide researchers or engineers to clarify the behavior relativity among components. In this paper we proposed a new formalism, named component network, which is an extension of Petri net and its powerful capability to modeling distributed system is the guarantee of successful modeling component-based system. Further more, a series operation and theorems are presented, which are concerned to be the footstone of component behavior relativity analysis and software evolution research.

Automated Configuration of Component-based Distributed Real-time and Embedded Systems from Feature Models

Component-based distributed real-time and embedded (DRE) systems facilitate the reuse of software artifacts across applications. To achieve a high-level of reuse, component-based DRE systems leverage late binding to allow dynamic system assembly at deployment time (e.g., via configuration scripts) rather than statically at compile-time. The complexity of deriving a correct manual configuration of an arbitrary set of components, however, is a key source of system failures, downtime, and missed deadlines. This paper presents a model-driven engineering tool called Fresh that uses (1) feature models to codify the configuration rules of components, (2) a constraint solver to derive a correct application configuration, and (3) an XML annotation engine to inject configuration decisions from the constraint solver directly into an application configuration. We use an avionics mission computing case study based on the Lightweight CORBA Component Model (CCM) to (1) demonstrate the complexities of configuring components in/out of a component-based application and (2) motivate the reduction in the configuration complexity when Fresh is used. The results show that Fresh achieves ~80-90% reduction in manual configuration effort, while also ensuring that the derived configuration is correct with respect to application configuration constraints and QoS requirements.

Component-based tailorability: Enabling highly flexible software applications

Component technologies are perceived as an important means to keep software architectures flexible. Flexibility offered by component technologies typically addresses software developers at design time. However, the design of software which should support social systems, such as work groups or communities, also demands ‘use-time’, or technically spoken, ‘run-time’ flexibility. In this paper, we summarize a decade of research efforts on component-based approaches to flexibilize groupware applications at run-time. We address the user as a ‘casual programmer’ who develops and individualizes software for his work context. To deal with the challenges of run-time flexibility, we developed a design approach which covers three levels: software architecture, user interface, and collaboration support. With regard to the software architecture, a component model, called F lexiB eans, has been developed. The F reE volve platform serves as an environment in which component-based applications can be tailored at run-time. Additionally, we have developed three different types of graphical user interfaces, enabling users to tailor their applications by recomposing components. To enable collaborative tailoring activities, we have integrated functions that allow sharing component structures among users. We also present different types of support techniques which are integrated into the user interface in order to enable users’ individual and collaborative tailoring activities. We conclude by elaborating on the notion of ‘software infrastructure’ which offers a holistic approach to support design activities of professional and non-professional programmers.

Micro and macro workflow variability design techniques of component

Components should provide variability in satisfying a variety of domains [ C. Szyperski, Component Software: Beyond Object-Oriented Programming, Addison-Wesley, 2002.], but it is not easy to develop components which can be applied to all domains. Although components are developed by analyzing many different requirements, developing components that satisfy all requirements is difficult since unexpected requirements occur during the utilization of components. Hence, providing the variability of components becomes an important prerequisite for a successful component-based application development. In this paper, we propose a variability design technique that can satisfy the business workflow requirements of many different kinds of domains. The technique addresses a method for designing the variability of the workflow in a more detailed method and uses an object-oriented mechanism and design patterns. One of the most important goals of this technique is to provide a practical process can be effectively applied in component-based application development.

CADeComp: Context-aware deployment of component-based applications

The expansion of wireless communication and mobile hand-held devices makes it possible to deploy a broad range of applications on mobile terminals such as PDAs and mobile phones. The constant context changes of mobile users oblige them to carry out many deployment tasks of the same application in order to obtain an application whose configuration satisfies the context requirements. The difficulty and the frequency of these deployment tasks led us to study the deployment in a mobile environment and to look for a solution for the automation of the deployment adaptation to the context. This paper studies the deployment sensitivity to the context in order to identify the variable deployment parameters and to analyze the impact of the deployment adaptation on the production life cycle of applications. The contribution made by this paper consists in an innovative middleware entity called Context-Aware Deployment of COMPonents (CADeComp), which can be plugged into existing middleware deployment services. CADeComp defines a flexible data model that facilitates the tasks of component producers and application assemblers by allowing them to specify the meta-information required to adapt the deployment to the context. The advantage of CADeComp is that it is based on reliable adaptive mechanisms that are defined by a platform-independent model according to the MDA approach. We propose a mapping of the CADeComp model to CCM. CADeComp was implemented and evaluated on this platform.