Search

This book constitutes the refereed post-proceedings of the Second International Workshop on Foundational and Practical Aspects of Resource Analysis, FOPARA 2011, held in Madrid, Spain, in May 2011. The 8 revised full papers were carefully reviewed and selected from the papers presented at the workshop and papers submitted following an open call for contributions after the workshop. The papers are organized in the following topical sections: implicit complexity, analysis and verfication of cost expressions, and worst case execution time analysis.

This book constitutes the refereed proceedings of the 11th International Conference on Software Process Improvement and Capability Determination, SPICE 2011, held in Dublin, Ireland, in May/June 2011. The 15 revised full papers presented and 15 short papers were carefully reviewed and selected from numerous submissions. The papers are organized in topical sections on process modelling and assessment, safety and security, medi SPICE, high maturity, implementation and improvement.

This volume constitutes the refereed proceedings of the 20th EuroSPI conference, held in Dundalk, Ireland, in June 2013. The 31 revised papers presented in this volume were carefully reviewed and selected. They are organized in topical sections on SPI Safety and Regulation Issues; SPI Lifecycle and Models; SPI Quality and Testing Issues; SPI Networks and Teams; SPI and Reference Models; SPI Implementation; Agile organisations and an agile management process group; Managing Diversity and Innovation; SPI and Measurement; Risk Management and Functional Safety Standards.

Reuse and integration are defined as synergistic concepts, where reuse addresses how to minimize redundancy in the creation of components; while, integration focuses on component composition. Integration supports reuse and vice versa. These related concepts support the design of software and systems for maximizing performance while minimizing cost. Knowledge, like data, is subject to reuse; and, each can be interpreted as the other. This means that inherent complexity, a measure of the potential utility of a system, is directly proportional to the extent to which it maximizes reuse and integration. Formal methods can provide an appropriate context for the rigorous handling of these synergistic concepts. Furthermore, formal languages allow for non ambiguous model specification; and, formal verification techniques provide support for insuring the validity of reuse and integration mechanisms. This edited book includes 12 high quality research papers written by experts in formal aspects of reuse and integration to cover the most recent advances in the field. These papers are extended versions of some of the best papers, which were presented at the IEEE International Conference on Information Reuse and Integration and the IEEE International Workshop on Formal Methods Integration - both of which were held in San Francisco in August 2014.

Software reuse and integration has been described as the process of creating software systems from existing software rather than building software systems from scratch. Whereas reuse solely deals with the artifacts creation, integration focuses on how reusable artifacts interact with the already existing parts of the specified transformation. Currently, most reuse research focuses on creating and integrating adaptable components at development or at compile time. However, with the emergence of ubiquitous computing, reuse technologies that can support adaptation and reconfiguration of architectures and components at runtime are in demand.This edited book includes 15 high quality research papers written by experts in information reuse and integration to cover the most recent advances in the field. These papers are extended versions of the best papers which were presented at IEEE International Conference on Information Reuse and Integration and IEEE International Workshop on Formal Methods Integration, which was held in San Francisco in August 2013.

This book constitutes the refereed proceedings of the 14th International Conference on Product-Focused Software Process Improvement, PROFES 2013, held in Paphos, Cyprus, in June 2013. The 22 revised full papers presented together with 10 short papers and 2 tutorial papers were carefully reviewed and selected from 41 submissions. The papers are organized in topical sections on empirical software engineering, software process improvement, managing software processes, software measurement, decision support in software engineering, safety-critical software engineering, and software maintenance.

The book constitutes the refereed proceedings of the 11th International Conference on Software Composition, SC 2012, held in Prague, Czech Republic, in May/June 2012, co-located with TOOLS 2012 Federated Conferences. The 12 revised full papers were carefully reviewed and selected from 42 submissions for inclusion in the book. The papers reflect all current research in software composition and are organized in topical sections on software composition in specification languages; context-aware and dynamic composition; composition in software development; and applications of software composition.

This book constitutes the refereed proceedings of the 5th International Conference, ICMT 2012, held in Prague, Czech Republic, in May 2012, co-located with TOOLS 2012 Federated Conferences. The 18 full papers presented together with one invited paper were carefully revised and selected from numerous submissions. Topics addressed are such as testing, typing and verification; bidirectionality; applications and visualization; transformation languages, virtual machines; pattern matching; and transformations in modelling, reutilization.

This volume, the 8th in the Transactions on Aspect-Oriented Software Development series, contains two regular submissions and a special section, consisting of five papers, on the industrial applications of aspect technology. The regular papers describe a framework for constructing aspect weavers, and patterns for reusable aspects. The special section begins with an invited contribution on how AspectJ is making its way from an exciting new hype topic to a valuable technology in enterprise computing. The remaining four papers each cover different industrial applications of aspect technology, which include a telecommunication platform, a framework for embedding user assistance in independently developed applications, a platform for digital publishing, and a framework for program code analysis and manipulation.

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, evaluation of such approaches and their impact on improving quality attributes of software systems.This book, the first volume in the Transactions on Aspect-Oriented Software Development series, presents nine revised papers that have been through a careful peer reviewing process by the journal's Editorial Board. The papers cover a wide range of topics from software design to implementation of aspect-oriented languages. The first four articles address various issues of aspect-oriented modeling at the design level; the following four articles discuss various programming language issues. The final article in this volume describes a workbench for implementing aspect-oriented languages, so that easy experimentation with new language features and implementation techniques are possible.

