Internet application workloads typically vary over time, periods of low demand alternate with spikes which, if not properly handled, can saturate the allocated infrastructure and violate Service Level Agreements. In this work, we leverage the usage patterns associated with the different customers of an Internet application to make tailored workload predictions. These workload predictions are then used to proactively adapt the allocation of resources in a data center right before load spikes happen. Such proactive allocation strategy improves the overall resource utilization and, at the same time, guarantees the service level agreements. A real life prototype has been implemented to compare our solution with both over-provisioning and reactive approaches. Results show up to 60% reduction in response time over a reactive approach with the same adaptation frequency, and up to 84% reduction in the amount of resources allocated compared to a typical over-provisioning approach.

We present a vision for the evolution of automotive diagnostics as car electronics are increasingly implemented as distributed systems. We first analyze the state of the art in the automotive development process, and we identify how distributed functionality challenges this process and leads to higher development and field maintenance costs. To address these challenges, we propose a modified development process that leverages a model-based approach. Finally, we outline future research directions for car diagnostics.

Requirements traceability is linking requirements to software artifacts, such as source code, test-cases and configuration files. For stakeholders of software, it is important to understand which requirements were tested, whether sufficiently, if at all. Hence tracing requirements in test-cases is an important problem. In this paper, we build on existing research and use features, realization of functional requirements in software [15], to automatically create requirements traceability links between requirements and test-cases. We evaluate our approach on a chat system, Apache Pool [21] and Apache Log4j [11]. We obtain precision/recall levels of more than 90%, an improvement upon currently existing Information Retrieval approaches when tested on the same case studies.

Journal Article Interaction-based Runtime Verification for Systems of Systems Integration Get access Ingolf H. Krüger, Ingolf H. Krüger Computer Science and Engineering Department, University of California, San Diego, La Jolla, CA 92093-0404, USA. Search for other works by this author on: Oxford Academic Google Scholar Michael Meisinger, Michael Meisinger Computer Science and Engineering Department, University of California, San Diego, La Jolla, CA 92093-0404, USA. Search for other works by this author on: Oxford Academic Google Scholar Massimiliano Menarini Massimiliano Menarini Computer Science and Engineering Department, University of California, San Diego, La Jolla, CA 92093-0404, USA. Search for other works by this author on: Oxford Academic Google Scholar Journal of Logic and Computation, Volume 20, Issue 3, June 2010, Pages 725–742, https://doi.org/10.1093/logcom/exn079 Published: 15 November 2008 Article history Received: 04 July 2008 Published: 15 November 2008

Automotive and avionics systems are complex, distributed, software-intensive systems-of-systems (SoS). Consequently, system integration is a central challenge in both domains. Important cross-cutting requirements aspects, such as security, authorization, and failure management, are best understood as properties of the interplay among sub-systems. Yet, traditional development processes address the integration challenge only late, at the level of implementation and deployment. Consequently, potentials for reuse within and across product lines are left unrealized. Furthermore, late integration leads to high calibration, configuration and redesign costs. Service-Oriented Architectures (SOAs) have emerged as a solution to the integration challenge. However, inappropriate application of SOA-principles results in a high degree of fragmentation and scattering of functionality-this leads to additional difficulties in requirements traceability and quality assurance. In this article, we give a comprehensive overview of these SOA-challenges, and present Rich Services as a hierarchical SOA blueprint and development process enabling SoS integration in a dependable way. Rich Services introduce services as hierarchical, partial interaction patterns; these interactions are then augmented with infrastructure elements to inject behaviors that address cross-cutting requirements aspects. Rich Services also seamlessly address the mapping from logical to deployment architectures. Using end-to-end failure management as an example, we illustrate the utility of Rich Services.

Provides an overview of the technical articles and features presented in this issue.

Some of the distinct attributes of Aerospace and Automobile Software Technologies are briefly reviewed in this article as a way of placing in collective-context the detailed technical papers that form this exciting special issue. A historical context, a unifying architectural perspective and, the rapidly changing and defining role of software is presented, especially as we look ahead to this new decade in this still young century.

System-of-systems integration is a fundamental challenge to Software Engineering. Enterprise Service Bus (ESB) technologies help overcoming this challenge by addressing loose coupling of services while provisioning for crosscutting concerns. ESBs use aspect-oriented techniques and flexible message routing and filtering to support decoupling of the business logic from crosscutting concerns such as encryption and failure management. These characteristics have led to an increasing adoption of ESBs in the enterprise business domain. However, currently there is no systematic development approach for Service-Oriented Architectures (SOAs) ranging from requirements analysis to architecture design to ESB deployment. A core challenge is the precise specification of the routing capabilities of the ESB. A viable solution should maintain the decoupling of crosscutting concerns from the business logic while being able to reason about the integrated interaction pattern. In this paper we leverage the Rich Service architectural blueprint in combination with Aspect-Oriented Modeling techniques to address this problem.

