Abstract: Open source software products represent the leading edge of innovation development and diffusion systems conducted for and by users themselves - no manufacturer required. Research into this phenomenon has so far focused on how the major tasks of software development are organized and motivated. But a complete user system requires the execution of "mundane but necessary" tasks as well. In this paper, we explore how the mundane but necessary task of field support for open source Apache server software is organized, and how and why users are motivated to participate in providing it. We find that the present system works well and that information providers are largely rewarded by benefits directly received from a related task. We also find, however, that the present help system is by and for only a few - and that changes would be needed if and as volume increases. General lessons for user-based innovation systems includes the clear willingness of users to openly reveal their proprietary information. This bodes well for the efficiency of user-only innovation systems. Open revealing is rational behavior if the information has low competitive value and/or if information providers think that other users know the same thing they do, and would reveal the information if they did not.

Abstract: From the Publisher: Designing application and middleware software to run in concurrent and networked environments is a significant challenge to software developers The patterns catalogued in this second volume of Pattern-Oriented Software Architectures (POSA) form the basis of a pattern language that addresses issues associated with concurrency and networking The book presents 17 interrelated patterns ranging from idioms through architectural designs They cover core elements of building concurrent and network systems: service access and configuration, event handling, synchronization, and concurrency All patterns present extensive examples and known uses in multiple programming languages, including C++, C, and Java The book can be used to tackle specific software development problems or read from cover to cover to provide a fundamental understanding of the best practices for constructing concurrent and networked applications and middleware About the Authors This book has been written by the award winning team responsible for the first POSA volume "A System of Patterns", joined in this volume by Douglas C Schmidt from University of California, Irvine (UCI), USA Visit our Web Page

Abstract: This book is a must-have for all IT professionals facing software development problems on a daily basis. If you are a systems analyst or requirements engineer it will provide an essential, practical guide from the task of identifying the problem to making the descriptions needed to resolve it.

Abstract: The software industry has practiced pair programming (two programmers working side by side at one computer on the same problem) with great success for years, but people who haven't tried it often reject the idea as a waste of resources. The authors demonstrate that using pair programming in the software development process yields better products in less time-and happier, more confident programmers.

Abstract: Most consumer electronics today contain embedded software. In the early days, developing CE software presented relatively minor challenges, but in the past several years three significant problems have arisen: size and complexity of the software in individual products; the increasing diversity of products and their software; and the need for decreased development time. The question of handling diversity and complexity in embedded software at an increasing production speed becomes an urgent one. The authors present their belief that the answer lies not in hiring more software engineers. They are not readily available, and even if they were, experience shows that larger projects induce larger lead times and often result in greater complexity. Instead, they believe that the answer lies in the use and reuse of software components that work within an explicit software architecture. The Koala model, a component-oriented approach detailed in this article, is their way of handling the diversity of software in consumer electronics. Used for embedded software in TV sets, it allows late binding of reusable components with no additional overhead.

Abstract: The production of new management approaches to evolution, leading to understanding of the relationships between technology and business. How can software be designed so that it can easily be evolved? More effective tools and methods for program comprehension for both code and data A better formalism and conceptualisation of 'maintainability'; how do we measure it? The development of a service-based model of software, to replace a product view. better

Abstract: In many studies in software engineering students are used instead of professional software developers, although the objective is to draw conclusions valid for professional software developers. This paper presents a study where the difference between the two groups is evaluated. People from the two groups have individually carried out a non-trivial software engineering judgement task involving the assessment of how ten different factors affect the lead-time of software development projects. It is found that the differences are only minor, and it is concluded that software engineering students may be used instead of professional software developers under certain conditions. These conditions are identified and described based on generally accepted criteria for validity evaluation of empirical studies.

Abstract: In today's software development environment, requirements often change during the product development life-cycle to meet shifting business demands, creating endless headaches for development teams. We discuss our experience in implementing the Scrum software development process to address these concerns.

Abstract: This paper summarizes several classes of software cost estimation models and techniques: parametric models, expertisedbased techniques, learningdoriented techniques, dynamicsdbased models, regressiondbased models, and compositedBayesian techniques for integrating expertisedbased and regressiondbased models. Experience to date indicates that neuraldnet and dynamicsdbased techniques are less mature than the other classes of techniques, but that all classes of techniques are challenged by the rapid pace of change in software technology. The primary conclusion is that no single technique is best for all situations, and that a careful comparison of the results of several approaches is most likely to produce realistic estimates.

