What will business software look like in the future? And how will it be developed?

This book covers the proceedings of the first international conference on Future Business Software - a new think tank discussing the trends in enterprise software with speakers from Europe's most successful software companies and the leading research institutions. The articles focus on two of the most prominent trends in the field: emergent software and agile development processes.

"Emergent Software" is a new paradigm of software development that addresses the highly complex requirements of tomorrow's business software and aims at dynamically and flexibly combining a business software solution's different components in order to fulfill customers' needs with a minimum of effort. Agile development processes are the response of software technology to the implementation of diverse and rapidly changing software requirements. A major focus is on the minimization of project risks, e.g. through short, iterative development cycles, test-driven development and an intensive culture of communication."

For more and more systems, software has moved from a peripheral to a central role, replacing mechanical parts and hardware and giving the product a competitive edge. Consequences of this trend are an increase in: the size of software systems, the variability in software artifacts, and the importance of software in achieving the system-level properties. Software architecture provides the necessary abstractions for managing the resulting complexity. We here introduce the Third Working IEEFlIFIP Conference on Software Architecture, WICSA3. That it is already the third such conference is in itself a clear indication that software architecture continues to be an important topic in industrial software development and in software engineering research. However, becoming an established field does not mean that software architecture provides less opportunity for innovation and new directions. On the contrary, one can identify a number of interesting trends within software architecture research. The first trend is that the role of the software architecture in all phases of software development is more explicitly recognized. Whereas initially software architecture was primarily associated with the architecture design phase, we now see that the software architecture is treated explicitly during development, product derivation in software product lines, at run-time, and during system evolution. Software architecture as an artifact has been decoupled from a particular lifecycle phase.

This book describes a cross-domain architecture and design tools for networked complex systems where application subsystems of different criticality coexist and interact on networked multi-core chips. The architecture leverages multi-core platforms for a hierarchical system perspective of mixed-criticality applications. This system perspective is realized by virtualization to establish security, safety and real-time performance. The impact further includes a reduction of time-to-market, decreased development, deployment and maintenance cost, and the exploitation of the economies of scale through cross-domain components and tools. Describes an end-to-end architecture for hypervisor-level, chip-level, and cluster level. Offers a solution for different types of resources including processors, on-chip communication, off-chip communication, and I/O. Provides a cross-domain approach with examples for wind-power, health-care, and avionics. Introduces hierarchical adaptation strategies for mixed-criticality systems Provides modular verification and certification methods for the seamless integration of mixed-criticality systems. Covers platform technologies, along with a methodology for the development process. Presents an experimental evaluation of technological results in cooperation with industrial partners. The information in this book will be extremely useful to industry leaders who design and manufacture products with distributed embedded systems in mixed-criticality use-cases. It will also benefit suppliers of embedded components or development tools used in this area. As an educational tool, this material can be used to teach students and working professionals in areas including embedded systems, computer networks, system architecture, dependability, real-time systems, and avionics, wind-power and health-care systems.

Knowledge-Based Software Engineering brings together in one place important contributions and up-to-date research results in this important area. Knowledge-Based Software Engineering serves as an excellent reference, providing insight into some of the most important research issues in the field.

The 9th ACIS International Conference on Software Engineering, Artificial Intelligence, Networking, and Parallel/Distributed Computing, held in Phuket Thailand on August 6 - 8, 2008 is aimed at bringing together researchers and scientist, businessmen and entrepreneurs, teachers and students to discuss the numerous fields of computer science, and to share ideas and information in a meaningful way. This publication captures 20 of the conference's most promising papers, and we impatiently await the important contributions that we know these authors will bring to the field.

GPS Tracking with Java EE Components: Challenges of Connected Cars highlights how the self-driving car is actually changing the automotive industry, from programing embedded software to hosting services and data crunching, in real time, with really big data. The book analyzes how the challenges of the Self Driving Car (SDC) exceed the limits of a classical GPS Tracking System (GTS.) It provides a guidebook on setting up a tracking system by customizing its components. It also provides an overview of the prototyping and modeling process, and how the reader can modify this process for his or her own software. Every component is introduced in detail and includes a number of design decisions for development. The book introduces Java EE (JEE) Modules, and shows how they can be combined to a customizable GTS, and used as seed components to enrich existing systems with live tracking. The book also explores how to merge tracking and mapping to guide SDCs, and focuses on client server programming to provide useful information. It also discusses the challenges involved with the live coordination of moving cars. This book is designed to aid GTS developers and engineers in the automotive industry. It can also help Java Developers, not only interested in GPS Tracking, but in modern software design from many individual modules. Source code and sample applications will be available on the book's website.