This book addresses extensible and adaptable computing, a broad range of methods and techniques used to systematically tackle the future growth of systems and respond proactively and seamlessly to change. The book is divided into five main sections: Agile Software Development, Data Management, Web Intelligence, Machine Learning and Computing in Education. These sub-domains of computing work together in mutually complementary ways to build systems and applications that scale well, and which can successfully meet the demands of changing times and contexts. The topics under each track have been carefully selected to highlight certain qualitative aspects of applications and systems, such as scalability, flexibility, integration, efficiency and context awareness. The first section (Agile Software Development) includes six contributions that address related issues, including risk management, test case prioritization and tools, open source software reliability and predicting the change proneness of software. The second section (Data Management) includes discussions on myriad issues, such as extending database caches using solid-state devices, efficient data transmission, healthcare applications and data security. In turn, the third section (Machine Learning) gathers papers that investigate ML algorithms and present their specific applications such as portfolio optimization, disruption classification and outlier detection. The fourth section (Web Intelligence) covers emerging applications such as metaphor detection, language identification and sentiment analysis, and brings to the fore web security issues such as fraud detection and trust/reputation systems. In closing, the fifth section (Computing in Education) focuses on various aspects of computer-aided pedagogical methods.

This book describes a structured sketching methodology to help you create alternative design ideas and sketch them on paper. The Five Design-Sheet method acts as a check-list of tasks, to help you think through the problem, create new ideas and to reflect upon the suitability of each idea. To complement the FdS method, we present practical sketching techniques, discuss problem solving, consider professional and ethical issues of designing interfaces, and work through many examples.Five Design-Sheets: Creative Design and Sketching for Computing and Visualization is useful for designers of computer interfaces, or researchers needing to explore alternative solutions in any field. It is written for anyone who is studying on a computing course and needs to design a computing-interface or create a well-structured design chapter for their dissertation, for example. We do acknowledge that throughout this book we focus on the creation of interactive software tools, and usethe case study of building data-visualization tools. We have however, tried to keep the techniques general enough such that it is beneficial for a wide range of people, with different challenges and different situations, and for different applications.

This book is by far the most systematic and comprehensive review of the field of automated software composition. Based on a formally described and reproducible methodology, it critically discusses the approaches, which are relevant for experts interested in an organized overview of related work. It also provides an introduction and intuitive classification system for researchers new to the field.In order to create this survey, several dozen papers were analyzed with respect to the concrete problems they tackle and the proposed solutions. It delivers both an overview and a qualitative comparison of the approaches, and answers three research questions: What types of automated software composition problems exist? In which use cases do these problems typically occur? And what are the most prominent solution paradigms for the different types? Overall, this book saves a great deal of time for everyone pursuing research in the area of automated software compositionwho needs a comprehensive guide that helps them understand the field, and that relates new approaches to existing ones.

This book constitutes the refereed proceedings of the 15th International Conference on Model Driven Engineering Languages and Systems, MODELS 2012, held in Innsbruck, Austria, in September/October 2012. The 50 papers presented in this volume were carefully reviewed and selected from a total of 181 submissions. They are organized in topical sections named: metamodels and domain specific modeling; models at runtime; model management; modeling methods and tools, consistency analysis, software product lines; foundations of modeling; static analysis techniques; model testing and simulation; model transformation; model matching, tracing and synchronization; modeling practices and experience; and model analysis.

Requirements engineering has since long acknowledged the importance of the notion that system requirements are stakeholder goals—rather than system functions—and ought to be elicited, modeled and analyzed accordingly. In this book, Nurcan and her co-editors collected twenty contributions from leading researchers in requirements engineering with the intention to comprehensively present an overview of the different perspectives that exist today, in 2010, on the concept of intention in the information systems community. These original papers honor Colette Rolland for her contributions to this field, as she was probably the first to emphasize that ‘intention'has to be considered as a first-class concept in information systems engineering. Written by long-term collaborators (and most often friends) of Colette Rolland, this volume covers topics like goal-oriented requirements engineering, model-driven development, method engineering, and enterprise modeling. As such, it is a tour d'horizon of Colette Rolland's lifework, and is presented to her on the occasion of her retirement at CaISE 2010 in Hammamet, the conference she once cofounded and which she helped to grow and prosper for more than 20 years.

Abstraction is the most basic principle of software engineering. Abstractions are provided by models. Modeling and model transformation constitute the core of model-driven development. Models can be refined and finally be transformed into a technical implementation, i.e., a software system. The aim of this book is to give an overview of the state of the art in model-driven software development. Achievements are considered from a conceptual point of view in the first part, while the second part describes technical advances and infrastructures. Finally, the third part summarizes experiences gained in actual projects employing model-driven development. Beydeda, Book and Gruhn put together the results from leading researchers in this area, both from industry and academia. The result is a collection of papers which gives both researchers and graduate students a comprehensive overview of current research issues and industrial forefront practice, as promoted by OMG's MDA initiative.