Abstract: To create successful interactive systems, user interface designers need to cooperate with developers and application domain experts in an interdisciplinary team. These groups, however, usually miss a common terminology to exchange ideas, opinions, and values.This paper presents an approach that uses pattern languages to capture this knowledge in software development, HCI, and the application domain. A formal, domain-independent definition of design patterns allows for computer support without sacrificing readability, and pattern use is integrated into the usability engineering life cycle.As an example, experience from building an award-winning interactive music exhibit was turned into a pattern language, which was then used to inform follow-up projects and support HCI education.

Abstract: According to its proponents, open source style software development has the capacity to compete successfully, and perhaps in many cases displace, traditional commercial development methods. In order to begin investigating such claims, we examine the development process of a major open source application, the Apache web server. By using email archives of source code change history and problem reports we quantify aspects of developer participation, core team size, code ownership, productivity, defect density, and problem resolution interval for this OSS project. This analysis reveals a unique process, which performs well on important measures. We conclude that hybrid forms of development that borrow the most effective techniques from both the OSS and commercial worlds may lead to high performance software processes.

Abstract: Is there such a thing anymore as a software system that doesn’t need to be secure? Almost every softwarecontrolled system faces threats from potential adversaries, from Internet-aware client applications running on PCs, to complex telecommunications and power systems accessible over the Internet, to commodity software with copy protection mechanisms. Software engineers must be cognizant of these threats and engineer systems with credible defenses, while still delivering value to customers. In this paper, we present our perspectives on the research issues that arise in the interactions between software engineering and security.

Abstract: From the Book: Preface How much would you pay for a software development team that would do what you want? Wait, don't answer yet—what if they could also tell you how much it would cost, so that you could decide what to do and what to defer, on your way to your deadline? You also get quality software, a robust array of tests that support the project through its entire lifecycle, and an up-to-date, clear view of project status. Best of all, you get the ability to change your mind about what you want, at any time. There aren't any silver bullets in software development, and there probably never will be. However, Extreme Programming is a simple set of common-sense practices that, when used together, really can give you much of what you just read in the paragraph above. In this book, we tell you what the XP practices are, and how to install them in your project. We are software developers. We have been involved in many successful projects, and even in some that weren't so successful. The successful ones were a lot more fun, for us, and for our customers. The unsuccessful ones have taught us a great deal about software development. We have had the privilege of working on a great project, with a great teacher, Kent Beck. We helped shape the software process named Extreme Programming, XP for short. Since then, we have been helping everyone who will listen to learn from our experience. The first book in the Extreme Programming series, Extreme Programming Explained , covers the reasoning behind the XP process. Based on our experience on the original XP project (and others), this book describes what makes XP work, day to day and monthto month. Successful software development is a team effort—not just the development team but the larger team consisting of customers, management, and developers. Extreme Programming is a simple process that brings these people together and helps them to succeed together. XP is aimed primarily at object-oriented projects using teams of a dozen or fewer programmers in one location. We would use XP for both in-house development and development of shrink-wrapped software. The principles of XP apply to any moderately sized project that needs to deliver quality software rapidly and flexibly. XP is about balancing the needs of customers with the abilities of programmers, and about steering (managing the project to success). If you're a customer, a programmer, or a manager, here's what this book offers you: Customers—who have software that needs to be developed: you will learn simple, effective ways to communicate what you need, to be sure that you are getting what you need, and to steer the project to success. You will learn that you can change your mind and still get what you need on time. Programmers—who, on an XP project, define the architecture, design the system, and write the tests and the code that support them: you will learn how to deliver business value quickly, how to deal with changing requirements, and how to build customer confidence and support. You will learn to build for tomorrow by building only what you need today. Managers—who control the project resources: you will learn how to measure project progress, how to measure quality, and how to answer the all-important question, "When will you be done?" You will learn an important truth of management—to use the programmers' actual performance to predict completion. Customers, programmers, and managers must all work together to build the system that's needed. Chapter 1, Extreme Programming, will describe the roles, rights, and responsibilities, and provide a road map for the book. Dig right in. We're sure that the XP practices can improve your projects, as they have ours.

Abstract: Reducing the number of software failures is one of the most challenging problems of software production. We assume that software development proceeds as a series of changes and model the probability that a change to software will cause a failure. We use predictors based on the properties of a change itself. Such predictors include size in lines of code added, deleted, and unmodified; diffusion of the change and its component subchanges, as reflected in the number of files, modules, and subsystems touched, or changed; several measures of developer experience; and the type of change and its subchanges (fault fixes or new code). The model is built on historic information and is used to predict the risk of new changes. In this paper we apply the model to 5ESS® software updates and find that change diffusion and developer experience are essential to predicting failures. The predictive model is implemented as a Web-based tool to allow timely prediction of change quality. The ability to predict the quality of change enables us to make appropriate decisions regarding inspection, testing, and delivery. Historic information on software changes is recorded in many commercial software projects, suggesting that our results can be easily and widely applied in practice.