This edited book invites the reader to explore how the latest technologies developed in computational intelligence can be extended and applied to software engineering. Leading experts demonstrate how this recent confluence of software engineering and computational intelligence provides a powerful tool to address the increasing demand for complex applications in diversified areas, the ever-increasing complexity and size of software systems, and the inherently imperfect nature of the information. The presented treatments to software modeling and formal analysis permit the extension of computational intelligence to various phases in software life cycles, such as managing fuzziness resident in the requirements, coping with fuzzy objects and imprecise knowledge, and handling uncertainty encountered in quality prediction.

The ubiquitous nature of the Internet of Things allows for enhanced connectivity between people in modern society. When applied to various industries, these current networking capabilities create opportunities for new applications. Internet of Things and Advanced Application in Healthcare is a critical reference source for emerging research on the implementation of the latest networking and technological trends within the healthcare industry. Featuring in-depth coverage across the broad scope of the Internet of Things in specialized settings, such as context-aware computing, reliability, and healthcare support systems, this publication is an ideal resource for professionals, researchers, upper-level students, practitioners, and technology developers seeking innovative material on the Internet of Things and its distinct applications. Topics Covered: Assistive Technologies Context-Aware Computing Systems Health Risk Management Healthcare Support Systems Reliability Concerns Smart Healthcare Wearable Sensors

Software architectures have gained wide popularity in the last decade. They generally play a fundamental role in coping with the inherent difficulties of the development of large-scale and complex software systems. Component-oriented and aspect-oriented programming enables software engineers to implement complex applications from a set of pre-defined components. Software Architectures and Component Technology collects excellent chapters on software architectures and component technologies from well-known authors, who not only explain the advantages, but also present the shortcomings of the current approaches while introducing novel solutions to overcome the shortcomings. The unique features of this book are: evaluates the current architecture design methods and component composition techniques and explains their shortcomings; presents three practical architecture design methods in detail; gives four industrial architecture design examples; presents conceptual models for distributed message-based architectures; explains techniques for refining architectures into components; presents the recent developments in component and aspect-oriented techniques; explains the status of research on Piccola, Hyper/JA(R), Pluggable Composite Adapters and Composition Filters. Software Architectures and Component Technology is a suitable text for graduate level students in computer science and engineering, and as a reference for researchers and practitioners in industry.

Introduction or Why I wrote this book N the fallof 1997 a dedicated troff user e-rnalled me the macros he used to typeset his books. 1took one look inside his fileand thought, "I can do I this;It'sjustcode. " Asan experiment1spent aweekand wrote a Cprogram and troff macros which formatted and typeset a membership directory for a scholarly society with approximately 2,000 members. When 1 was done, I could enter two commands, and my program and troff would convert raw membershipdata into 200 pages ofPostScriptin 35 seconds. Previously, it had taken me several days to prepare camera-readycopy for the directory using a word processor. For completeness 1sat down and tried to write 1EXmacros for the typesetting. 1failed. Although ninety-five percent of my macros worked, I was unable to prepare the columns the project required. As my frustration grew, 1began this book-mentally, in myhead-as an answer to the question, "Why is 'lEX so hard to learn?" Why use Tgx? Lest you accuse me of the old horse and cart problem, 1should address the question, "Why use 1EX at all?" before 1explain why 'lEX is hard. Iuse 'lEXfor the followingreasons. Itisstable, fast, free, and it uses ASCII. Ofcourse, the most important reason is: 'lEX does a fantastic job. Bystable, I mean it is not likely to change in the next 10 years (much less the next one or two), and it is free of bugs. Both ofthese are important.

Communication protocols form the operational basis of computer networks and tele communication systems. They are behavior conventions that describe how com munication systems inter act with each other, defining the temporal order of the interactions and the formats of the data units exchanged - essentially they determine the efficiency and reliability of computer networks. Protocol Engineering is an important discipline covering the design, validation, and implementation of communication protocols. Part I of this book is devoted to the fundamentals of communication protocols, describing their working principles and implicitly also those of computer networks. The author introduces the concepts of service, protocol, layer, and layered architecture, and introduces the main elements required in the description of protocols using a model language. He then presents the most important protocol functions. Part II deals with the description of communication proto cols, offering an overview of the various formal methods, the essence of Protocol Engineering. The author introduces the fundamental description methods, such as finite state machines, Petri nets, process calculi, and temporal logics, that are in part used as semantic models for formal description techniques. He then introduces one represen tative technique for each of the main description approaches, among others SDL and LOTOS, and surveys the use of UML for describing protocols. Part III covers the protocol life cycle and the most important development stages, presenting the reader with approaches for systematic protocol design, with various verification methods, with the main implementation techniques, and with strategies for their testing, in particular with conformance and interoperability tests, and the test description language TTCN. The author uses the simple data transfer example protocol XDT (eXample Data Transfer) throughout the book as a reference protocol to exemplify the various description techniques and to demonstrate important validation and implementation approaches. The book is an introduction to communication protocols and their development for undergraduate and graduate students of computer science and communication technology, and it is also a suitable reference for engineers and programmers. Most chapters contain exercises, and the author's accompanying website provides further online material including a complete formal description of the XDT protocol and an animated simulation visualizing its behavior.