This open access book provides a basic introduction to feature modelling and analysis as well as to the integration of AI methods with feature modelling. It is intended as an introduction for researchers and practitioners who are new to the field and will also serve as a state-of-the-art reference to this audience. While focusing on the AI perspective, the book covers the topics of feature modelling (including languages and semantics), feature model analysis, and interacting with feature model configurators. These topics are discussed along the AI areas of knowledge representation and reasoning, explainable AI, and machine learning.

This book provides a comprehensive, empirically grounded exploration of how Generative AI is reshaping the landscape of software development. It emphasizes the empirical evaluation of Generative AI tools in real-world scenarios, offering insights into their practical efficacy, limitations, and impact. By presenting case studies, surveys, and interviews from various software development contexts, the book offers a global perspective on the integration of Generative AI, highlighting how these advanced tools are adapted to and influence diverse cultural, organizational, and technological environments. This book is structured to provide a comprehensive understanding of Generative AI and its transformative impact on the field of software engineering. The book is divided into five parts, each focusing on different aspects of Generative AI in software development. As an introduction, Part 1 presents the fundamentals of Generative AI adoption. Part 2 is a collection of empirical studies and delves into the practical aspects of integrating Generative AI tools in software engineering, with a focus on patterns, methodologies, and comparative analyses. Next, Part 3 presents case studies that showcase the application and impact of Generative AI in various software development contexts. Part 4 then examines how Generative AI is reshaping software engineering processes, from collaboration and workflow to management and agile development. Finally, Part 5 looks towards the future, exploring emerging trends, future directions, and the role of education in the context of Generative AI. The book offers diverse perspectives as it compiles research and experiences from various countries and software development environments. It also offers non-technical discussions about Generative AI in management, teamwork, business and education. This way, it is intended for both researchers in software engineering and for professionals in industry who want to learn about the impactof Generative AI on software development.

This book provides an overview of software security analysis in a DevOps cycle including requirements formalisation, verification and continuous monitoring. It presents an overview of the latest techniques and tools that help engineers and developers verify the security requirements of large-scale industrial systems and explains novel methods that enable a faster feedback loop for verifying security-related activities, which rely on techniques such as automated testing, model checking, static analysis, runtime monitoring, and formal methods. The book consists of three parts, each covering a different aspect of security engineering in the DevOps context. The first part,'Security Requirements', explains how to specify and analyse security issues in a formal way. The second part,'Prevention at Development Time', offers a practical and industrial perspective on how to design, develop and verify secure applications. The third part,'Protection at Operations', eventually introduces tools for continuous monitoring of security events and incidents. Overall, it covers several advanced topics related to security verification, such as optimizing security verification activities, automatically creating verifiable specifications from security requirements and vulnerabilities, and using these security specifications to verify security properties against design specifications and generate artifacts such as tests or monitors that can be used later in the DevOps process. The book aims at computer engineers in general and does not require specific knowledge. In particular, it is intended for software architects, developers, testers, security professionals, and tool providers, who want to define, build, test, and verify secure applications, Web services, and industrial systems.

This book offers a practical introduction to the use of artificial intelligence (AI) techniques to improve and optimise the various phases of the software development process, from the initial project planning to the latest deployment. All chapters were written by leading experts in the field and include practical and reproducible examples. Following the introductory chapter, Chapters 2-9 respectively apply AI techniques to the classic phases of the software development process: project management, requirement engineering, analysis and design, coding, cloud deployment, unit and system testing, and maintenance. Subsequently, Chapters 10 and 11 provide foundational tutorials on the AI techniques used in the preceding chapters: metaheuristics and machine learning. Given its scope and focus, the book represents a valuable resource for researchers, practitioners and students with a basic grasp of software engineering.

This book guides the reader through a design process that was tested and optimized in companies and design bureaus. It not only smoothly integrates modern product development techniques, but also addresses, for each phase, issues related to the management of intangible assets. There are several books on the product design process, as well as on the development of innovative products in general. However, none of them addresses how to integrate the engineering techniques with the necessary aspects of Intellectual Property Management. With a focus on software intensive products in general, the book presents a meta-process that adapts to product design in any area where the software element is an important factor in product functionality and innovation.

This book highlights recent research advances in various domains related to software ecosystems such as library reuse, collaborative development, cloud computing, open science, sentiment analysis and machine learning. A key aspect of software ecosystems is that software products belong to ever more interdependent networks of co-evolving software components. The ever-increasing importance of social coding platforms has made software ecosystems indispensable to software practitioners, in commercial as well as open-source settings.The book starts with an introductory chapter that provides a historical account of the origins of software ecosystems. It provides the necessary context about the domain of software ecosystems by highlighting its different perspectives, definitions, and representations. It also exemplifies the variety of software ecosystems that have emerged during the previous decades. The remaining book is composed of five parts: Part I contains two chapters on software ecosystem representations, Part II two chapters that focus on complementary ways and techniques of analyzing software ecosystems. Next, Part III includes two chapters that focus on aspects related to the evolution within software ecosystems, while Part IV looks at workflow automation and infrastructure-as-code ecosystems. Finally, Part V focuses on ecosystems for software modeling and for data-intensive software.This book is intended for researchers and practitioners interested in data mining, tooling, and empirical analysis of software ecosystems. The reader will appreciate chapters that cover a wide spectrum of social and technical aspects of software ecosystems, each including an overview of the state of the art.Chapter 2 The Software Heritage Open Science Ecosystem is available open access under a Creative Commons Attribution 4.0 International License via link.springer.com.

