Abstract: Expanding deadlines and escalating costs have notoriously plagued the game industry. Although the majority of the game development costs are spent on art and animation, significant cost reductions and more importantly reductions in development time can be achieved when developers use off the shelf components rather than develop them from scratch. However, many game developers struggle with component integration and managing the complexity of their architectures. This paper gives an overview of developing games with components, presents a reference architecture that outlines the relevant areas of reuse and signifies some of the problems with developing components unique to the domain of games.

Abstract: A key issue with Web Services (WS) is the verification and validation (V&V) of services to build trust between service providers and service users. This paper proposed a test-broker architecture so that all stakeholder within WS can contribute to improve the testing of the services. The test broker supports the submission, indexing, and querying of test artifacts such as test cases, defect reports and evaluations. It can also provide the services for the test generation, test coordination, and distributed testing services. The DCV&V (Decentralized, Collaborative, Verification and Validation) framework is proposed with a set of distributed and collaborated test brokers dedicated to different V&V tasks to enable scalable and flexible test collaborations. The paper explores the concept of design-by-contract and applies the principle to DCV&V. It identifies two categories of testing contracts including TSC (Testing Service Contracts) and TCC (Test Collaboration Contracts). It illustrates the application of TSC with contract-based test generation based on WS OWL-S specification. It elaborates TCC with the analysis of the test artifacts definitions.

Abstract: Supporting dynamic reconfiguration is required even in highly constrained embedded systems, to allow software patches and updates, and to allow adaptations to changes in environmental and operating conditions without service interruption. Dynamic reconfiguration, however, is a complex and error prone process. In this paper we report our experience in implementing safe dynamic reconfigurations in embedded devices with limited resources. Our approach relies on a component-based framework for building reconfigurable operating systems, and the use of a domain specific language (DSL) for reconfiguration.

Abstract: Modern systems are increasingly required to be capable to evolve at run-time, in particular allowing for the dynamic plugging of new features. It is important that this evolution happens preserving some established properties (which can concern the structure, the interaction patterns, or crucial extra-functional properties, such as reliability or security), and due to dynamicity this needs to be checked at run-time, as the changes occur. In this work we consider evolving component-based systems formed by a kernel architecture to which new components can be plugged in at run-time, and introduce the MOSAICO approach for the run-time monitoring of architectural properties. MOSAICO uses Aspect-oriented technologies for instrumenting and monitoring the system according to selected architectural properties. MOSAICO can handle evolving black-box component systems since it continuously watches the events occurring at the extension points of the kernel architecture. The application of a prototype implementation of MOSAICO, capable to handle interaction pattern properties, is illustrated on the NewsFeeder case study.

Abstract: Data encapsulation is a familiar property in object-oriented programming It is not only useful for modelling things in the real world, but it also facilitates reuse by enabling the creation of multiple instances of the same class, each with its own identity and private data For CBSE, this kind of reuse is clearly also one of the key desiderata However, it must be achieved in conjunction with composition, which is central to CBSE In this paper we show how data encapsulation can be combined with composition, by extending a component model we have defined previously

Abstract: Current works address self-adaptability of software architectures to build more autonomous and flexible systems However, most of these works only perform adaptations at configuration-level: a component is adapted by being replaced with a new one The state of the replaced component is lost and related components can undergo undesirable changes This paper presents a generic solution to design components that are capable of supporting runtime adaptation, taking into account that component type changes must be propagated to its instances The adaptation is performed in a decentralized and autonomous way, in order to cope with the increasing need for building heterogeneous and autonomous systems As a result, each component type manages its instances and each instance applies autonomously the changes Moreover, our proposal uses aspect-oriented components to benefit from their reuse and maintenance, and it is based on MOF and Reflection concepts to benefit from the high abstraction level they provide

Abstract: In this paper, we present an automatic and flexible approach for software component substitution. When a component is removed from an assembly, most existing approaches perform component-to-component substitution, relying on the fact that such a candidate component is available, which is hardly to happen because the constraints on its interfaces are too strong. When such a component does not exist, it would be more flexible to allow a single component to be replaced by a whole component assembly. We propose such an automatic substitution mechanism which does not need the changes to be anticipated and preserves the quality of the assembly.

Abstract: In component-based software development, the design of components should be carried out separately from the deployment of components, in order to enable composition by independent third-parties. However, current component models are biased towards either the design phase or the deployment phase. In this paper, we argue that ideally component models should include both design and deployment phases, and it should be possible to compose components in both phases. We also demonstrate a preliminary implementation of composition in both phases in a component model we have defined.

Abstract: Several performance-driven approaches to selectively enforce interface contracts for scientific components are investigated. The goal is to facilitate debugging deployed applications built from plug-and-play components while keeping the cost of enforcement within acceptable overhead limits. This paper describes a study of global enforcement using a priori execution cost estimates obtained from traces. Thirteen trials are formed from five, single-component programs. Enforcement experiments conducted using twenty-three enforcement policies are used to determine the nature of exercised contracts and the impact of a variety of sampling strategies. Performance-driven enforcement appears to be best suited to programs that exercise moderately expensive contracts.

