Abstract: Software product lines represent perhaps the most exciting paradigm shift in software development since the advent of high-level programming languages. Nowhere else in software engineering have we seen such breathtaking improvements in cost, quality, time to market, and developer productivity, often registering in the order-of-magnitude range. Here, the authors combine academic research results with real-world industrial experiences, thus presenting a broad view on product line engineering so that both managers and technical specialists will benefit from exposure to this work. They capture the wealth of knowledge that eight companies have gathered during the introduction of the software product line engineering approach in their daily practice.

Abstract: For any software developer who has spent days in “integration hell,” cobbling together myriad software components, Continuous Integration: Improving Software Quality and Reducing Risk illustrates how to transform integration from a necessary evil into an everyday part of the development process. The key, as the authors show, is to integrate regularly and often using continuous integration (CI) practices and techniques.The authors first examine the concept of CI and its practices from the ground up and then move on to explore other effective processes performed by CI systems, such as database integration, testing, inspection, deployment, and feedback. Through more than forty CI-related practices using application examples in different languages, readers learn that CI leads to more rapid software development, produces deployable software at every step in the development lifecycle, and reduces the time between defect introduction and detection, saving time and lowering costs. With successful implementation of CI, developers reduce risks and repetitive manual processes, and teams receive better project visibility.The book covers How to make integration a “non-event” on your software development projects How to reduce the amount of repetitive processes you perform when building your software Practices and techniques for using CI effectively with your teams Reducing the risks of late defect discovery, low-quality software, lack of visibility, and lack of deployable software Assessments of different CI servers and related tools on the market The book's companion Web site, www.integratebutton.com, provides updates and code examples.

Abstract: A comprehensive literature survey on approaches for mining software repositories (MSR) in the context of software evolution is presented. In particular, this survey deals with those investigations that examine multiple versions of software artifacts or other temporal information. A taxonomy is derived from the analysis of this literature and presents the work via four dimensions: the type of software repositories mined (what), the purpose (why), the adopted/invented methodology used (how), and the evaluation method (quality). The taxonomy is demonstrated to be expressive (i.e., capable of representing a wide spectrum of MSR investigations) and effective (i.e., facilitates similarities and comparisons of MSR investigations). Lastly, a number of open research issues in MSR that require further investigation are identified.

Abstract: Systematic reviews are one of the key building blocks of evidence-based software engineering. Current guidelines for such reviews are, for a large part, based on standard meta-analytic techniques. However, such quantitative techniques have only limited applicability to software engineering research. In this paper, therefore, we describe our experience with an approach to combine diverse study types in a systematic review of empirical research of agile software development.

Abstract: Software reliability engineering is focused on engineering techniques for developing and maintaining software systems whose reliability can be quantitatively evaluated. In order to estimate as well as to predict the reliability of software systems, failure data need to be properly measured by various means during software development and operational phases. Moreover, credible software reliability models are required to track underlying software failure processes for accurate reliability analysis and forecasting. Although software reliability has remained an active research subject over the past 35 years, challenges and open questions still exist. In particular, vital future goals include the development of new software reliability engineering paradigms that take software architectures, testing techniques, and software failure manifestation mechanisms into consideration. In this paper, we review the history of software reliability engineering, the current trends and existing problems, and specific difficulties. Possible future directions and promising research subjects in software reliability engineering are also addressed.

Abstract: Software engineering projects are inherently cooperative, requiring many software engineers to coordinate their efforts to produce a large software system. Integral to this effort is developing shared understanding surrounding multiple artifacts, each artifact embodying its own model, over the entire development process. This focus on model- oriented collaboration embedded within a larger process is what distinguishes collaboration research in software engineering from broader collaboration research, which tends to address artifact-neutral coordination technologies and toolkits. This article first presents a list of goals for software engineering collaboration, then surveys existing collaboration support tools in software engineering. The survey covers both tools that focus on a single artifact or stage in the development process (requirements support tools, UML collaboration tools), and tools that support the representation and execution of an entire software process. Important collaboration standards are also described. Several possible future directions for collaboration in software engineering are presented, including tight integration between web and desktop development environments, broader participation by customers and end users in the entire development process, capturing argumentation surrounding design rationale, and use of massively multiplayer online (MMO) game technology as a collaboration medium. The article concludes by noting a problem in performing research on collaborative systems, that of assessing how well certain artifacts, models, and embedded processes work, and whether they are better than other approaches.

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