This book focuses on crisis management in software development which includes forecasting, responding and adaptive engineering models, methods, patterns and practices. It helps the stakeholders in understanding and identifying the key technology, business and human factors that may result in a software production crisis. These factors are particularly important for the enterprise-scale applications, typically considered very complex in managerial and technological aspects and therefore, specifically addressed by the discipline of software engineering. Therefore, this book throws light on the crisis responsive, resilient methodologies and practices; therewith, it also focuses on their evolutionary changes and the resulting benefits.

In this book the author explains domain engineering and the underlying science, and he then shows how we can derive requirements prescriptions for computing systems from domain descriptions. A further motivation is to present domain descriptions, requirements prescriptions, and software design specifications as mathematical quantities.The author's maxim is that before software can be designed we must understand its requirements, and before requirements can be prescribed we must analyse and describe the domain for which the software is intended. He does this by focusing on what it takes to analyse and describe domains. By a domain we understand a rationally describable discrete dynamics segment of human activity, of natural and man-made artefacts, examples include road, rail and air transport, container terminal ports, manufacturing, trade, healthcare, and urban planning. The book addresses issues of seemingly large systems, not small algorithms, and it emphasizes descriptionsas formal, mathematical quantities.This is the first thorough monograph treatment of the new software engineering phase of software development, one that precedes requirements engineering. It emphasizes a methodological approach by treating, in depth, analysis and description principles, techniques and tools. It does this by basing its domain modeling on fundamental philosophical principles, a view that is new for a computer science monograph.The book will be of value to computer scientists engaged with formal specifications of software. The author reveals this as a field of interesting problems, most chapters include pointers to further study and exercises drawn from practical engineering and science challenges. The text is supported by a primer to the formal specification language RSL and extensive indexes.

This book presents interdisciplinary research in software engineering with applications for the social sector. The author focuses on software applications that are used for social good and that serve the needs of society. The author aims to bridge the knowledge gap between requirement engineers, industry, and users in order to help identify a diverse range of needs in the social sector (taking into account user crowd diversity in terms of technological competencies, geography, demographics, and behavioral and psychographic aspects). The book provides rigorous empirical studies and validates solutions that serve as a guide to the software engineering community, researchers, graduate students, and teachers.Provides interdisciplinary research in software engineering and the needs of the social sector, helping to increase success rates of society focused startups and applicationsIdeal for social entrepreneurs who can use the book for doing customer development with diverse usersEstablishes a new research line of social sector requirement engineering, taking into account user age, language, ability, and access

This textbook examines database systems from the viewpoint of a software developer. This perspective makes it possible to investigate why database systems are the way they are. It is of course important to be able to write queries, but it is equally important to know how they are processed. We e.g. don't want to just use JDBC; we also want to know why the API contains the classes and methods that it does. We need a sense of how hard is it to write a disk cache or logging facility. And what exactly is a database driver, anyway?The first two chapters provide a brief overview of database systems and their use. Chapter 1 discusses the purpose and features of a database system and introduces the Derby and SimpleDB systems. Chapter 2 explains how to write a database application using Java. It presents the basics of JDBC, which is the fundamental API for Java programs that interact with a database. In turn, Chapters 3-11 examine the internals of a typical database engine. Each chapter covers a different database component, starting with the lowest level of abstraction (the disk and file manager) and ending with the highest (the JDBC client interface); further, the respective chapter explains the main issues concerning the component, and considers possible design decisions. As a result, the reader can see exactly what services each component provides and how it interacts with the other components in the system. By the end of this part, s/he will have witnessed the gradual development of a simple but completely functional system. The remaining four chapters then focus on efficient query processing, and focus on the sophisticated techniques and algorithms that can replace the simple design choices described earlier. Topics include indexing, sorting, intelligent buffer usage, and query optimization.This text is intended for upper-level undergraduate or beginning graduate courses in Computer Science. It assumes that the reader is comfortable with basic Java programming; advanced Java concepts (such as RMI and JDBC) are fully explained in the text. The respective chapters are complemented by “end-of-chapter readings” that discuss interesting ideas and research directions that went unmentioned in the text, and provide references to relevant web pages, research articles, reference manuals, and books. Conceptual and programming exercises are also included at the end of each chapter. Students can apply their conceptual knowledge by examining the SimpleDB (a simple but fully functional database system created by the author and provided online) code and modifying it.

This open access book presents the outcomes of the “Design for Future – Managed Software Evolution” priority program 1593, which was launched by the German Research Foundation (“Deutsche Forschungsgemeinschaft (DFG)”) to develop new approaches to software engineering with a specific focus on long-lived software systems. The different lifecycles of software and hardware platforms lead to interoperability problems in such systems. Instead of separating the development, adaptation and evolution of software and its platforms, as well as aspects like operation, monitoring and maintenance, they should all be integrated into one overarching process.Accordingly, the book is split into three major parts, the first of which includes an introduction to the nature of software evolution, followed by an overview of the specific challenges and a general introduction to the case studies used in the project. The second part of the book consists of the main chapters on knowledge carrying software, and cover tacit knowledge in software evolution, continuous design decision support, model-based round-trip engineering for software product lines, performance analysis strategies, maintaining security in software evolution, learning from evolution for evolution, and formal verification of evolutionary changes. In turn, the last part of the book presents key findings and spin-offs. The individual chapters there describe various case studies, along with their benefits, deliverables and the respective lessons learned. An overview of future research topics rounds out the coverage.The book was mainly written for scientific researchers and advanced professionals with an academic background. They will benefit from its comprehensive treatment of various topics related to problems that are now gaining in importance, given the higher costs for maintenance and evolution in comparison to the initial development, and the fact that today, most software is not developed from scratch, but as part of a continuum of former and future releases.

