This book constitutes revised papers of the proceedings of the 7th International Workshop on System Analysis and Modeling, SAM 2012, held in Innsbruck, Austria, in October 2012. The 12 papers presented were carefully reviewed and selected from 27 submissions. In addition, the book contains two keynote speeches in full-paper length. The contributions are organized in topical sections named: test and analysis, language enhancements, fuzzy subjects, components and composition, and configuring and product lines.

Modula-2 is a simple yet powerful programming language that is suitable for a wide variety of applications. It is based on Pascal, a successful programming language that was introduced in 1970 by Niklaus Wirth. During the 1970's Pascal became the most widely taught programming language and it gained acceptance in science and industry. In 1980 Dr. Wirth released the Modula-2 program ming language. Modula-2 is an evolution of Pascal. It improves on the successes of Pascal while adding the MODULE - a tool for ex pressing the relations between the major parts of programs. In ad dition Modula-2 contains low-level features for systems program ming and coroutines for concurrent programming. Programming languages are important because they are used to express ideas. Some programming languages are so limited that certain ideas can't be easily expressed. For example languages that lac k floating point arithmetic are inappropriate for scientific com putations. Languages such as Basic and Fortran that lack recur sion are unsuitable for text processing or systems programming. Sometimes a programming language is useable for a certain appli cation but it is far from ideal. A good example is the difficulty of writing large programs in pure Pascal. Pascal is a poor language for large jobs because it lacks facilities for partitioning a program viii Preface 6< ; ~~~~er 0\ Sheet Metal Tube /" 0 (to Affix Eraser to Shaft) ~ Hollow Wooden Shaft A Lead Core Figure 1. An exploded diagram. into separate pieces that can be developed independently.

This volume contains a selection of papers that focus on the state-of the-art in real-time scheduling and resource management. Preliminary versions of these papers were presented at a workshop on the foundations of real-time computing sponsored by the Office of Naval Research in October, 1990 in Washington, D.C. A companion volume by the title Foundations of Real-Time Computing: Fonnal Specifications and Methods complements this book by addressing many of the most advanced approaches currently being investigated in the arena of formal specification and verification of real-time systems. Together, these two texts provide a comprehensive snapshot of current insights into the process of designing and building real-time computing systems on a scientific basis. Many of the papers in this book take care to define the notion of real-time system precisely, because it is often easy to misunderstand what is meant by that term. Different communities of researchers variously use the term real-time to refer to either very fast computing, or immediate on-line data acquisition, or deadline-driven computing. This text is concerned with the very difficult problems of scheduling tasks and resource management in computer systems whose performance is inextricably fused with the achievement of deadlines. Such systems have been enabled for a rapidly increasing set of diverse end-uses by the unremitting advances in computing power per constant-dollar cost and per constant-unit-volume of space. End-use applications of deadline-driven real-time computers span a spectrum that includes transportation systems, robotics and manufacturing, aerospace and defense, industrial process control, and telecommunications."

Appropriate for use as a graduate text or a professional reference, Languages for Digital Embedded Systems is the first detailed, broad survey of hardware and software description languages for embedded system design. Instead of promoting the one language that will solve all design problems (which does not and will not ever exist), this book takes the view that different problems demand different languages, and a designer who knows the spectrum of available languages has the advantage over one who is trapped using the wrong language. Languages for Digital Embedded Systems concentrates on successful, widely-used design languages, with a secondary emphasis on those with significant theoretical value. The syntax, semantics, and implementation of each language is discussed, since although hardware synthesis and software compilation technology have steadily improved, coding style still matters, and a thorough understanding of how a language is synthesized or compiled is generally necessary to take full advantage of a language. Practicing designers, graduate students, and advanced undergraduates will all benefit from this book. It assumes familiarity with some hardware or software languages, but takes a practical, descriptive view that avoids formalism.