Software development is a complex problem-solving activity with a high level of uncertainty. There are many technical challenges concerning scheduling, cost estimation, reliability, performance, etc, which are further aggravated by weaknesses such as changing requirements, team dynamics, and high staff turnover. Thus the management of knowledge and experience is a key means of systematic software development and process improvement. "Managing Software Engineering Knowledge" illustrates several theoretical examples of this vision and solutions applied to industrial practice. It is structured in four parts addressing the motives for knowledge management, the concepts and models used in knowledge management for software engineering, their application to software engineering, and practical guidelines for managing software engineering knowledge. This book provides a comprehensive overview of the state of the art and best practice in knowledge management applied to software engineering. While researchers and graduate students will benefit from the interdisciplinary approach leading to basic frameworks and methodologies, professional software developers and project managers will also profit from industrial experience reports and practical guidelines.

This book describes how to apply ICONIX Process (a minimal, use case-driven modeling process) in an agile software project. It's full of practical advice for avoiding common agile pitfalls. Further, the book defines a core agile subset so those of you who want to get agile need not spend years learning to do it. Instead, you can simply read this book and apply the core subset of techniques.

The book follows a real-life .NET/C# project from inception and UML modeling, to working code through several iterations. You can then go on-line to compare the finished product with the initial set of use cases.

The book also introduces several extensions to the core ICONIX Process, including combining Test-Driven Development (TDD) with up-front design to maximize both approaches (with examples using Java and JUnit). And the book incorporates persona analysis to drive the projects goals and reduce requirements churn.

Since the early seventies concepts of specification have become central in the whole area of computer science. Especially algebraic specification techniques for abstract data types and software systems have gained considerable importance in recent years. They have not only played a central role in the theory of data type specification, but meanwhile have had a remarkable influence on programming language design, system architectures, arid software tools and environments. The fundamentals of algebraic specification lay a basis for teaching, research, and development in all those fields of computer science where algebraic techniques are the subject or are used with advantage on a conceptual level. Such a basis, however, we do not regard to be a synopsis of all the different approaches and achievements but rather a consistently developed theory. Such a theory should mainly emphasize elaboration of basic concepts from one point of view and, in a rigorous way, reach the state of the art in the field. We understand fundamentals in this context as: 1. Fundamentals in the sense of a carefully motivated introduction to algebraic specification, which is understandable for computer scientists and mathematicians. 2. Fundamentals in the sense of mathematical theories which are the basis for precise definitions, constructions, results, and correctness proofs. 3. Fundamentals in the sense of concepts from computer science, which are introduced on a conceptual level and formalized in mathematical terms.

Since the introduction of personal computers, software has emerged as a driving force in the global economy and a major industry in its own right. During this time, the U.S. government has reversed its prior policy against software patents and is now issuing thousands of such patents each year, provoking heated controversy among programmers, lawyers, scholars, and software companies. This book is the first to step outside of the highly-polarized debate and examine the current state of the law, its suitability to the realities of software development, and its implications for day-to-day software development.

Written by a former lawyer and working software developer, "Inventing Software" provides a comprehensive overview of software patents, from the lofty perspectives of legal history and computing theory to the technical details and issues of actual patents. People interested in the legal aspect of software patents will find detailed technical analysis of actual patented software, the legal strategies behind the wording of the patents, and an analysis of the ease or difficulty of detecting infringements. Software developers will find ways to integrate patent planning into their standard software engineering practices, and a practical guide for studying and appraising their competitors' patents and safeguarding the value of their own. Intended primarily for programmers and software industry executives and managers, "Inventing Software" will also be useful, illuminating reading for attorneys and software company investors.