This book focuses on software fault detection and correction processes, presenting 5 different paired models introduced over the last decade and discussing their applications, in particular to determining software release time. The first work incorporates the testing effort function and the fault introduction process into the paired fault detection and fault correction models. The second work incorporates fault dependency, while the third adopts a Markov approach for studying fault detection and correction processes. The fourth work considers the multi-release property of various software, and models fault detection and correction processes. The last work classifies faults into four types and models the fault-detection and correction processes. Enabling readers to familiarize themselves with how software reliability can be modeled when different factors need to be considered, and how the approaches can be used to analyze other systems, the book is important referenceguide for researchers in the field of software reliability engineering and practitioners working on software projects. To gain the most from the book, readers should have a firm grasp of the fundamentals of the stochastic process.

This book provides a comprehensive overview of the field of software processes, covering in particular the following essential topics: software process modelling, software process and lifecycle models, software process management, deployment and governance, and software process improvement (including assessment and measurement). It does not propose any new processes or methods; rather, it introduces students and software engineers to software processes and life cycle models, covering the different types ranging from “classical”, plan-driven via hybrid to agile approaches.The book is structured as follows: In chapter 1, the fundamentals of the topic are introduced: the basic concepts, a historical overview, and the terminology used. Next, chapter 2 covers the various approaches to modelling software processes and lifecycle models, before chapter 3 discusses the contents of these models, addressing plan-driven, agile and hybrid approaches. The following three chapters address various aspects of using software processes and lifecycle models within organisations, and consider the management of these processes, their assessment and improvement, and the measurement of both software and software processes. Working with software processes normally involves various tools, which are the focus of chapter 7, before a look at current trends in software processes in chapter 8 rounds out the book.This book is mainly intended for graduate students and practicing professionals. It can be used as a textbook for courses and lectures, for self-study, and as a reference guide. When used as a textbook, it may support courses and lectures on software processes, or be used as complementary literature for more basic courses, such as introductory courses on software engineering or project management. To this end, it includes a wealth of examples and case studies, and each chapter is complemented by exercises that help readers gain a better command of the concepts discussed.

This work is a historical and philosophical study of the programming work carried out by John von Neumann in the period 1945-8. At the heart of the book is an examination of a manuscript featuring the earliest known surviving example of von Neumann's coding, a routine written in 1945 to ‘mesh'two sequences of data and intended to be part of a larger program implementing the algorithm now known as mergesort. The text of the manuscript itself, along with a preliminary document describing the code he used to write this program, are reproduced as appendices. The program is approached in three chapters describing the historical background to von Neumann's work, the significance of the sorting application itself, and the development of the EDVAC, the machine for which the program was written. The subsequent chapters widen the focus again, discussing the subsequent evolution of the program and the crucial topic of subroutines, before concluding by situating von Neumann's work in a number of wider contexts. The book also offers a unifying philosophical interpretation of von Neumann's approach to coding.

This book is a self-contained, practical introduction how to use FeatureIDE for modeling and implementing variable systems. In particular, readers learn how to analyze domains using feature models, specify requirements in form of configurations, and how to generate code based on conditional compilation and feature-oriented programming. Given the interactive style of the book, readers can directly try out the open-source development environment. All code examples are available in the standard distribution on GitHub and can immediately been used for individual modifications. Each part of the book is presented as a step-by-step tutorial and additionally illustrated using an ongoing example of elevator control software written in Java.Written by the core development team of FeatureIDE, this book is suitable for students using a tool for deepening the theoretical foundations of variability modeling and implementation, and as a reference for practitioners needing a stable and scalable tool for industrial applications. FeatureIDE is the most used open-source tool for feature modeling and has been continuously improved since 2004. The success of FeatureIDE is due to being a vehicle for cutting-edge product-line research by still providing an easy-to-use and seamless integration into Eclipse.

This book presents the SigniFYI Suite of conceptual and methodological tools, designed to uncover meanings inscribed in software, their origins, intent and consequences to identify and trace correlating patterns; from software design and development to software use and experience.Based on the study of Semiotic Engineering, the book advances the e study of Human-Centered Computing (HCC), inviting professionals, researchers, teachers and students to reflect upon how subjective and cultural values manifest themselves through software models, programs and user interfaces.Theauthors weave a mesh of technical, theoretical and philosophical considerations of what it means to build and use software, exploring what we (professionals and non-professionals) mean by the pieces of software we design and develop, as well as what pieces of software mean to end-users and others.Explicitly dedicated to software designers, developers and users, Software Developers as Users is a provocative view of socio-technical communication in the digital age.