Constraint Logic Programming (CLP), an area of extreme research interest in recent years, extends the semantics of Prolog in such a way that the combinatorial explosion, a characteristic of most problems in the field of Artificial Intelligence, can be tackled efficiently. By employing solvers dedicated to each domain instead of the unification algorithm, CLP drastically reduces the search space of the problem, which leads to increased efficiency in the execution of logic programs. CLP offers the possibility of solving complex combinatorial problems in an efficient way, and at the same time maintains the advantages offered by the declarativeness of logic programming. The aim of this book is to present parallel and constraint logic programming, offering a basic understanding of the two fields to the reader new to the area. The first part of the book gives an introduction to the fundamental aspects of conventional logic programming which is necessary for understanding the parts that follow. The second part includes an introduction to parallel logic programming, architectures and implementations proposed in the area.Finally, the third part presents the principles of constraint logic programming. The last two parts also include descriptions of the supporting facilities for the two paradigms in two popular systems; ECLIPSe and SICStus. These platforms have been selected mainly because they offer both parallel and constraint features. Annotated and explained examples are also included in the relevant parts, offering a valuable guide and a first practical experience to the reader. Finally, applications of the covered paradigms are presented. The authors felt that a book of this kind should provide some theoretical background necessary for the understanding of the covered logic programming paradigms, and a quick start for the reader interested in writing parallel and constraint logic programming programs. However it is outside the scope of this book to provide a deep theoretical background of the two areas.In that sense, this book is addressed to a public interested in obtaining a knowledge of the domain, without spending the time and effort to understand the extensive theoretical work done in the field -- namely postgraduate and advanced undergraduate students in the area of logic programming. This book fills a gap in the current bibliography, since there is no comprehensive book of this level that covers the areas of conventional, parallel, and constraint logic programming. Parallel and Constraint Logic Programming: An Introduction to Logic, Parallelism and Constraints is appropriate for an advanced level course on Logic Programming or Constraints, and as a reference for practitioners and researchers in industry.

Formal Methods for Open Object-Based Distributed Systems presents the leading edge in several related fields, specifically object-orientated programming, open distributed systems and formal methods for object-oriented systems. With increased support within industry regarding these areas, this book captures the most up-to-date information on the subject. Many topics are discussed, including the following important areas: object-oriented design and programming; formal specification of distributed systems; open distributed platforms; types, interfaces and behaviour; formalisation of object-oriented methods. This volume comprises the proceedings of the International Workshop on Formal Methods for Open Object-based Distributed Systems (FMOODS), sponsored by the International Federation for Information Processing (IFIP) which was held in Florence, Italy, in February 1999. Formal Methods for Open Object-Based Distributed Systems is suitable as a secondary text for graduate-level courses in computer science and telecommunications, and as a reference for researchers and practitioners in industry, commerce and government.

LOTOS (Language Of Temporal Ordering Specification) became an international standard in 1989, although application of preliminary versions of the language to communication services and protocols of the ISO/OSI family dates back to 1984. This history of the use of LOTOS made it apparent that more advantages than the pure production of standard reference documents were to be expected from the use of such formal description techniques. LOTOSphere: Software Development with LOTOS describes in depth a five year project that moved LOTOS out of the ISO tower into software engineering practice. LOTOS became a vehicle for efficient, yet formally based industrial software specification, design, verification, implementation and testing. LOTOSphere: Software Development with LOTOS is divided into six parts. The first introduces the reader to LOTOS and the project LOTOSphere. The five remaining each treat an important part of the software development life cycle using LOTOS. This is the first book to give a comprehensive treatment of the use of these formal description techniques in a software engineering environment. It will thus be a valuable reference for researchers and software developers and can also be used as a text for an advanced course on the subject.

The LASER school is intended for professionals from the industry (engineers and managers) as well as university researchers, including PhD students. Participants learn about the most important software technology advances from the pioneers in the field. The school's focus is applied, although theory is welcome to establish solid foundations. The format of the school favors extensive interaction between participants and speakers. LASER 2011 is devoted to software verification tools. There have been great advances in the field of software verification in recent years. Today verification tools are being increasingly used not only by researchers, but by programming practitioners. The summer school will focus on several of the most prominent and practical of such tools from different areas of software verification (such as formal proofs, testing and model checking). During the school the participants will not only learn the principles behind the tools, but also get hands-on experience, trying the tools on real programs.