One of the key challenges to successful systems-of-systems integration using Web services technologies is how to address crosscutting architectural concerns such as policy management, governance, and authentication, while still maintaining the lightweight implementation and deployment Jlavor that distinguishes Web services fiom earlier attempts at providing interoperable enterprise systems. To address this challenge, this article introduces the notion of a Rich Service, an extension of the standard service notion, based on an architectural pattern that allows hierarchical decomposition of system architecture according to separate concerns. Rich Services enable the capture of dzfferent system aspects and their interactions. By leveraging emerging Enterprise Service Bus technologies, Rich Services also enable a direct transition from a logical to a deployed service-oriented architecture (SOA). This results in immediate beneJits not only in SOA design, implementation, deployment, and quality assurance, but also in the traceability of architectural requirements to an SOA implementation.

The amount of software in cars grows exponentially. Driving forces of this development are the availability of cheaper and more powerful hardware, as well as the demand for innovation through new functionality. The rapidly growing significance of software and software-based functionality is at the root of various challenges in the automotive industries. These concern their organization, definition of key competencies, processes, methods, tools, models, product structures, division of labor, logistics, maintenance, and long-term strategies. This paper pinpoints the idiosyncrasies of the domain, characterizes the essentials of automotive software, and discusses the challenges of automotive software engineering

Service-oriented software systems rapidly gain importance across application domains: They emphasize functionality (services), rather structural entities (components), as the basic building block for system composition. More specifically, services coordinate the interplay of components to accomplish specific tasks. In this article, we establish a foundation of service orientation: Based on the Focus theory of distributed systems (see Broy and Stølen [2001]), we introduce a theory and formal model of services. In Focus, systems are composed of interacting components. A component is atotalbehavior. We introduce a formal model of services where, in contrast, a service is apartialbehavior. For services and components, we work out foundational specification techniques and outline methodological development steps. We show how services can be structured and how software architectures can be composed of services and components. Although our emphasis is on a theoretical foundation of the notion of services, we demonstrate utility of the concepts we introduce by means of a running example from the automotive domain.

An important step in the development of large-scale distributed, reactive systems is the design of architectures that effectively support the systems' purposes. Early prototypes help to decide upon the most effective architecture for a given situation. Questions to answer include the boundaries of components, communication topologies and of replication. It is desirable to evaluate and compare architectures for functionality and quality attributes before implementing or changing the whole system. Often, the effort required is prohibitive. In this paper we present an approach to efficiently create prototypes for service-oriented architectures using aspect-oriented programming techniques. We explain a procedure for transforming interaction based software specifications into AspectJ programs. We show how to map the same set of interaction scenarios to different candidate architectures. This significantly reduces the effort required to explore architectural alternatives. We explain and evaluate our approach using the Center TRACON Automation System as a running example.

SystemC is being widely used for system-level modeling of system-on-chip. When designing this class of system, one of the main challenges is to guarantee the correctness of the implementation. This can be especially difficult for designs that are composed of concurrent components with lot of interactions. Most designers use a component-based design approach, where one has an informal idea of how the design should behave, define component specifications, implement and assemble the components into a program, and then check for correctness by simulating the design with a number of testbenches. With this methodology, bugs often go undetected because when using simulation, it is very difficult to test for all possible interactions. To overcome this limitation, our goal is to establish a specification and verification methodology for SystemC. To address the scalability issue, which is a serious limiting factor in state-based verification approaches, we use the concepts of behavioral types; allowing us to effectively infer system properties from properties of its components. In this paper, we answer the following questions: (1) what is a behavioral type? (2) how are behavioral type defined? and (3) how to use the behavioral types in a compositional verification methodology

The correct interplay among components in a distributed, reactive system is a crucial development task, particularly for embedded systems such as those in the automotive domain. Model-based development is a promising means for capturing key structural and behavioral requirements before implementing code. Current development approaches focus on components as the central development entity, leaving component integration as a separate and error-prone task in later stages of the system development process. This approach is particularly problematic in the area of Quality-of-Service properties that are inherently end-to-end. We address this problem by using a model where system functions, not components implementing them, are central from the early phases of requirements capture through implementation. We develop a domain model for system functions (or services) based on interaction patterns; this model captures deadline specifications ranging from individual messages to entire services. Using a combination of modeling tools and code-generators for the RT CORBA platform, we provide an experimentation platform for monitoring these specified deadlines in executable specifications.

Most object oriented applications that involve persistent data interact with a relational database. The most common interaction mechanism is a call level interface (CLI) such as ODBC or JDBC. While there are many advantages to using a CLI -- expressive power and performance being two of the most key -- there are also drawbacks. Applications communicate through a CLI by constructing strings that contain SQL statements. These SQL statements are only checked for correctness at runtime, tend to be fragile and are vulnerable to SQL injection attacks. To solve these and other problems, we present the SQL DOM: a set of classes that are strongly-typed to a database schema. Instead of string manipulation, these classes are used to generate SQL statements. We show how to extract the SQL DOM automatically from an existing database schema, demonstrate its applicability to solve the mentioned problems, and evaluate its performance.

Increasing interactions among automotive software functions and the ensuing complexity demand new ways of developing automotive systems. Many functions deployed in the vehicle cut across physical and logical boundaries. Capturing the core interactions underlying system functions, creating logical service architectures and mapping them to varying deployment architectures and product lines are central development tasks that cross-cut requirements capture, architecture design, implementation and validation/verification. The service-oriented development approach we propose addresses these fundamental aspects of automotive system design. In this talk the author demonstrate the description techniques, methodology and tools we have developed, and discuss their application in the context of automotive case studies.