This book opens the “black box” of software sourcing by explaining how dynamic software alignment is established and how it impacts business performance outcomes. By investigating how software-sourcing modes are related to value generation in the post-implementation phase, it shows researchers and managers the impact logic of on-demand, on-premises, and in-house software on dynamic fit and process-level performance outcomes in a client organization. It describes dynamic IT alignment as the key to success in a fast-moving digital world with software-as-a-service on the rise and highlights the fact that today companies can choose between developing software in-house (make) or sourcing packaged systems in an on-premises (buy) or an on-demand (lease) mode. This book is the first to explicitly compare these sourcing arrangements with each other in terms of alignment and business performance.

As interactive systems are quickly becoming integral to our everyday lives, this book investigates how we can make these systems, from desktop and mobile apps to more wearable and immersive applications, more usable and maintainable by using HCI design patterns. It also examines how we can facilitate the reuse of design practices in the development lifecycle of multi-devices, multi-platforms and multi-contexts user interfaces. Effective design tools are provided for combining HCI design patterns and User Interface (UI) driven engineering to enhance design whilst differentiating between UI and the underlying system features. Several examples are used to demonstrate how HCI design patterns can support this decoupling by providing an architectural framework for pattern-oriented and model-driven engineering of multi-platforms and multi-devices user interfaces. Patterns of HCI Design and HCI Design of Patterns is for students, academics and Industry specialists who are concerned with user interfaces and usability within the software development community.

This SpringerBrief discusses multiple forms of open-source-inspired outsourcing: opensourcing, innersourcing and crowdsourcing. It uses a framework-based comparison to explain the strengths and weaknesses of each approach. By pointing out characteristics along with benefits and pitfalls of each approach, the authors provide nuanced and research-based advice to managers and developers facing software sourcing decisions. The differences and commonalities of these three emerging approaches are carefully analyzed. Chapters explore the primary challenges of reliability, efficiency and robustness in open-source methods. Examples from industrial cases are included, along with extensive references to recent research. The brief concludes with a comparative analysis of approaches and outlines key implications to be aware of when outsourcing. Software Sourcing in the Age of Open: Leveraging the Unknown Workforce is designed for professionals and researchers interested in outsourcing challenges. The content is also suitable for postgraduate students interested in contemporary software sourcing approaches.

Developers frequently introduce errors into software systems when they fail to recognise module dependencies.Using forty-three software families and Software Product Lines (SPLs), where the majority are commonly used in industrial practice, the authors reports on the feature modularization problem and provides a study of how often it may occur in practice. To solve the problem they present the concept of emergent feature modularization which aims to establish contracts between features to prevent developers from breaking other features when performing a maintenance task.

While previously available methodologies for software – like those published in the early days of object technology – claimed to be appropriate for every conceivable project, situational method engineering (SME) acknowledges that most projects typically have individual characteristics and situations. Thus, finding the most effective methodology for a particular project needs specific tailoring to that situation. Such a tailored software development methodology needs to take into account all the bits and pieces needed for an organization to develop software, including the software process, the input and output work products, the people involved, the languages used to describe requirements, design, code, and eventually also measures of success or failure.The authors have structured the book into three parts. Part I deals with all the basic concepts, terminology and overall ideas underpinning situational method engineering. As a summary of this part, they present a formal meta-model that enables readers to create their own quality methods and supporting tools. In Part II, they explain how to implement SME in practice, i.e., how to find method components and put them together and how to evaluate the resulting method. For illustration, they also include several industry case studies of customized or constructed processes, highlighting the impact that high-quality engineered methods can have on the success of an industrial software development. Finally, Part III summarizes some of the more recent and forward-looking ideas.This book presents the first summary of the state of the art for SME. For academics, it provides a comprehensive conceptual framework and discusses new research areas. For lecturers, thanks to its step-by-step explanations from basics to the customization and quality assessment of constructed methods, it serves as a solid basis for comprehensive courses on the topic. For industry methodologists, it offers a reference guide onfeatures and technologies to consider when developing in-house software development methods or customising and adopting off-the-shelf ones.

​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.

Co-Design is the set of emerging techniques which allows for the simultaneous design of Hardware and Software. In many cases where the application is very demanding in terms of various performances (time, surface, power consumption), trade-offs between dedicated hardware and dedicated software are becoming increasingly difficult to decide upon in the early stages of a design. Verification techniques - such as simulation or proof techniques - that have proven necessary in the hardware design must be dramatically adapted to the simultaneous verification of Software and Hardware. Describing the latest tools available for both Co-Design and Co-Verification of systems, Hardware/Software Co-Design and Co-Verification offers a complete look at this evolving set of procedures for CAD environments. The book considers all trade-offs that have to be made when co-designing a system. Several models are presented for determining the optimum solution to any co-design problem, including partitioning, architecture synthesis and code generation. When deciding on trade-offs, one of the main factors to be considered is the flow of communication, especially to and from the outside world. This involves the modeling of communication protocols. An approach to the synthesis of interface circuits in the context of co-design is presented. Other chapters present a co-design oriented flexible component data-base and retrieval methods; a case study of an ethernet bridge, designed using LOTOS and co-design methodologies and finally a programmable user interface based on monitors. Hardware/Software Co-Design and Co-Verification will help designers and researchers to understand these latest techniques in system design and as such will be of interest to all involved in embedded system design.