For real-time systems, the worst-case execution time (WCET) is the key objective to be considered. Traditionally, code for real-time systems is generated without taking this objective into account and the WCET is computed only after code generation. Worst-Case Execution Time Aware Compilation Techniques for Real-Time Systems presents the first comprehensive approach integrating WCET considerations into the code generation process. Based on the proposed reconciliation between a compiler and a timing analyzer, a wide range of novel optimization techniques is provided. Among others, the techniques cover source code and assembly level optimizations, exploit machine learning techniques and address the design of modern systems that have to meet multiple objectives. Using these optimizations, the WCET of real-time applications can be reduced by about 30% to 45% on the average. This opens opportunities for decreasing clock speeds, costs and energy consumption of embedded processors. The proposed techniques can be used for all types real-time systems, including automotive and avionics IT systems.

Software engineering is widely recognized as one of the most exciting, stimulating, and profitable research areas, with a significant practical impact on the software industry. Thus, training future generations of software engineering researchers and bridging the gap between academia and industry are vital to the field. The International Summer School on Software Engineering (ISSSE), which started in 2003, aims to contribute both to training future researchers and to facilitating the exchange of knowledge between academia and industry. This volume consists of chapters originating from a number of tutorial lectures given in 2009, 2010, and 2011 at the International Summer School on Software Engineering, ISSSE, held in Salerno, Italy. The volume has been organized into three parts, focusing on software measurement and empirical software engineering, software analysis, and software management. The topics covered include software architectures, software product lines, model driven software engineering, mechatronic systems, aspect oriented software development, agile development processes, empirical software engineering, software maintenance, impact analysis, traceability management, software testing, and search-based software engineering.

The increasing complexity of systems and the growing uncertainty in their operational environments have created a critical need to develop systems able to improve their operation, adapt to change, and recover from failures autonomously. This situation has led to recent advances in self-adaptive systems able to reconfigure their structure and modify their behavior at run-time to adapt to environmental changes. Despite these advances, one key aspect of self-adaptive systems that remains to be tackled in depth is "assurances": the provision of evidence that the system satisfies its stated functional and non-functional requirements during its operation in the presence of self-adaptation. This book is one of the outcomes of the ESEC/FSE 2011 Workshop on Assurances for Self-Adaptive Systems (ASAS), held in Szeged, Hungary, in September 2011. It contains extended versions of some of the papers presented during the workshop, as well as invited papers from recognized experts. The 12 refereed papers were thoroughly reviewed and selected. The book consists of four parts: formal verification, models and middleware, failure prediction, and assurance techniques.

This book constitutes the revised selected papers of the 9th International Symposium on Formal Aspects of Component Software, FACS 2012, held in Mountain View, CA, USA in September 2012. The 16 full papers presented were carefully reviewed and selected from 40 submissions. They cover topics such as formal models for software components and their interaction; formal aspects of services, service oriented architectures, business processes, and cloud computing; design and verification methods for software components and services; composition and deployment: models, calculi, languages; formal methods and modeling languages for components and services; model based and GUI based testing of components and services; models for QoS and other extra-functional properties (e.g., trust, compliance, security) of components and services; components for real-time, safety-critical, secure, and/or embedded systems; industrial or experience reports and case studies; update and reconfiguration of component and service architectures; component systems evolution and maintenance; autonomic components and self-managed applications; formal and rigorous approaches to software adaptation and self-adaptive systems.

Formal methods have been applied successfully to the verification of medium-sized programs in protocol and hardware design for some time. However, their application to the development of large systems requires more emphasis on specification, modeling, and validation techniques supporting the concepts of reusability and modifiability, and their implementation in new extensions of existing programming languages like Java.

This book contains 20 revised papers submitted after the 10th Symposium on Formal Methods for Components and Objects, FMCO 2011, which was held in Turin, Italy, in October 2011. Topics covered include autonomic service-component ensembles; trustworthy eternal systems via evolving software, data, and knowledge; parallel patterns for adaptive heterogeneous multicore systems; programming for future 3D architectures with many cores; formal verification of object oriented software; and an infrastructure for reliable computer systems.