Abstract: Being an important means of reducing development costs, behavior specification of software components facilitates reuse of a component and even reuse of a component's architecture (assembly). However, since typically only a part of the components' functionality is actually used in the new context, a significant part of the behavior specification may be superfluous. As a result, it may be hard to see (and filter out) the actual interplay among the components in their behavior specification. This paper targets the problem in the scope of behavior protocols. It presents a technique for slicing behavior protocols with respect to a given context (composition), designed to remove the unused behavior from a behavior specification. The technique is based on a formal foundation, generic enough to support slicing with respect to a property expressed as a predicate. To demonstrate viability of the proposed approach, a positive experience with behavior specification slicing applied in real-life case study is shared with the reader (along with a short description of a prototype).

Abstract: The transformation and integration of government services, enabled by the use of new technologies such as application servers and Web services, is fundamental to reduce the cost of government and improving service outcomes to citizens. Many core Government information systems comprise applications running on legacy mainframes, databases and transaction processing monitors. As Governments worldwide provide direct access over the Internet to these legacy applications from the general public, they may be exposed to workloads well above the origin design parameters of these back-end systems. This creates a significant risk of high profile failures for Government agencies whose newly integrated systems become overloaded. In this paper we describe how we conducted a performance assessment of a business-critical, Internet-facing Web services that integrated new and legacy systems from two Australian Government agencies. We leveraged prototype tools from our own research along with known techniques in performance modeling. We were able to clearly demonstrate that the existing hardware and software would be adequate to handle the predicted workload for the next financial year. We were also able to do 'what-if' analysis and predict how the system can perform with alternative strategies to scale the system. We conclude by summarizing the lessons learnt, including the importance of architecture visibility, benchmarking data quality, and measurement feasibility due to issues of outsourcing, privacy legislation and cross-agency involvement.

Abstract: Software components are deployed into an execution environment before runtime. The execution environment influences the runtime execution of a component. Therefore, it is important to study existing execution environments for components and learn how they influence components' runtime execution. In this paper, we undertake such a study. We show that deploying components into different execution environments may incur runtime conflicts, which, however, can be detected before runtime.

Abstract: In this paper we describe a technique for specifying time related properties on traditional software components. We apply the separation of concerns paradigm to allow independent specification of timing and to integrate timechecking specialized tool support into conventional software design processes. We aim at helping the designer to specify time contracts and at simplifying the introduction of time properties in the component behaviour description. We propose to handle timing issues in a separate and specific design activity, in order to provide means of formal computation of time properties for component assemblies without modifying in depth existing design processes.

Abstract: The SOAP Service Description Language (SSDL) is a SOAP-centric language for describing Web Service contracts. SSDL focuses on message abstraction as the building block for creating service-oriented applications and provides an extensible range of protocol frameworks that can be used to describe and formally model component composition based on Web Service interactions. Given its novel approach, implementing support for SSDL contracts presents interesting challenges to middleware developers. At one end of the spectrum, programming abstractions that support message-oriented designs need to be created. At the other end, new functionality and semantics must be added to existing SOAP engines. In this paper we explain how component developers can create message-oriented Web Service interfaces with contemporary tool support (specifically the Windows Communication Foundation) using SSDL. We show how SSDL can be used as an alternative and powerful metadata language natively alongside existing tooling without imposing additional burdens on application developers. Moreover, we describe the design and architecture of the Soya middleware which supports SSDL-based development of Web Services on the WCF platform.

Abstract: QoS contract negotiation enables the selection of appropriate concrete QoS contracts between collaborating components. The negotiation is particularly challenging when component's QoS contracts depend on runtime resources or quality attributes to be fixed dynamically. This paper proposes a QoS contract negotiation approach by modeling it as a constraint solving problem. Important to our approach is the classification of the negotiation in multiple phases - coarse-grained and fine-grained, which are concerned with the negotiation of coarse-grained and fine-grained component properties respectively. We present negotiation algorithms first in a single-client - single-server scenario and later generalize it to a multiple-clients scenario. The contract negotiation is illustrated using an example from a video streaming scenario.

Abstract: Software components and software architectures have emerged as a promising paradigm to improve the construction of software systems. Some attributes, such as reliability, requires evidences about failures in the system. An approach addressing the software reliability estimation problem is based on considering all execution traces collected during the testing process. An execution trace is a sequence of blocks grouping source code statements. Following this approach, early reliability assessment of component assemblies requires addressing an important issue: a precise composition semantics representing the behavior of the assembled components. This paper describes a composition model for sequential component assemblies which uses as basic units of composition a set of empirical evidences generated during the component testing process. These units are named as Component Test Records.

Abstract: In the SOA paradigm service composition enables creation of business processes and workflows by assembling together simple or composite services in a particular sequence. In such a distributed architecture possibly involving multiple service providers, optimal selection of service implementations from an existing pool of services, based on QoS and cost factors assumes critical practical relevance. In this paper, we analyze various complex service provider configurations, where multiple business functionalities (comprising a business process) are available as simple or composite services from multiple service providers (some possibly working in coalitions) at varying QoS and cost attribute values. We study the service composition constraints resulting in such a context and propose an algorithm to formally capture these special constraints and represent these into simple weighted multi-stage graphs suitable for subsequent application of various optimization techniques cited in the literature.

Abstract: Binary component-based software updates that are lightweight, efficient, safe and generic still remain a challenge. Most existing deployment systems that achieve this goal have to control the complete software environment of the user which is a barrier to adoption for both software consumers and producers. Binary change set composition is a technique to deliver incremental, binary updates for component-based software systems in an efficient and non-intrusive way. This way application updates can be delivered more frequently, with minimal additional overhead for users and without sacrificing the benefits of componentbased software development.