Abstract: Basic ApproachFoundations of Software Testing is the premiere example-based text and reference for establishing sound engineering practices in test generation, selection, minimization and enhancement, for software projects ranging from the most simple to the highly complex, to those used by government agencies such as the FAA. Foundations of Software Testing also covers data-flow based adequacy and mutation-based adequacy, which are the most powerful of the available test adequacy criteria. It distills knowledge developed by hundreds of testing researchers and practitioners from all over the world and brings it to readers in an easy to understand form.Test generation, selection, priortization and assessment lie at the foundation of all technical activities that arise in a test process. Appropriate deployment of the elements of this strong foundation enables the testing of different types of software applications, including Object Oriented systems, Web services, graphical user interfaces, embedded systems, as well as properties relating to security, performance, and reliability. With over 200 examples and exercises of mathematical, step-by-step approaches, Foundations describes a wide variety of testing techniqes, including finite state models, combinatorial designs, and minimization for regression testing.Table of ContentsPart I: PRELIMINARIES1. Basics of Software TestingPart II: TEST GENERATION2. Test Generation from Requirements3. Test Generation from Finite-State Models4. Test Generation from Combinatorial Designs5. Test Selection, Minimization and Prioritization for Regression TestingPart III: TEST ADEQUACY ASSESSMENT AND ENHANCEMENT6. Test-Adequacy: Assessment Using Control Flow and Data Flow7. Test Adequacy Assessment Using Program MutationAbout the AuthorAditya P. Mathur is Professor and Head, Department of Computer Science, at Purdue University. He is one of the founders of the department of Computer Science at BITS, Pilani, India where he designed, developed, and taught the first course on microprocessors to undergraduate students from his seminal book Introduction to Microprocessors. Dr. Mathur has been a prolific researcher with over 100 published works in international journals and conferences. His key contributions include a multilingual computer, the saturation effect in software testing, a theory of software cybernetics, and novel techniques for the estimation of software reliability.Students, practitioners, and researchers will find this book an excellent source of simple to advanced techniques to use and improve their knowledge of and expertise in software testing.Praise for Foundations of Software Testing:"The book describes techniques in a lucid manner with great clarity with the help of numerous examples. Illustration of the techniques through appropriate examples makes the book very easy to study and assimilate the deep concepts and thus a unique book in the area of software testing.", Ashish Kundu, Graduate Student, Department of Computer Science, Purdue University." As a teacher of software testing and validation, I had to search for books that can be used as references in my class and I found that "Foundations of Software Testing" is the best one for at least the following reasons:- It covers a wide range of concepts related to software testing.- It introduces the different concepts smoothly with examples illustrating them. This helps students a lot in understanding the ideas behind each concept introduced.- The exercises at the end of each chapter test if the students understood the concepts properly and as expected.- The references of the book and the discussion at the end of each chapter both give the reader an opportunity to learn more. The slides are well prepared and organized. This facilitates the task of the professor when lecturing.", Professor Abdeslam En-nouaary, Concordia University."This book teaches software testing as a science and not as an art. It not only presents an engineering approach for handling different testing tasks but, also sets up the formal framework for the presented technique. Thus when compared to other books on testing it can be readily used as a resource by both practitioners and researchers which in my view is the real strength of this book.Initially I thought that there is still much that can be added to this book, but seeing the list of chapters that would be added in subsequent volumes I believe that for the complete set of volumes it would be very difficult to suggest drastic improvements.", Ammar Masood, Graduate student, Department of Electrical and Computer Engineering, Purdue University."So far, I like your book. Plenty of definitions and terminology that is clearly presented." Christine Ayers, undergraduate student, UT Dallas.

Abstract: Lean software development is the application of the principles of the Toyota product development system to software development. Toyota has been extremely successful developing complex new vehicles, which include a vast amount of embedded software, in a very short time and always on time. This tutorial examines the underlying engineering principles Toyota uses to develop vehicles and shows how they can be applied to software development. When correctly applied, lean software development results in high quality software that is developed quickly and at the lowest possible cost. Moreover, the success of many of the practices of Agile Software Development can be explained by understanding the principles of Lean Software development.

Abstract: One aim of component-based software engineering (CBSE) is to enable the prediction of extra-functional properties, such as performance and reliability, utilising a well-defined composition theory. Nowadays, such theories and their accompanying prediction methods are still in a maturation stage. Several factors influencing extra-functional properties need additional research to be understood. A special problem in CBSE stems from its specific development process: Software components should be specified and implemented independent from their later context to enable reuse. Thus, extra-functional properties of components need to be specified in a parametric way to take different influence factors like the hardware platform or the usage profile into account. In our approach, we use the Palladio Component Model (PCM) to specify component-based software architectures in a parametric way. This model offers direct support of the CBSE development process by dividing the model creation among the developer roles. In this paper, we present our model and a simulation tool based on it, which is capable of making performance predictions. Within a case study, we show that the resulting prediction accuracy can be sufficient to support the evaluation of architectural design decisions.