I love virtual machines (VMs) and I have done for a long time.If that makes me "sad" or an "anorak," so be it. I love them because they are so much fun, as well as being so useful. They have an element of original sin (writing assembly programs and being in control of an entire machine), while still being able to claim that one is being a respectable member of the community (being structured, modular, high-level, object-oriented, and so on). They also allow one to design machines of one's own, unencumbered by the restrictions of a starts optimising it for some physical particular processor (at least, until one processor or other). I have been building virtual machines, on and off, since 1980 or there abouts. It has always been something of a hobby for me; it has also turned out to be a technique of great power and applicability. I hope to continue working on them, perhaps on some of the ideas outlined in the last chapter (I certainly want to do some more work with register-based VMs and concur rency). I originally wanted to write the book from a purely semantic viewpoint."

This tutorial volume includes revised and extended lecture notes of six long tutorials, five short tutorials, and one peer-reviewed participant contribution held at the 4th International Summer School on Generative and Transformational Techniques in Software Engineering, GTTSE 2011. The school presents the state of the art in software language engineering and generative and transformational techniques in software engineering with coverage of foundations, methods, tools, and case studies.

Parallel processing is seen today as the means to improve the power of computing facilities by breaking the Von Neumann bottleneck of conventional sequential computer architectures. By defining appropriate parallel computation models definite advantages can be obtained. Parallel processing is the center of the research in Europe in the field of Information Processing Systems so the CEC has funded the ESPRIT Supemode project to develop a low cost, high performance, multiprocessor machine. The result of this project is a modular, reconfigurable architecture based on !NMOS transputers: T.Node. This machine can be considered as a research, industrial and commercial success. The CEC has decided to continue to encourage manufacturers as well as research and end-users of transputers by funding other projects in this field. This book presents course papers of the Eurocourse given at the Joint Research Centre in ISPRA (Italy) from the 4th to 8 of November 1991. First we present an overview of various trends in the design of parallel architectures and specially of the T.Node with it's software development environments, new distributed system aspects and also new hardware extensions based on the !NMOS T9000 processor. In a second part, we review some real case applications in the field of image synthesis, image processing, signal processing, terrain modeling, particle physics simulation and also enhanced parallel and distributed numerical methods on T.Node.

The LNCS journal Transactions on Aspect-Oriented Software Development is devoted to all facets of aspect-oriented software development (AOSD) techniques in the context of all phases of the software life cycle, from requirements and design to implementation, maintenance and evolution. The focus of the journal is on approaches for systematic identification, modularization, representation and composition of crosscutting concerns, i.e., the aspects and evaluation of such approaches and their impact on improving quality attributes of software systems. This volume, the 9th in the Transactions on Aspect-Oriented Software Development series, contains three regular submissions and two special sections, each consisting of two papers. The papers focus on the following topics: modularization, pointcut language, dynamic adaptation, event-based programming, aspect-aware design, system software, object composition and templates.

This book constitutes the refereed proceedings of the International Symposium on Logical Foundations of Computer Science, LFCS 2013, held in San Diego, CA, USA in January 2013. The volume presents 29 revised refereed papers carefully selected by the program committee. The scope of the Symposium is broad and includes constructive mathematics and type theory; logic, automata and automatic structures; computability and randomness; logical foundations of programming; logical aspects of computational complexity; logic programming and constraints; automated deduction and interactive theorem proving; logical methods in protocol and program verification; logical methods in program specification and extraction; domain theory logic; logical foundations of database theory; equational logic and term rewriting; lambda and combinatory calculi; categorical logic and topological semantics; linear logic; epistemic and temporal logics; intelligent and multiple agent system logics; logics of proof and justification; nonmonotonic reasoning; logic in game theory and social software; logic of hybrid systems; distributed system logics; mathematical fuzzy logic; system design logics; and other logics in computer science.