Today's distributed systems are characterized by interactions-often complex-between many different hardware and software components cooperating and exchanging information. To simplify development of interactive systems and facilitate communication and documentation, experts of varying disciplines employ descriptions, or specifications, of a given system's behavior and/or structure. Specification and Development of Interactive Systems offers a unique approach to program and software development suitable for large distributed systems, with an emphasis on modular system development and systems engineering. The authors build a basic method, called FOCUS, that enables interactive systems to be described by characterizing their histories of message interaction. The method covers functional requirements, timing, structure, and implementation issues of systems. In addition, the book describes how to connect the models and techniques to tables and diagram-based methods popular in practical systems engineering. Topics and features: * Specification of interface behavior and modular top-down system development * Specification of time and the modeling of hardware/software systems * Interface refinement and the modeling of development steps leading from one level of abstraction to the next * State transition diagrams and tables and the usage of common description techniques, such as found in UML This book provides a mathematical and logical foundation for the specification and development of interactive systems based on a model that describes systems in terms of their input/output behavior. The reader gains a comprehensive understanding of all fundamental models, techniques, and methods for interactive system design. The book is an essential resource for all researchers and professionals in computer science, software systems engineering and computer engineering.

Object-Process Methodology (OPM) is a comprehensive novel approach to systems engineering. Integrating function, structure and behavior in a single, unifying model, OPM significantly extends the system modeling capabilities of current object-oriented methods. Founded on a precise generic ontology and combining graphics with natural language, OPM is applicable to virtually any domain of business, engineering and science. Relieved from technical issues, system architects can use OPM to engage in the creative design of complex systems.The book presents the theory and practice of OPM with examples from various industry segments and engineering disciplines, as well as daily life. It includes a CD-ROM demo version of the award-winning OPM-supporting Object-Process CASE Tool (OPCAT). Using the numerous examples and exercises (with answers) in the book, this software enables the reader to gain hands-on experience in developing complex systems.

This innovative resource provides the most comprehensive coverage of software fault tolerance techniques to guide professionals through design, operation and performance. It features an in-depth discussion on the advantages and disadvantages of specific techniques, so practitioners can decide which ones are best suited for their work. The book examines key programming techniques such as assertions, checkpointing, and atomic actions, and provides design tips and models to assist in the development of critical software fault tolerance software systems that help ensure dependable performance. From software reliability, recovery and redundancy to design- and data-diverse software fault tolerance techniques, this practical reference provides detailed insight into techniques that will improve the overall quality of software.

This book provides a coherent methodology for Model-Driven Requirements Engineering which stresses the systematic treatment of requirements within the realm of modelling and model transformations. The underlying basic assumption is that detailed requirements models are used as first-class artefacts playing a direct role in constructing software. To this end, the book presents the Requirements Specification Language (RSL) that allows precision and formality, which eventually permits automation of the process of turning requirements into a working system by applying model transformations and code generation to RSL. The book is structured in eight chapters. The first two chapters present the main concepts and give an introduction to requirements modelling in RSL. The next two chapters concentrate on presenting RSL in a formal way, suitable for automated processing. Subsequently, chapters 5 and 6 concentrate on model transformations with the emphasis on those involving RSL and UML. Finally, chapters 7 and 8 provide a summary in the form of a systematic methodology with a comprehensive case study. Presenting technical details of requirements modelling and model transformations for requirements, this book is of interest to researchers, graduate students and advanced practitioners from industry. While researchers will benefit from the latest results and possible research directions in MDRE, students and practitioners can exploit the presented information and practical techniques in several areas, including requirements engineering, architectural design, software language construction and model transformation. Together with a tool suite available online, the book supplies the reader with what it promises: the means to get from requirements to code "in a snap".

This book provides a comprehensive overview of digital signal processing for a multi-disciplinary audience. It posits that though the theory involved in digital signal processing stems from electrical, electronics, communication, and control engineering, the topic has use in other disciplinary areas like chemical, mechanical, civil, computer science, and management. This book is written about digital signal processing in such a way that it is suitable for a wide ranging audience. Readers should be able to get a grasp of the field, understand the concepts easily, and apply as needed in their own fields. It covers sampling and reconstruction of signals; infinite impulse response filter; finite impulse response filter; multi rate signal processing; statistical signal processing; and applications in multidisciplinary domains. The book takes a functional approach and all techniques are illustrated using Matlab.