Abstract: Software patterns have revolutionized the way developers and architects think about how software is designed, built and documented. This new title in Wileys prestigious Series in Software Design Patterns presents proven techniques to achieve patterns for fault tolerant software. This is a key reference for experts seeking to select a technique appropriate for a given system. Readers are guided from concepts and terminology, through common principles and methods, to advanced techniques and practices in the development of software systems. References will provide access points to the key literature, including descriptions of exemplar applications of each technique. Organized into a collection of software techniques, specific techniques can be easily found with sufficient detail to allow appropriate choices for the system being designed.

Abstract: In this paper we discuss the impact of open source on both the security and transparency of a software system. We focus on the more technical aspects of this issue, combining and extending arguments developed over the years. We stress that our discussion of the problem only applies to software for general purpose computing systems. For embedded systems, where the software usually cannot easily be patched or upgraded, different considerations may apply.

Abstract: Software development processes are often not explicitly modelled and sometimes even chaotic. In order to keep track of the involved documents and files, engineers use Software Configuration Management (SCM) systems. Along the way, those systems collect and store information on the software process itself. Thus, SCM information can be used for constructing explicit process models, which is called software process mining. In this paper we show that (1) a Process Mining Framework can be used for obtaining software process models as well as for analysing and optimising them; (2) an algorithmic approach, which arose from our research on software processes, is integrated in the framework.

Abstract: We are exploring the practice of large-scale reuse involving at least a group of source code files. Our research question is to determine the extent of such reuse occurring in open source projects, to identify the code that is reused the most, and to investigate patterns of large-scale reuse. We start by identifying a sample of projects involving all code in several large repositories of open source projects, all projects bundled with popular distributions of Linux and BSD, and several large individual projects. In the next step we obtain the source code and identify groups of files reused among projects and determine the code that is most widely reused in our sample. Our findings indicate that more than 50% of the files were used in more than one project. The most widely reused components were small and represented templates requiring major and minor modifications and a group of files reused without any change. Some widely reused components involved hundreds of files.

Abstract: Foreword Preface Acknowledgments Section 1 Introduction to Software Cost Estimation Chapter 1 Introduction Chapter 2 The Origins of Software Cost Estimation Chapter 3 Six Forms of Software Cost Estimation Chapter 4 Software Cost Estimating Tools and Project Success and Failure Rates Chapter 5 Sources of Error in Software Cost Estimation Section 2 Preliminary Estimation Methods Chapter 6 Manual Software Estimating Methods Chapter 7 Manual Software Estimating Methods Derived from Agile Projects and New Chapter 8 Automated Estimates from Minimal Data Section 3 Sizing Software Deliverables Chapter 9 Sizing Software Deliverables Section 4 Cost Estimating Adjustment Factors Chapter 10 Compensation and Work-Pattern Adjustments Chapter 11 Activity Pattern Adjustment Factors Chapter 12 Software Technology Adjustment Factors Section 5 Activity-Based Software Estimating Chapter 13 Estimating Software Requirements Chapter 14 Estimating Software Prototypes Chapter 15 Estimating Software Specifications and Design Chapter 16 Estimating Design Inspections Chapter 17 Estimating Programming or Coding Chapter 18 Estimating Code Inspections Chapter 19 Estimating Software Configuration Control and Change Management Chapter 20 Estimating Software Testing Chapter 21 Estimating User and Project Documentation Chapter 22 Estimating Software Project Management Section 6 Maintenance and Enhancement Cost Estimating Chapter 23 Maintenance and Enhancement Estimating Chapter 24 Software Cost-Estimating Research Issues Index

Abstract: Competisoft provides the Latin American software industry with a reference framework for improvement and certification of its software processes.The project is based on proven solutions, including the MoProSoft model that four Mexican software companies applied to increase their processes' capacity level.

Abstract: During software evolution, information about changes between different versions of a program is useful for a number of software engineering tasks. For example, configuration-management systems can use change information to assess possible conflicts among updates from different users. For another example, in regression testing, knowledge about which parts of a program are unchanged can help in identifying test cases that need not be rerun. For many of these tasks, a purely syntactic differencing may not provide enough information for the task to be performed effectively. This problem is especially relevant in the case of object-oriented software, for which a syntactic change can have subtle and unforeseen effects. In this paper, we present a technique for comparing object-oriented programs that identifies both differences and correspondences between two versions of a program. The technique is based on a representation that handles object-oriented features and, thus, can capture the behavior of object-oriented programs. We also present JDiff, a tool that implements the technique for Java programs. Finally, we present the results of four empirical studies, performed on many versions of two medium-sized subjects, that show the efficiency and effectiveness of the technique when used on real programs.