Behavioral Specifications of Businesses and Systems deals with the reading, writing and understanding of specifications. The papers presented in this book describe useful and sometimes elegant concepts, good practices (in programming and in specifications), and solid underlying theory that is of interest and importance to those who deal with increased complexity of business and systems. Most concepts have been successfully used in actual industrial projects, while others are from the forefront of research. Authors include practitioners, business thinkers, academics and applied mathematicians. These seemingly different papers address different aspects of a single problem - taming complexity. Behavioral Specifications of Businesses and Systems emphasizes simplicity and elegance in specifications without concentrating on particular methodologies, languages or tools. It shows how to handle complexity, and, specifically, how to succeed in understanding and specifying businesses and systems based upon precise and abstract concepts. It promotes reuse of such concepts, and of constructs based on them, without taking reuse for granted. Behavioral Specifications of Businesses and Systems is the second volume of papers based on a series of workshops held alongside ACM's annual conference on Object-Oriented Programming Systems Languages and Applications (OOPSLA) and European Conference on Object-Oriented Programming (ECOOP). The first volume, Object-Oriented Behavioral Specifications, edited by Haim Kilov and William Harvey, was published by Kluwer Academic Publishers in 1996.

The VLISP project showed how to produce a comprehensively verified implemen tation for a programming language, namely Scheme [4, 15). Some of the major elements in this verification were: * The proof was based on the Clinger-Rees denotational semantics of Scheme given in [15). Our goal was to produce a "warts-and-all" verification of a real language. With very few exceptions, we constrained ourselves to use the se mantic specification as published. The verification was intended to be rigorous, but. not. complet.ely formal, much in the style of ordinary mathematical discourse. Our goal was to verify the algorithms and data types used in the implementat.ion, not their embodiment. in code. See Section 2 for a more complete discussion ofthese issues. Our decision to be faithful to the published semantic specification led to the most difficult portions ofthe proofs; these are discussed in [13, Section 2.3-2.4). * Our implementation was based on the Scheme48 implementation of Kelsey and Rees [17). This implementation t.ranslates Scheme into an intermediate-level "byte code" language, which is interpreted by a virtual machine. The virtual machine is written in a subset of Scheme called PreScheme. The implementationissufficient.ly complete and efficient to allow it to bootstrap itself. We believe that this is the first. verified language implementation with these properties.