Abstract: Testing is an important process that is performed to support quality assurance. Testing activities support quality assurance by gathering information about the nature of the software being studied. These activities consist of designing test cases, executing the software with those test cases, and examining the results produced by those executions. Studies indicate that more than fty percent of the cost of software development is devoted to testing, with the percentage for testing critical software being even higher. As software becomes more pervasive and is used more often to perform critical tasks, it will be required to be of higher quality. Unless we can nd ecient ways to perform eective testing, the percentage of development costs devoted to testing will increase signicantly. This report briefly assesses the state of the art in software testing, outlines some future directions in software testing, and gives some pointers to software testing resources.

Abstract: Software metrics as a subject area is over 30 years old, but it has barely penetrated into mainstream software engineering. A key reason for this is that most software metrics activities have not addressed their most important requirement: to provide information to support quantitative managerial decision-making during the software lifecycle. Good support for decision-making implies support for risk assessment and reduction. Yet traditional metrics approaches, often driven by regression-based models for cost estimation and defects prediction, provide little support for managers wishing to use measurement to analyse and minimise risk. The future for software metrics lies in using relatively simple existing metrics to build management decision-support tools that combine different aspects of software development and testing and enable managers to make many kinds of predictions, assessments and trade-offs during the software life-cycle. Our recommended approach is to handle the key factors largely missing from the usual metrics approaches, namely: causality, uncertainty, and combining different (often subjective) evidence. Thus the way forward for software metrics research lies in causal modelling (we propose using Bayesian nets), empirical software engineering, and multi-criteria decision aids.

Abstract: Since early 1980 an exponential blowup of cellular mobile systems has been observed, which has produced, all over the world, the definition of a plethora of analog and digital standards. In 2000 the industrial competition between Asia, Europe, and America promises a very difficult path toward the definition of a unique standard for future mobile systems, although market analyses underline the trading benefits of a common worldwide standard. It is therefore in this field that the software radio concept is emerging as a potential pragmatic solution: a software implementation of the user terminal able to dynamically adapt to the radio environment in which it is, time by time, located. In fact, the term software radio stands for radio functionalities defined by software, meaning the possibility to define by software the typical functionality of a radio interface, usually implemented in TX and RX equipment by dedicated hardware. The presence of the software defining the radio interface necessarily implies the use of DSPs to replace dedicated hardware, to execute, in real time, the necessary software. In this article objectives, advantages, problem areas, and technological challenges of software radio are addressed. In particular, SW radio transceiver architecture, possible SW implementation, and its download are analyzed.

Abstract: In this article, the author outlines an approach to marketing planning for radically new products, disruptive or discontinuous innovations that change the dimensionality of the consumer decision. The planning process begins with an extensive situation analysis. The factors identified in the situation analysis are woven into the economic webs surrounding the new product. The webs are mapped into Bayesian networks that can be updated as events unfold and used to simulate the impact that changes in assumptions underlying the web have on the prospects for the new product. The author illustrates this method using a historical case regarding the introduction of videotape recorders by Sony and JVC and a contemporary case of the introduction of electric vehicles. The author provides a complete, numerical example pertaining to a software development project in the Appendix.

Abstract: Computer simulations provide a framework for exploring the biomechanics of movement. The authors have developed a software system that lets users create computer graphics simulations of human and animal movement. This software provides a platform on which the biomechanics community can build a library of simulations that can be exchanged, tested and improved through multi-institutional collaboration.

Abstract: This paper examines and proposes an approach to writing software specifications, based on research in systems theory, cognitive psychology and human-machine interaction. The goal is to provide specifications that support human problem solving and the tasks that humans must perform in software development and evolution. A type of specification, called intent specifications, is constructed upon this underlying foundation.

Abstract: CGAL is a Computational Geometry Algorithms Library written in C++. The goal is to make the large body of geometric algorithms developed inthe field of computational geometry available for industrial application. In this report we discuss the major design goals for CGAL, which are correctne- ss, flexibility, ease-of-use, efficiency, and robustness, and present our approach to reach these goals. Templates and the relatively new generic programming play a central role in the architecture of CGAL. We give a short introduction to generic programming in C++, compare it to the object-oriented programming paradigm, and present examples where both paradigms are used effectively in CGAL. Moreover, we give an overview on the current structure of the library and consider software engineering aspects in the CGAL-project.