IFIP's Working Group 2.7(13.4)• has, since its establishment in 1974, con­ centrated on the software problems of user interfaces. From its original interest in operating systems interfaces the group has gradually shifted em­ phasis towards the development of interactive systems. The group has orga­ nized a number of international working conferences on interactive software technology, the proceedings of which have contributed to the accumulated knowledge in the field. The current title of the Working Group is'User Interface Engineering', with the aim of investigating the nature, concepts, and construction of user interfaces for software systems. The scope of work involved is: - to increase understanding of the development of interactive systems; - to provide a framework for reasoning about interactive systems; - to provide engineering models for their development. This report addresses all three aspects of the scope, as further described below. In 1986 the working group published a report (Beech, 1986) with an object-oriented reference model for describing the components of operating systems interfaces. The modelwas implementation oriented and built on an object concept and the notion of interaction as consisting of commands and responses. Through working with that model the group addressed a number of issues, such as multi-media and multi-modal interfaces, customizable in­ terfaces, and history logging. However, a conclusion was reached that many software design considerations and principles are independent of implemen­ tation models, but do depend on the nature of the interaction process.

This book is written for software engineers, software project leaders, and software managers who would like to introduce a new advanced software technology, expert systems, into their product. Expert system technology brings into programming a new dimension in which'rule of thumb'or heuristic expert knowledge is encoded in the program. In contrast to conventional procedural languages {e. g., Fortran or C}, expert systems employ high-level programming languages {Le., expert system shells} that enable us to capture the judgmental knowledge of experts such as geologists, doctors, lawyers, bankers, or insurance underwriters. Past expert systems have been more successfully applied in the problem areas of analysis and synthesis where the boundary of lo;nowledge is well defined and where experts are available and can be identified. Early successful applications include diagnosis systems such as MYCIN, geological systems such as PROSPECTOR, or design/configu­ ration systems such as XC ON. These early expert systems were mainly applicable to scientific and engineering problems, which are not theoreti­ cally well understood in terms of decisionmaking processes by their experts and which therefore require judgmental assessment. The more recent expert systems are being applied to sophisticated synthesis problems that involve a large number of choices, such as how the elements are to be compared. These problems normally entailed a large search space and slower speed for the expert systems designed. Examples of these systems include factory scheduling applications such as ISIS, or legal reasoning applications such as TAXMAN.

Herausgegeben für die Deutsche Forschungsanstalt für Luft- und Raumfahrt, Projektträger'Arbeit und Technik'

In any software project the analysis stage - documenting and designing requirements to meet the needs of the prospective users - is vital to the success of the project. This book provides a thorough introduction to analysis and where it fits into the software engineering process. The author applies his many years of experience both as a manager of software projects and as a consultant to numerous companies to illustrate succesful techniques and to identify potential pitfalls. The book is based on courses offered at Columbia University to a diverse audience of students and professionals. Throughout, the author is concerned to emphasize the stages of analysis and to identify many alternative modelling tools that an analyst can use. Particular emphasis is placed on Joint Application Development and on prototyping. Readers are assumed to have a reasonable understanding of computer concepts and terminology, and so this will be suitable for a first-level analysis course or it can be used by information systems professionals who need an in-depth understanding of the principles of the analysis and design process.

'In the mathematics I can report no deficience, except that it be that men do not sufficiently understand the excellent use of the pure mathematics, in that they do remedy and cure many defects in the wit and faculties intellectual. For if the wit be too dull, they sharpen it; if too wandering, they fix it; if too inherent in the sense, they abstract it.'Roger Bacon (1214?-1294?)'Mathematics-the art and science of effective reasoning.'E. W. Dijkstra, 1976'A person who had studied at a good mathematical school can do anything.'Ye. Bunimovich, 2000 This is the third book published by Kluwer based on the very successful OOPSLA workshops on behavioral semantics (the first two books were published in 1996 [KH 1996] and 1999 [KRS 1999]). These workshops fostered precise and explicit specifications of business and system semantics, independently of any (possible) realization. Some progress has been made in these areas, both in academia and in industry. At the same time, in too many cases only lip service to elegant specifica­ tions of semantics has been provided, and as a result the systems we build or buy are all too often not what they are supposed to be. We used to live with that, and quite often users relied on human intermediaries to'sort the things out.'This approach worked perfectly well for a long time.

In recent years, searching for source code on the web has become increasingly common among professional software developers and is emerging as an area of academic research. This volume surveys past research and presents the state of the art in the area of'code retrieval on the web.'This work is concerned with the algorithms, systems, and tools to allow programmers to search for source code on the web and the empirical studies of these inventions and practices. It is a label that we apply to a set of related research from software engineering, information retrieval, human-computer interaction, management, as well as commercial products. The division of code retrieval on the web into snippet remixing and component reuse is driven both by empirical data, and analysis of existing search engines and tools. Contributors include leading researchers from human-computer interaction, software engineering, programming languages, and management.'Finding Source Code on the Web for Remix and Reuse'consists of five parts. Part I is titled'Programmers and Practices,'and consists of a retrospective chapter and two empirical studies on how programmers search the web for source code. Part II is titled'From Data Structures to Infrastructures,'and covers the creation of ground-breaking search engines for code retrieval required ingenuity in the adaptation of existing technology and in the creation of new algorithms and data structures. Part III focuses on'Reuse: Components and Projects,'which are reused with minimal modification. Part IV is on'Remix: Snippets and Answers,'which examines how source code from the web can also be used as solutions to problems and answers to questions. The book concludes with Part V,'Looking Ahead,'that looks at future programming and the legalities of software reuse and remix and the implications of current intellectual property law on the future of software development. The story,'Richie Boss: Private InvestigatorManager,'was selected as the winner of a crowdfunded short story contest.'