Abstract: Depicting applications of several machine learning approaches in software systems development and deployment, this text provides analysis, characterization, and refinement of software engineering data in terms of machine learning methods.

Abstract: GQM+Strategies is a measurement approach that builds on the well-tested GQM approach to planning and implementing software measurement. Although GQM has proven itself useful in a variety of industrial settings, one recognized weakness is the difficulty for GQM users to link software measurement goals to higher-level goals of the organization in which the software is being developed. This linkage is important, as it helps to justify software measurement efforts and allows measurement data to contribute to higher-level decisions. GQM+strategies provides mechanisms for explicitly linking software measurement goals, to higher-level goals for the software organization, and further to goals and strategies at the level of the entire business.

Abstract: With today's ever increasing demands on software, developers must produce software that can be changed without the risk of degrading the software architecture. Degraded software architecture is problematic because it makes the system more prone to defects and increases the cost of making future changes. The effects of making changes to software can be difficult to measure. One way to address software changes is to characterize their causes and effects. This paper introduces an initial architecture change characterization scheme created to assist developers in measuring the impact of a change on the architecture of the system. It also presents an initial study conducted to gain insight into the validity of the scheme. The results of this study indicated a favorable view of the viability of the scheme by the subjects, and the scheme increased the ability of novice developers to assess and adequately estimate change effort.

Abstract: Projects combining agile methods with CMMI1 are more successful in producing higher quality software that more effectively meets customer needs at a faster pace. Systematic Software Engineering works at CMMI level 5 and uses lean Software Development as a driver for optimizing software processes. Early pilot projects at Systematic showed productivity on Scrum teams almost twice that of traditional teams. Other projects demonstrated a story based test driven approach to software development reduced defects found during final test by 40%. We assert that Scrum and CMMI together bring a more powerful combination of adaptability and predictability than either one alone and suggest how other companies can combine them.

Abstract: Most of the models for software reliability analysis are based on reliability growth models which deal with the fault detection process. This is done either by assuming that faults are corrected immediately after being detected or the time to correct a fault is not counted. Some models have been developed to relax this assumption. However, unlike the fault-detection process, few published data sets are available to support the modeling and analysis of both the fault detection and removal processes. In this paper, some useful approaches to the modeling of both software fault-detection and fault-correction processes are discussed. Further analysis on the software release time decision that incorporates both a fault-detection model and fault-correction model is also presented. This procedure is easy to use and useful for practical applications. The approach is illustrated with an actual set of data from a software development project. Copyright © 2006 John Wiley & Sons, Ltd.

Abstract: Robot Software: Principles and Challenges.- Trends in Robot Software Domain Engineering.- Stable Analysis Patterns for Robot Mobility.- The CLARAty Project: Coping with Hardware and Software Heterogeneity.- Simulation and Testbeds of Autonomous Robots in Harsh Environments.- Writing Code in the Field: Implications for Robot Software Development.- Software Environments for Robot Programming.- Sidebar - Programming Commercial Robots.- Component-Based Robotics.- Trends in Component-Based Robotics.- CoolBOT: A Component Model and Software Infrastructure for Robotics.- ROCI: Strongly Typed Component Interfaces for Multi-robot Teams Programming.- Communication Patterns as Key Towards Component Interoperability.- Using MARIE for Mobile Robot Component Development and Integration.- Orca: A Component Model and Repository.- Sidebar - Software Architectures.- Robotic Software Frameworks.- Trends in Robotic Software Frameworks.- Reusable Robot Software and the Player/Stage Project.- An Integration Framework for Developing Interactive Robots.- Increasing Decoupling in the Robotics4.NET Framework.- VIP: The Video Image Processing Framework Based on the MIRO Middleware.- MRT: Robotics Off-the-Shelf with the Modular Robotic Toolkit.- Towards Framework-Based UxV Software Systems: An Applied Research Perspective.- Sidebar - Middlewares for Distributed Computing.- Software Environments for Networked Robotics.- Trends in Software Environments for Networked Robotics.- Advanced Teleoperation Architecture.- A Multi-robot-Multi-operator Collaborative Virtual Environment.- Modularity and Mobility of Distributed Control Software for Networked Mobile Robots.- Sidebar - Java3D for Web-Based Robot Control.

Abstract: Competisoft provides the Latin American software industry with a reference framework for improvement and certification of its software processes.The project is based on proven solutions, including the MoProSoft model that four Mexican software companies applied to increase their processes’ capacity level.