Abstract: The software clustering literature contains many different approaches that attempt to automatically decompose software systems. These approaches commonly utilize criteria or measures based on principles such as high cohesion and low coupling, information hiding etc. We present an algorithm that subscribes to a philosophy targeted towards program comprehension and based on subsystem patterns. We discuss the algorithm's implementation and describe experiments that demonstrate its usefulness.

Abstract: For the past 40 years, the techniques, processes and methods of software development have been dominated by supply-side issues, giving rise to a software industry oriented towards developers rather than users. To achieve the levels of functionality, flexibility and time-to-market required by users, a radical shift is required in the development of software, with a more demand-centric view, leading to software which will be delivered as a service within the framework of an open marketplace. Already, there are some signs that this approach is being adopted by industry, but in a very limited way. We summarise research and a research method which has resulted in a long-term strategic view of software engineering innovation. Based on this foundation, we describe more recent work, which has resulted in an innovative demand-side model for the future of software. We propose a service architecture in which components may be bound instantly, just at the time they are needed, and then the binding may be discarded. A major benefit of this approach is that it leads to highly flexible and agile software that should be able to meet rapidly changing business needs.

Abstract: vii 1 Nothing New Under the Sun? 1 2 Software Component Technology 3 Summary of Key Points 5 3 Vision Statement 7 Summary of Key Points 8 4 Components 9 Summary of Key Points 10 5 Interfaces 11 5.1 Interface Abstraction and Application Programming Interfaces 11 5.2 Extending APIs to Extra-Functional Properties 12 5.2.1 Specifying Behavior 12 5.2.2 Specifying Synchronization 13 5.2.3 Specifying Quality of Service 13 5.3 Credentials 14 5.4 Components and Multiple Interfaces 15 Summary of Key Points 16 6 Contracts 17 6.1 Contracts and Reciprocal Obligations 18 6.2 Two Senses of Contract 20 Summary of Key Points 21 7 Component Models and Frameworks 23 7.1 What are Component Models? 23 7.2 Component Framework 25 7.3 Custom Frameworks and Programmable Middleware 26 Summary of Key Points 28

Abstract: Software development organizations are now discovering the efficiencies that can be achieved by architecting entire software product families together. In Software Architecture for Product Families, experts from one of the worlds most advanced software domain engineering projects share in-depth insights about the techniques that work -and those that dont. The book offers a solutions-oriented, case-study approach covering the entire development lifecycle, based on advanced work done by three of Europes leading technology companies and their academic partners. Discover the challenges that drive companies to consider architecting product families, and the new problems they encounter in doing so. Master concepts and terms that can be used to describe the architecture of a product family; then learn how to assess that architecture, and transform it into working applications. The authors also present chapter-length, realworld case studies of domain engineering projects at Nokia, Philips, and ABB.

Abstract: Sophisticated modeling and analysis methods are being developed in academic and industrial research labs for reliability engineering and other domains. The evaluation and evolution of such methods based on use in practice is critical to research progress, but few such methods see widespread use. A critical impediment to disseminating new methods is the inability to produce, at a reasonable cost, supporting software tools that have the: usability and dependability characteristics that industrial users require; and evolvability to accommodate software change as the underlying analysis methods are refined and enhanced. The difficulty of software development thus emerges as a key impediment to advances in engineering modeling and analysis. This paper presents an approach to tool development that attacks these problems. Progress requires synergistic, interdisciplinary collaborations between application-domain and software-engineering researchers. The authors have pursued such an approach in developing Galileo: a fault tree modeling and analysis tool. These innovations are described in two dimensions: (1) the Galileo core reliability modeling and analysis function; and (2) the authors' work on software engineering for high-quality, low-cost modeling and analysis tools.

Abstract: Software’s increasingly critical role in systems of widespread significance presents new challenges for the education of software engineers. Not only is our dependence on software increasing, but the character of software production is itself changing ‐ and with it the demands on the software developers. Four challenges for educators of software developers help identify aspirations for software engineering education.

Abstract: Software Product Lines are large systems intended for reuse in concrete products. As such these large systems provide reusable architecture and implementation that the individual products have in common. The differences between the product are left open. We refer to these open spots as variability points. In this article we provide a conceptual framework of terminology for the concept of variability and we discuss how variability can be managed in Software Product Lines.