Computer interfaces and documentation are notoriously difficult for any user, regardless of his or her level of experience. Advances in technology are not making applications more friendly. Introducing concepts from linguistics and language teaching, Language and Communication proposes a new approach to computer interface design. The book explains for the first time why the much hyped user-friendly interface is treated with such derision by the user community. The author argues that software and hardware designers should consider such fundamental language concepts as meaning, context, function, variety, and equivalence. She goes on to show how imagining an interface as a new language can be an invaluable design exercise, calling into question deeply held beliefs and assumptions about what users will or will not understand. Written for a wide range of computer scientists and professionals, and presuming no prior knowledge of language-related terminology, this volume is a key step in the on-going information revolution.

It is, indeed, widely acceptable today that nowhere is it more important to focus on the improvement of software quality than in the case of systems with requirements in the areas of safety and reliability - especially for distributed, real-time and embedded systems. Thus, much research work is under progress in these fields, since software process improvement impinges directly on achieved levels of quality, and many application experiments aim to show quantitative results demonstrating the efficacy of particular approaches. Requirements for safety and reliability - like other so-called non-functional requirements for computer-based systems - are often stated in imprecise and ambiguous terms, or not at all. Specifications focus on functional and technical aspects, with issues like safety covered only implicitly, or not addressed directly because they are felt to be obvious; unfortunately what is obvious to an end user or system user is progressively less so to others, to the extend that a software developer may not even be aware that safety is an issue. Therefore, there is a growing evidence for encouraging greater understanding of safety and reliability requirements issues, right across the spectrum from end user to software developer; not just in traditional safety-critical areas (e.g. nuclear, aerospace) but also acknowledging the need for such things as heart pacemakers and other medical and robotic systems to be highly dependable.

Broadly-scoped requirements such as security, privacy, and response time are a major source of complexity in modern software systems. This is due to their tangled inter-relationships with and effects on other requirements. Aspect-Oriented Requirements Engineering (AORE) aims to facilitate modularisation of such broadly-scoped requirements, so that software developers are able to reason about them in isolation - one at a time. AORE also captures these inter-relationships and effects in well-defined composition specifications, and, in so doing exposes the causes for potential conflicts, trade-offs, and roots for the key early architectural decisions. Over the last decade, significant work has been carried out in the field of AORE. With this book the editors aim to provide a consolidated overview of these efforts and results. The individual contributions discuss how aspects can be identified, represented, composed and reasoned about, as well as how they are used in specific domains and in industry. Thus, the book does not present one particular AORE approach, but conveys a broad understanding of the aspect-oriented perspective on requirements engineering. The chapters are organized into five sections: concern identification in requirements, concern modelling and composition, domain-specific use of AORE, aspect interactions, and AORE in industry. This book provides readers with the most comprehensive coverage of AORE and the capabilities it offers to those grappling with the complexity arising from broadly-scoped requirements - a phenomenon that is, without doubt, universal across software systems. Software engineers and related professionals in industry, as well as advanced undergraduate and post-graduate students and researchers, will benefit from these comprehensive descriptions and the industrial case studies.

The author's aim in this textbook is to provide students with a clear understanding of the relationship between the principles of object-oriented programming and software engineering. Professor Zeigler takes an approach based on state representation to formal specification. Consequently, this book is unique through its - emphasis on formulating primitives from which all other functionality can be built; - integral use of a semi-formal behaviour specification language based on state transition concepts; -differentiation between behaviour and implementation; -a reusable heterogeneous container class library; -ability to show the elegance and power of ensemble methods with non-trivial examples. As a result, students studying software engineering will find this a distinctive and valuable approach to programming and systems engineering.

Component-based software development regards software construction in terms of conventional engineering disciplines where the assembly of systems from readily-available prefabricated parts is the norm. Because both component-based systems themselves and the stakeholders in component-based development projects are different from traditional software systems, component-based testing also needs to deviate from traditional software testing approaches.

Gross first describes the specific challenges related to component-based testing like the lack of internal knowledge of a component or the usage of a component in diverse contexts. He argues that only built-in contract testing, a test organization for component-based applications founded on building test artifacts directly into components, can prevent catastrophic failures like the one that caused the now famous ARIANE 5 crash in 1996. Since building testing into components has implications for component development, built-in contract testing is integrated with and made to complement a model-driven development method. Here UML models are used to derive the testing architecture for an application, the testing interfaces and the component testers. The method also provides a process and guidelines for modeling and developing these artifacts.

This book is the first comprehensive treatment of the intricacies of testing component-based software systems. With its strong modeling background, it appeals to researchers and graduate students specializing in component-based software engineering. Professionals architecting and developing component-based systems will profit from the UML-based methodology and the implementation hints based on the XUnit and JUnit frameworks.