Summary form only given. Visual modeling techniques play an important role in the design and understanding of complex, software intensive systems. Block diagrams in systems engineering and the Unified Modeling Language (UML) in software engineering, are prominent examples of such visual modeling techniques.

EHAVIOR models play a key role in the engineering of software-basedsystems.Theyarethebasisforsystematic approaches to requirements elicitation, specification, architecture design, simulation, code generation, and verification and validation. A range of notations, techniques, and tools supporting behavior modeling for these development tasks have been suggested. Underlying these notations, techniques, and tools, two complementary approaches to modeling behavior can be identified: interaction-based and state-based modeling. Interaction-based modeling focuses on the interactions between actors and components in a system. Consequently, communication between such entities is viewed as the principal modeling construct. Interaction modeling, commonly realized using scenario and use case techniques, provides an overall view of a system which is particularly suited for supporting communication between project

The notion of service is becoming increasingly popular as a means for implementing large-scale distributed, reactive systems. Systematic development approaches and modeling notations for services are still largely missing from the literature. We introduce an architecture definition language for service-oriented software architectures. It provides modeling elements for interaction patterns defining services, as well as for mapping sets of services to target component configurations. We also present a comprehensive software development process that considers services as first class modeling elements. By decoupling the modeling of services from their implementation on target component configurations this process enables exploration of multiple architectures implementing the same set of services. We substantiate our view of services as cross-cutting architectural aspects by providing a mapping from services to aspects in AspectJ. We illustrate applicability of our approach by modeling service-oriented architectures for portions of the Center TRACON automation system as a running example.

Abstract. Message sequence charts (MSCs) have proven to be a useful modeling technique especially within the requirements analysis phase of software development. MSCs, however, do not support the concept of broadcast communication, which is frequently used in technical applications. In this paper, we present an extension to MSCs for the modeling of broadcast interaction scenarios. Based on the mathematical framework of timed streams we also introduce a semantics for broadcast MSCs. We thoroughly discuss methodological benefits and semantic properties of this approach, consider alternative solutions, and address its scaleability with respect to complex real-time systems applications.

Following the success of the "First Workshop on Scenarios and State Machines: Models, Algorithms, and Tools" held at ICSE 2002 in Orlando [1], this workshop aims at bringing together researchers and practitioners to build a shared understanding on the relation between scenarios and state machines and to gain insight into techniques and tools that may leverage the combination of these approaches to enhance our means for behavior modeling.

The definition of a transparent software architecture is one of the key issues in the early development phases for complex distributed and reactive software systems. In this paper, we show how to derive an architecture systematically for systems with communication models based on broadcasting. Adequate graphical description techniques for capturing interaction requirements and logical component architectures for broadcasting systems are unavailable so far. We introduce an extension to UML's sequence diagrams to capture broadcasting scenarios. Furthermore, we present methodological steps for constructively deriving structural and behavioral aspects of the architecture under consideration from the captured scenarios.

We introduce Hybrid Sequence Charts (HySCs) as a visual description technique for communication in hybrid system models. To that end, we adapt a subset of the well-known MSC syntax to the application domain of hybrid systems. The semantics of HySCs is different from standard MSC semantics. Most notably, we use a shared variables communication model and assume the existence of a continuous, global clock. Similar to their classic counterpart HySCs can be advantageously used in the early phases of the software development process. In particular in the requirements capture phase, they improve the dialog between customers and application experts: They complement existing formalisms like hybrid automata by focusing on the interaction between the system's components. We outline the key concepts and the usage of HySCs along an example, the specification of an electronic height control system. Then we define the formal semantics of their basic elements.

We introduce the formal notion of an interaction interface. Its purpose is to specify formally the interaction between two or more components that co-operate as subsystems of a distributed system. We suggest the use of interaction interfaces for the description not of the behaviour of a single component in isolation but of the interface, the co-operation, between two or more components that are interacting within a distributed system. Typical examples are the interaction between an embedded system and its environment or the interaction between a sender and a receiver in a communication protocol. An interaction interface can be formally described by predicates characterising sets of interaction histories. We understand the specification of interaction histories as a typical step in system development that prepares the decomposition of a system into interacting subcomponents. After fixing the distribution structure of the system, an interaction interface is worked out that describes how the introduced subcomponents interact. In a successive development step we systematically derive the individual component specifications from the interface description. We show how such an interaction interface can be decomposed systematically into component specifications.

A crucial aspect of the architecture of a software system is its decomposition into components and the specification of component interactions. In this report we use a variant of extended event traces as a graphical technique for the description of such component interactions. It allows us to define interaction patterns that occur frequently within an architecture, in the form of diagrams. The diagrams may be instantiated in various contexts, thus allowing reuse of interaction patterns. Our notation contains operators yielding not only exemplary but complete behavior specifications. Extended event traces have a clear semantics that is based on sets of traces. We present several application examples that demonstrate the practical use of our notation.