Today, people use a large number of'systems'ranging in complexity from washing machines to international airline reservation systems. Computers are used in nearly all such systems: accuracy and security are becoming increasingly essential. The design of such computer systems should make use of development methods as systematic as those used in other engineering disciplines. A systematic development method must provide a way of writing specifications which are both precise and concise; it must also supply a way of relating design to specification. A concise specification can be achieved by restricting attention to what a system has to do: all considerations of implementation details are postponed. With computer systems, this is done by: 1) building an abstract model of the system -operations being specified by pre-and post-conditions; 2) defining languages by mapping program texts onto some collection of objects modelizing the concepts of the system to be dealt with, whose meaning is understood; 3) defining complex data objects in terms of abstractions known from mathematics. This last topic, the use of abstract data types, pervades all work on specifications and is necessary in order to apply ideas to systems of significant complexity. The use of mathematics based notations is the best way to achieve precision. 1.1 ABSTRACT DATA TYPES, PROOF TECHNIQUES From a practical point of view, a solution to these three problems consists to introduce abstract data types in the programming languages, and to consider formal proof methods.

While standardization has empowered the software industry to substantially scale software development and to provide affordable software to a broad market, it often does not address smaller market segments, nor the needs and wishes of individual customers. Software product lines reconcile mass production and standardization with mass customization in software engineering. Ideally, based on a set of reusable parts, a software manufacturer can generate a software product based on the requirements of its customer. The concept of features is central to achieving this level of automation, because features bridge the gap between the requirements the customer has and the functionality a product provides. Thus features are a central concept in all phases of product-line development. The authors take a developer's viewpoint, focus on the development, maintenance, and implementation of product-line variability, and especially concentrate on automated product derivation based on a user's feature selection. The book consists of three parts. Part I provides a general introduction to feature-oriented software product lines, describing the product-line approach and introducing the product-line development process with its two elements of domain and application engineering. The pivotal part II covers a wide variety of implementation techniques including design patterns, frameworks, components, feature-oriented programming, and aspect-oriented programming, as well as tool-based approaches including preprocessors, build systems, version-control systems, and virtual separation of concerns. Finally, part III is devoted to advanced topics related to feature-oriented product lines like refactoring, feature interaction, and analysis tools specific to product lines. In addition, an appendix listsvarious helpful tools for software product-line development, along with a description of how they relate to the topics covered in this book. To tie the book together, the authors use two running examples that are well documented in the product-line literature: data management for embedded systems, and variations of graph data structures. They start every chapter by explicitly stating the respective learning goals and finish it with a set of exercises; additional teaching material is also available online. All these features make the book ideally suited for teaching – both for academic classes and for professionals interested in self-study.

This text sheds light on how mathematical models and computing can help understanding and prediction of complicated physical processes; how communication networks should be designed and implemented to meet the increasingly challenging requirements from users; and how modern engineering principles can lead to better and more robust software systems. Through interviews with 12 internationally recognized researchers within these fields, conducted by the well-known science writer Dana Mackenzie and the science journalist Kathrine Aspaas, the reader gets views on recent achievements and future challenges. ​

In any serious engineering discipline, it would be unthinkable to construct a large system without having a precise notion of what is to be built and without verifying how the system is expected to function. Software engineering is no different in this respect. Formal methods involve the use of mathematical notation and calculus in software development; such methods are difficult to apply to large-scale systems with practical constraints (e.g., limited developer skills, time and budget restrictions, changing requirements). Here Liu claims that formal engineering methods may bridge this gap. He advocates the incorporation of mathematical notation into the software engineering process, thus substantially improving the rigor, comprehensibility and effectiveness of the methods commonly used in industry. This book provides an introduction to the SOFL (Structured Object-Oriented Formal Language) method that was designed and industry-tested by the author. Written in a style suitable for lecture courses or for use by professionals, there are numerous exercises and a significant real-world case study, so the readers are provided with all the knowledge and examples needed to successfully apply the method in their own projects.

This book is about a significant step forward in software development. It brings state-of-the-art ontology reasoning into mainstream software development and its languages. Ontology Driven Software Development is the essential, comprehensive resource on enabling technologies, consistency checking and process guidance for ontology-driven software development (ODSD). It demonstrates how to apply ontology reasoning in the lifecycle of software development, using current and emerging standards and technologies. You will learn new methodologies and infrastructures, additionally illustrated using detailed industrial case studies.The book will help you: Learn how ontology reasoning allows validations of structure models and key tasks in behavior models.Understand how to develop ODSD guidance engines for important software development activities, such as requirement engineering, domain modeling and process refinement.Become familiar with semantic standards, such as the Web Ontology Language (OWL) and the SPARQL query language.Make use of ontology reasoning, querying and justification techniques to integrate software models and to offer guidance and traceability supports.This book is helpful for undergraduate students and professionals who are interested in studying how ontologies and related semantic reasoning can be applied to the software development process. In addition, itwill also be useful for postgraduate students, professionals and researchers who are going to embark on their research in areas related to ontology or software engineering.