TOOLS Eastern Europe 2002 was the third annual conference on the technology of object-oriented languages and systems. It was held in Eastern Europe, more specifically in Sofia, Bulgaria, from March 13 to 15. In my capacity of program chairman, I could count on the support from the Programming Technology Lab of the Vrije Universiteit Brussel to set up the technical program for this con- ference. We managed to assemble a first class international program committee composed of the following researchers: * Mehmet Aksit (Technische Hogeschool Twente, Netherlands) * Jan Bosch (Universiteit Groningen, Netherlands) * Gilad Bracha (Sun Microsystems, USA) * Shigeru Chiba (Tokyo Institute of Technology, Japan) * Pierre Cointe (Ecole des Mines de Nantes, France) * Serge Demeyer (Universitaire Instelling Antwerpen, Belgium) * Pavel Hruby (Navision, Denmark) * Mehdi Jazayeri (Technische Universitiit Wien, Austria) * Eric Jul (University of Copenhagen, Denmark) * Gerti Kappel (University of Linz, Austria) * Boris Magnusson (University of Lund, Sweden) * Daniela Mehandjiiska-Stavreva (Bond University, Australia) * Tom Mens (Vrije Universiteit Brussel, Belgium) * Christine Mingins (Monash University, Australia) * Ana Moreira (Universidade Nova de Lisboa, Portugal) * Oscar Nierstrasz (Universitiit Bern, Switzerland) * Walter Olthoff (DFKI, Germany) * Igor Pottosin (A. P. Ershov Institute of Informatics Systems, Russia) * Atanas Radenski (Winston-Salem State University, USA) Markku Sakkinen (University of Jyvilskyl!l. , Finland) * * Bran Selic (Rational, Canada) * Andrey Terehov (St.

Business Component-Based Software Engineering, an edited volume, aims to complement some other reputable books on CBSE, by stressing how components are built for large-scale applications, within dedicated development processes and for easy and direct combination. This book will emphasize these three facets and will offer a complete overview of some recent progresses. Projects and works explained herein will prompt graduate students, academics, software engineers, project managers and developers to adopt and to apply new component development methods gained from and validated by the authors. The authors of Business Component-Based Software Engineering are academic and professionals, experts in the field, who will introduce the state of the art on CBSE from their shared experience by working on the same projects. Business Component-Based Software Engineering is designed to meet the needs of practitioners and researchers in industry, and graduate-level students in Computer Science and Engineering.

The formal study of program behavior has become an essential ingredient in guiding the design of new computer architectures. Accurate characterization of applications leads to efficient design of high performing architectures. Quantitative and analytical characterization of workloads is important to understand and exploit the interesting features of workloads. This book includes ten chapters on various aspects of workload characterizati on. File caching characteristics of the industry-standard web-serving benchmark SPECweb99 are presented by Keller et al. in Chapter 1, while value locality of SPECJVM98 benchmarks are characterized by Rychlik et al. in Chapter 2. SPECJVM98 benchmarks are visited again in Chapter 3, where Tao et al. study the operating system activity in Java programs. In Chapter 4, KleinOsowski et al. describe how the SPEC2000 CPU benchmark suite may be adapted for computer architecture research and present the small, representative input data sets they created to reduce simulation time without compromising on accuracy. Their research has been recognized by the Standard Performance Evaluation Corporation (SPEC) and is listed on the official SPEC website, http://www. spec. org/osg/cpu2000/research/umnl. The main contribution of Chapter 5 is the proposal of a new measure called locality surface to characterize locality of reference in programs. Sorenson et al. describe how a three-dimensional surface can be used to represent both of programs. In Chapter 6, Thornock et al.

Practical Performance Modeling: Application of the MOSEL Language introduces the new and powerful performance and reliability modeling language MOSEL (MOdeling, Specification and Evaluation Language), developed at the University of Erlangen, Germany. MOSEL facilitates the performance and reliability modeling of a computer, communication, manufacturing or workflow management system in a very intuitive and simple way. The core of MOSEL consists of constructs to specify the possible states and state transitions of the system under consideration. This specification is very compact and easy to understand. With additional constructs, the interesting performance or reliability measures and graphical representations can be specified. With some experience, it is possible to write down the MOSEL description of a system immediately only by knowing the behavior of the system under study. There are no restrictions, unlike models using, for example, queueing networks, Petri nets or fault trees. MOSEL fulfills all the requirements for a universal modeling language. It is high level, system-oriented, and usable. It is open and can be integrated with many tools. By providing compilers, which translate descriptions specified in MOSEL into the tool-specific languages, all previously implemented tools with their different methods and algorithms (including simulation) can be used. Practical Performance Modeling: Application of the MOSEL Language provides an easy to understand but nevertheless complete introduction to system modeling using MOSEL and illustrates how easily MOSEL can be used for modeling real-life examples from the fields of computer, communication, and manufacturing systems. Practical Performance Modeling: Application of the MOSEL Language will be of interest to professionals and students in the fields of performance and reliability modeling in computer science, communication, and manufacturing. It is also well suited as a textbook for university courses covering performance and reliability modeling with practical applications.

Real-time computing systems are vital to a wide range of applications. For example, they are used in the control of nuclear reactors and automated manufacturing facilities, in controlling and tracking air traffic, and in communication systems. In recent years, real-time systems have also grown larger and become more critical. For instance, advanced aircraft such as the space shuttle must depend heavily on computer sys tems Carlow 84]. The centralized control of manufacturing facilities and assembly plants operated by robots are other examples at the heart of which lie embedded real-time systems. Military defense systems deployed in the air, on the ocean surface, land and underwater, have also been increasingly relying upon real-time systems for monitoring and operational safety purposes, and for retaliatory and containment measures. In telecommunications and in multi-media applications, real time characteristics are essential to maintain the integrity of transmitted data, audio and video signals. Many of these systems control, monitor or perform critical operations, and must respond quickly to emergency events in a wide range of embedded applications. They are therefore required to process tasks with stringent timing requirements and must perform these tasks in a way that these timing requirements are guaranteed to be met. Real-time scheduling al gorithms attempt to ensure that system timing behavior meets its specifications, but typically assume that tasks do not share logical or physical resources. Since resource-sharing cannot be eliminated, synchronization primitives must be used to ensure that resource consis tency constraints are not violated."